/*
* 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.lucene.util;
import org.apache.lucene.analysis.Token;
import org.apache.lucene.analysis.TokenStream;
import org.apache.lucene.analysis.tokenattributes.*;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class TestAttributeSource extends LuceneTestCase {
public void testCaptureState() {
// init a first instance
AttributeSource src = new AttributeSource();
CharTermAttribute termAtt = src.addAttribute(CharTermAttribute.class);
TypeAttribute typeAtt = src.addAttribute(TypeAttribute.class);
termAtt.append("TestTerm");
typeAtt.setType("TestType");
final int hashCode = src.hashCode();
AttributeSource.State state = src.captureState();
// modify the attributes
termAtt.setEmpty().append("AnotherTestTerm");
typeAtt.setType("AnotherTestType");
assertTrue("Hash code should be different", hashCode != src.hashCode());
src.restoreState(state);
assertEquals("TestTerm", termAtt.toString());
assertEquals("TestType", typeAtt.type());
assertEquals("Hash code should be equal after restore", hashCode, src.hashCode());
// restore into an exact configured copy
AttributeSource copy = new AttributeSource();
copy.addAttribute(CharTermAttribute.class);
copy.addAttribute(TypeAttribute.class);
copy.restoreState(state);
assertEquals("Both AttributeSources should have same hashCode after restore", src.hashCode(), copy.hashCode());
assertEquals("Both AttributeSources should be equal after restore", src, copy);
// init a second instance (with attributes in different order and one additional attribute)
AttributeSource src2 = new AttributeSource();
typeAtt = src2.addAttribute(TypeAttribute.class);
FlagsAttribute flagsAtt = src2.addAttribute(FlagsAttribute.class);
termAtt = src2.addAttribute(CharTermAttribute.class);
flagsAtt.setFlags(12345);
src2.restoreState(state);
assertEquals("TestTerm", termAtt.toString());
assertEquals("TestType", typeAtt.type());
assertEquals("FlagsAttribute should not be touched", 12345, flagsAtt.getFlags());
// init a third instance missing one Attribute
AttributeSource src3 = new AttributeSource();
termAtt = src3.addAttribute(CharTermAttribute.class);
// The third instance is missing the TypeAttribute, so restoreState() should throw IllegalArgumentException
expectThrows(IllegalArgumentException.class, () -> {
src3.restoreState(state);
});
}
public void testCloneAttributes() {
final AttributeSource src = new AttributeSource();
final FlagsAttribute flagsAtt = src.addAttribute(FlagsAttribute.class);
final TypeAttribute typeAtt = src.addAttribute(TypeAttribute.class);
flagsAtt.setFlags(1234);
typeAtt.setType("TestType");
final AttributeSource clone = src.cloneAttributes();
final Iterator<Class<? extends Attribute>> it = clone.getAttributeClassesIterator();
assertEquals("FlagsAttribute must be the first attribute", FlagsAttribute.class, it.next());
assertEquals("TypeAttribute must be the second attribute", TypeAttribute.class, it.next());
assertFalse("No more attributes", it.hasNext());
final FlagsAttribute flagsAtt2 = clone.getAttribute(FlagsAttribute.class);
assertNotNull(flagsAtt2);
final TypeAttribute typeAtt2 = clone.getAttribute(TypeAttribute.class);
assertNotNull(typeAtt2);
assertNotSame("FlagsAttribute of original and clone must be different instances", flagsAtt2, flagsAtt);
assertNotSame("TypeAttribute of original and clone must be different instances", typeAtt2, typeAtt);
assertEquals("FlagsAttribute of original and clone must be equal", flagsAtt2, flagsAtt);
assertEquals("TypeAttribute of original and clone must be equal", typeAtt2, typeAtt);
// test copy back
flagsAtt2.setFlags(4711);
typeAtt2.setType("OtherType");
clone.copyTo(src);
assertEquals("FlagsAttribute of original must now contain updated term", 4711, flagsAtt.getFlags());
assertEquals("TypeAttribute of original must now contain updated type", "OtherType", typeAtt.type());
// verify again:
assertNotSame("FlagsAttribute of original and clone must be different instances", flagsAtt2, flagsAtt);
assertNotSame("TypeAttribute of original and clone must be different instances", typeAtt2, typeAtt);
assertEquals("FlagsAttribute of original and clone must be equal", flagsAtt2, flagsAtt);
assertEquals("TypeAttribute of original and clone must be equal", typeAtt2, typeAtt);
}
public void testDefaultAttributeFactory() throws Exception {
AttributeSource src = new AttributeSource();
assertTrue("CharTermAttribute is not implemented by CharTermAttributeImpl",
src.addAttribute(CharTermAttribute.class) instanceof CharTermAttributeImpl);
assertTrue("OffsetAttribute is not implemented by OffsetAttributeImpl",
src.addAttribute(OffsetAttribute.class) instanceof OffsetAttributeImpl);
assertTrue("FlagsAttribute is not implemented by FlagsAttributeImpl",
src.addAttribute(FlagsAttribute.class) instanceof FlagsAttributeImpl);
assertTrue("PayloadAttribute is not implemented by PayloadAttributeImpl",
src.addAttribute(PayloadAttribute.class) instanceof PayloadAttributeImpl);
assertTrue("PositionIncrementAttribute is not implemented by PositionIncrementAttributeImpl",
src.addAttribute(PositionIncrementAttribute.class) instanceof PositionIncrementAttributeImpl);
assertTrue("TypeAttribute is not implemented by TypeAttributeImpl",
src.addAttribute(TypeAttribute.class) instanceof TypeAttributeImpl);
}
@SuppressWarnings({"rawtypes","unchecked"})
public void testInvalidArguments() throws Exception {
expectThrows(IllegalArgumentException.class, () -> {
AttributeSource src = new AttributeSource();
src.addAttribute(Token.class);
fail("Should throw IllegalArgumentException");
});
expectThrows(IllegalArgumentException.class, () -> {
AttributeSource src = new AttributeSource(Token.TOKEN_ATTRIBUTE_FACTORY);
src.addAttribute(Token.class);
});
expectThrows(IllegalArgumentException.class, () -> {
AttributeSource src = new AttributeSource();
// break this by unsafe cast
src.addAttribute((Class) Iterator.class);
});
}
public void testLUCENE_3042() throws Exception {
final AttributeSource src1 = new AttributeSource();
src1.addAttribute(CharTermAttribute.class).append("foo");
int hash1 = src1.hashCode(); // this triggers a cached state
final AttributeSource src2 = new AttributeSource(src1);
src2.addAttribute(TypeAttribute.class).setType("bar");
assertTrue("The hashCode is identical, so the captured state was preserved.", hash1 != src1.hashCode());
assertEquals(src2.hashCode(), src1.hashCode());
}
public void testClonePayloadAttribute() throws Exception {
// LUCENE-6055: verify that PayloadAttribute.clone() does deep cloning.
PayloadAttributeImpl src = new PayloadAttributeImpl(new BytesRef(new byte[] { 1, 2, 3 }));
// test clone()
PayloadAttributeImpl clone = src.clone();
clone.getPayload().bytes[0] = 10; // modify one byte, srcBytes shouldn't change
assertEquals("clone() wasn't deep", 1, src.getPayload().bytes[0]);
// test copyTo()
clone = new PayloadAttributeImpl();
src.copyTo(clone);
clone.getPayload().bytes[0] = 10; // modify one byte, srcBytes shouldn't change
assertEquals("clone() wasn't deep", 1, src.getPayload().bytes[0]);
}
public void testRemoveAllAttributes() {
List<Class<? extends Attribute>> attrClasses = new ArrayList<>();
attrClasses.add(CharTermAttribute.class);
attrClasses.add(OffsetAttribute.class);
attrClasses.add(FlagsAttribute.class);
attrClasses.add(PayloadAttribute.class);
attrClasses.add(PositionIncrementAttribute.class);
attrClasses.add(TypeAttribute.class);
// Add attributes with the default factory, then try to remove all of them
AttributeSource defaultFactoryAttributeSource = new AttributeSource();
assertFalse(defaultFactoryAttributeSource.hasAttributes());
for (Class<? extends Attribute> attrClass : attrClasses) {
defaultFactoryAttributeSource.addAttribute(attrClass);
assertTrue("Missing added attribute " + attrClass.getSimpleName(),
defaultFactoryAttributeSource.hasAttribute(attrClass));
}
defaultFactoryAttributeSource.removeAllAttributes();
for (Class<? extends Attribute> attrClass : attrClasses) {
assertFalse("Didn't remove attribute " + attrClass.getSimpleName(),
defaultFactoryAttributeSource.hasAttribute(attrClass));
}
assertFalse(defaultFactoryAttributeSource.hasAttributes());
// Add attributes with the packed implementations factory, then try to remove all of them
AttributeSource packedImplsAttributeSource
= new AttributeSource(TokenStream.DEFAULT_TOKEN_ATTRIBUTE_FACTORY);
assertFalse(packedImplsAttributeSource.hasAttributes());
for (Class<? extends Attribute> attrClass : attrClasses) {
packedImplsAttributeSource.addAttribute(attrClass);
assertTrue("Missing added attribute " + attrClass.getSimpleName(),
packedImplsAttributeSource.hasAttribute(attrClass));
}
packedImplsAttributeSource.removeAllAttributes();
for (Class<? extends Attribute> attrClass : attrClasses) {
assertFalse("Didn't remove attribute " + attrClass.getSimpleName(),
packedImplsAttributeSource.hasAttribute(attrClass));
}
assertFalse(packedImplsAttributeSource.hasAttributes());
}
}