This is an automated email from the ASF dual-hosted git repository. rec pushed a commit to branch bugfix/UIMA-6421-Can-inject-String-value-into-StringArray-slot in repository https://gitbox.apache.org/repos/asf/uima-uimaj.git
commit 8b2adb0ad993f79339860b1c3d362e58fafe920e Author: Richard Eckart de Castilho <[email protected]> AuthorDate: Wed Mar 9 11:05:22 2022 +0100 [UIMA-6421] Can inject String value into StringArray slot - Modernize unit test - Fix formatting rules --- src/main/eclipse/org.eclipse.jdt.core.prefs | 2 +- .../apache/uima/cas/test/FeatureStructureTest.java | 577 ++++++++++----------- 2 files changed, 264 insertions(+), 315 deletions(-) diff --git a/src/main/eclipse/org.eclipse.jdt.core.prefs b/src/main/eclipse/org.eclipse.jdt.core.prefs index 4bac137..9ed6a9e 100644 --- a/src/main/eclipse/org.eclipse.jdt.core.prefs +++ b/src/main/eclipse/org.eclipse.jdt.core.prefs @@ -136,7 +136,7 @@ org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_field=insert org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_local_variable=insert org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_method=insert org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_package=insert -org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_parameter=insert +org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_parameter=do not insert org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_type=insert org.eclipse.jdt.core.formatter.insert_new_line_after_label=do not insert org.eclipse.jdt.core.formatter.insert_new_line_after_opening_brace_in_array_initializer=do not insert diff --git a/uimaj-core/src/test/java/org/apache/uima/cas/test/FeatureStructureTest.java b/uimaj-core/src/test/java/org/apache/uima/cas/test/FeatureStructureTest.java index 684a46d..14be9a7 100644 --- a/uimaj-core/src/test/java/org/apache/uima/cas/test/FeatureStructureTest.java +++ b/uimaj-core/src/test/java/org/apache/uima/cas/test/FeatureStructureTest.java @@ -16,9 +16,15 @@ * specific language governing permissions and limitations * under the License. */ - package org.apache.uima.cas.test; +import static org.apache.uima.cas.test.CASTestSetup.GROUP_1_LANGUAGES; +import static org.apache.uima.cas.test.CASTestSetup.GROUP_2_LANGUAGES; +import static org.apache.uima.cas.test.CASTestSetup.TOKEN_TYPE; +import static org.apache.uima.cas.test.CASTestSetup.TOKEN_TYPE_FEAT; +import static org.apache.uima.cas.test.CASTestSetup.WORD_TYPE; +import static org.assertj.core.api.Assertions.assertThatExceptionOfType; +import static org.assertj.core.api.Assertions.assertThatNoException; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertTrue; @@ -46,10 +52,6 @@ import org.junit.jupiter.api.AfterEach; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; -/** - * Class comment for FeatureStructureTest.java goes here. - * - */ public class FeatureStructureTest { private CASImpl cas; @@ -57,162 +59,156 @@ public class FeatureStructureTest { private TypeSystemImpl ts; private Type topType; - private Type stringType; - private TypeImpl tokenType; - private Type intType; - private TypeImpl tokenTypeType; - private Type wordType; - private Type arrayFsWithSubtypeType; - - private Feature arrayFsWithSubtypeTypeFeat; - private Type group1Type; - private Type group2Type; - private Type langPairType; - private Type neListType; + private Feature arrayFsWithSubtypeTypeFeat; private Feature lang1; - private Feature lang2; - private Feature descr; - private Feature tokenTypeFeat; - private Feature lemmaFeat; - private Feature sentLenFeat; - private Feature tokenFloatFeat; private Feature tokenLongFeat; private Feature tokenDoubleFeat; - private Feature startFeature; - private Feature tlFeature; - private Feature hdFeature; @BeforeEach - public void setUp() { - try { - this.cas = (CASImpl) CASInitializer.initCas(new CASTestSetup(), null); - assertTrue(this.cas != null); - this.ts = (TypeSystemImpl) this.cas.getTypeSystem(); - assertTrue(this.ts != null); - } catch (Exception e) { - e.printStackTrace(); - assertTrue(false); - } - this.topType = this.ts.getType(CAS.TYPE_NAME_TOP); - assertTrue(this.topType != null); - this.stringType = this.ts.getType(CAS.TYPE_NAME_STRING); - assertTrue(this.stringType != null); - this.tokenType = this.ts.getType(CASTestSetup.TOKEN_TYPE); - assertTrue(this.stringType != null); - this.intType = this.ts.getType(CAS.TYPE_NAME_INTEGER); - assertTrue(this.intType != null); - this.tokenTypeType = this.ts.getType(CASTestSetup.TOKEN_TYPE_TYPE); - assertTrue(this.tokenTypeType != null); - this.wordType = this.ts.getType(CASTestSetup.WORD_TYPE); - assertTrue(this.wordType != null); - this.arrayFsWithSubtypeType = this.ts.getType(CASTestSetup.ARRAYFSWITHSUBTYPE_TYPE); - assertTrue(this.arrayFsWithSubtypeType != null); - this.arrayFsWithSubtypeTypeFeat = this.ts + public void setUp() throws Exception { + cas = (CASImpl) CASInitializer.initCas(new CASTestSetup(), null); + assertTrue(cas != null); + + ts = (TypeSystemImpl) cas.getTypeSystem(); + assertTrue(ts != null); + + topType = ts.getType(CAS.TYPE_NAME_TOP); + assertTrue(topType != null); + + stringType = ts.getType(CAS.TYPE_NAME_STRING); + assertTrue(stringType != null); + + tokenType = ts.getType(CASTestSetup.TOKEN_TYPE); + assertTrue(stringType != null); + + intType = ts.getType(CAS.TYPE_NAME_INTEGER); + assertTrue(intType != null); + + tokenTypeType = ts.getType(CASTestSetup.TOKEN_TYPE_TYPE); + assertTrue(tokenTypeType != null); + + wordType = ts.getType(CASTestSetup.WORD_TYPE); + assertTrue(wordType != null); + + arrayFsWithSubtypeType = ts.getType(CASTestSetup.ARRAYFSWITHSUBTYPE_TYPE); + assertTrue(arrayFsWithSubtypeType != null); + + arrayFsWithSubtypeTypeFeat = ts .getFeatureByFullName(CASTestSetup.ARRAYFSWITHSUBTYPE_TYPE_FEAT_Q); - this.group1Type = this.ts.getType(CASTestSetup.GROUP_1); - assertTrue(this.group1Type != null); - this.group2Type = this.ts.getType(CASTestSetup.GROUP_2); - assertTrue(this.group2Type != null); - this.tokenTypeFeat = this.ts.getFeatureByFullName(CASTestSetup.TOKEN_TYPE_FEAT_Q); - assertTrue(this.tokenTypeFeat != null); - this.lemmaFeat = this.ts.getFeatureByFullName(CASTestSetup.LEMMA_FEAT_Q); - assertTrue(this.lemmaFeat != null); - this.sentLenFeat = this.ts.getFeatureByFullName(CASTestSetup.SENT_LEN_FEAT_Q); - assertTrue(this.sentLenFeat != null); - this.tokenFloatFeat = this.ts.getFeatureByFullName(CASTestSetup.TOKEN_FLOAT_FEAT_Q); - assertTrue(this.tokenFloatFeat != null); - this.tokenDoubleFeat = this.ts.getFeatureByFullName(CASTestSetup.TOKEN_DOUBLE_FEAT_Q); - assertTrue(this.tokenDoubleFeat != null); - this.tokenLongFeat = this.ts.getFeatureByFullName(CASTestSetup.TOKEN_LONG_FEAT_Q); - assertTrue(this.tokenLongFeat != null); - this.startFeature = this.ts.getFeatureByFullName(CAS.FEATURE_FULL_NAME_BEGIN); - assertTrue(this.startFeature != null); - this.langPairType = this.ts.getType(CASTestSetup.LANG_PAIR); - assertTrue(this.langPairType != null); - this.lang1 = this.langPairType.getFeatureByBaseName(CASTestSetup.LANG1); - assertTrue(this.lang1 != null); - this.lang2 = this.langPairType.getFeatureByBaseName(CASTestSetup.LANG2); - assertTrue(this.lang2 != null); - this.descr = this.langPairType.getFeatureByBaseName(CASTestSetup.DESCR_FEAT); - assertTrue(this.descr != null); - this.neListType = this.ts.getType(CAS.TYPE_NAME_NON_EMPTY_FS_LIST); - assertTrue(this.neListType != null); - this.tlFeature = this.neListType.getFeatureByBaseName(CAS.FEATURE_BASE_NAME_TAIL); - assertTrue(this.tlFeature != null); - this.hdFeature = this.neListType.getFeatureByBaseName(CAS.FEATURE_BASE_NAME_HEAD); - assertTrue(this.hdFeature != null); + + group1Type = ts.getType(CASTestSetup.GROUP_1); + assertTrue(group1Type != null); + + group2Type = ts.getType(CASTestSetup.GROUP_2); + assertTrue(group2Type != null); + + tokenTypeFeat = ts.getFeatureByFullName(CASTestSetup.TOKEN_TYPE_FEAT_Q); + assertTrue(tokenTypeFeat != null); + + lemmaFeat = ts.getFeatureByFullName(CASTestSetup.LEMMA_FEAT_Q); + assertTrue(lemmaFeat != null); + + sentLenFeat = ts.getFeatureByFullName(CASTestSetup.SENT_LEN_FEAT_Q); + assertTrue(sentLenFeat != null); + + tokenFloatFeat = ts.getFeatureByFullName(CASTestSetup.TOKEN_FLOAT_FEAT_Q); + assertTrue(tokenFloatFeat != null); + + tokenDoubleFeat = ts.getFeatureByFullName(CASTestSetup.TOKEN_DOUBLE_FEAT_Q); + assertTrue(tokenDoubleFeat != null); + + tokenLongFeat = ts.getFeatureByFullName(CASTestSetup.TOKEN_LONG_FEAT_Q); + assertTrue(tokenLongFeat != null); + + startFeature = ts.getFeatureByFullName(CAS.FEATURE_FULL_NAME_BEGIN); + assertTrue(startFeature != null); + + langPairType = ts.getType(CASTestSetup.LANG_PAIR); + assertTrue(langPairType != null); + + lang1 = langPairType.getFeatureByBaseName(CASTestSetup.LANG1); + assertTrue(lang1 != null); + + lang2 = langPairType.getFeatureByBaseName(CASTestSetup.LANG2); + assertTrue(lang2 != null); + + descr = langPairType.getFeatureByBaseName(CASTestSetup.DESCR_FEAT); + assertTrue(descr != null); + + neListType = ts.getType(CAS.TYPE_NAME_NON_EMPTY_FS_LIST); + assertTrue(neListType != null); + + tlFeature = neListType.getFeatureByBaseName(CAS.FEATURE_BASE_NAME_TAIL); + assertTrue(tlFeature != null); + + hdFeature = neListType.getFeatureByBaseName(CAS.FEATURE_BASE_NAME_HEAD); + assertTrue(hdFeature != null); } @AfterEach public void tearDown() { - this.cas = null; - - this.ts = null; - this.topType = null; - this.stringType = null; - this.tokenType = null; - - this.intType = null; - this.tokenTypeType = null; - this.wordType = null; - this.group1Type = null; - this.group2Type = null; - - this.tokenTypeFeat = null; - this.lemmaFeat = null; - this.sentLenFeat = null; - this.tokenFloatFeat = null; - this.startFeature = null; - this.langPairType = null; - this.lang1 = null; - this.lang2 = null; - this.descr = null; + cas = null; + + ts = null; + topType = null; + stringType = null; + tokenType = null; + + intType = null; + tokenTypeType = null; + wordType = null; + group1Type = null; + group2Type = null; + + tokenTypeFeat = null; + lemmaFeat = null; + sentLenFeat = null; + tokenFloatFeat = null; + startFeature = null; + langPairType = null; + lang1 = null; + lang2 = null; + descr = null; } @Test public void testErrorDerefDifferentCAS() { CAS cas2 = CASInitializer.initCas(new CASTestSetup(), null); - Type tokenType1 = this.ts.getType(CASTestSetup.TOKEN_TYPE); - Feature tokenTypeFeature = this.ts - .getFeatureByFullName(CASTestSetup.TOKEN_TYPE + ":" + CASTestSetup.TOKEN_TYPE_FEAT); + Type tokenType1 = ts.getType(TOKEN_TYPE); + Feature tokenTypeFeature = ts.getFeatureByFullName(TOKEN_TYPE + ":" + TOKEN_TYPE_FEAT); FeatureStructure fs1 = cas2.createFS(tokenType1); FeatureStructure fs = cas.createFS(tokenType1); - boolean caught = false; - try { - fs.setFeatureValue(tokenTypeFeature, fs1); - } catch (Exception e) { - assertTrue(e instanceof CASRuntimeException); - caught = true; - } - assertTrue(caught); + + assertThatExceptionOfType(CASRuntimeException.class) // + .isThrownBy(() -> fs.setFeatureValue(tokenTypeFeature, fs1)); } @Test public void testGetType() { - Type tokenType1 = this.ts.getType(CASTestSetup.TOKEN_TYPE); - Type wordType1 = this.ts.getType(CASTestSetup.WORD_TYPE); - FeatureStructure word = this.cas.createFS(wordType1); - FeatureStructure token = this.cas.createFS(tokenType1); + Type tokenType1 = ts.getType(TOKEN_TYPE); + Type wordType1 = ts.getType(WORD_TYPE); + FeatureStructure word = cas.createFS(wordType1); + FeatureStructure token = cas.createFS(tokenType1); assertTrue(word.getType().equals(wordType1)); assertTrue(token.getType().equals(tokenType1)); } @@ -230,7 +226,7 @@ public class FeatureStructureTest { NonEmptyFSList fsl = new NonEmptyFSList(ts.getType(CAS.TYPE_NAME_NON_EMPTY_FS_LIST), cas); fsl.addToIndexes(); // otherwise won't be replaced later - Annotation token = this.cas.createFS(tokenType); + Annotation token = cas.createFS(tokenType); cas.setId2FSsMaybeUnconditionally(token); // set up some refs; these must be updated if the type changes in a way to require a new FS @@ -304,86 +300,62 @@ public class FeatureStructureTest { assertEquals(null, token.getFeatureValue(tokenTypeFeat)); assertTrue(fsa.get(0) == token); assertTrue(fsl.getHead() == token); - } @Test public void testSetArrayValuedFeature() { - FeatureStructure testFS = this.cas.createFS(this.arrayFsWithSubtypeType); - assertTrue(testFS.getFeatureValue(this.arrayFsWithSubtypeTypeFeat) == null); - ArrayFS arrayFS = this.cas.createArrayFS(1); - testFS.setFeatureValue(this.arrayFsWithSubtypeTypeFeat, arrayFS); + FeatureStructure testFS = cas.createFS(arrayFsWithSubtypeType); + assertTrue(testFS.getFeatureValue(arrayFsWithSubtypeTypeFeat) == null); + ArrayFS arrayFS = cas.createArrayFS(1); + testFS.setFeatureValue(arrayFsWithSubtypeTypeFeat, arrayFS); assertTrue(true); - boolean caughtExc = false; - try { - testFS.setFeatureValue(this.arrayFsWithSubtypeTypeFeat, testFS); - } catch (CASRuntimeException e) { - caughtExc = true; - assertTrue(e.getMessageKey().equals(CASRuntimeException.INAPPROP_RANGE)); - } - assertTrue(caughtExc); + + assertThatExceptionOfType(CASRuntimeException.class) // + .isThrownBy(() -> testFS.setFeatureValue(arrayFsWithSubtypeTypeFeat, testFS)); } @Test public void testSetFeatureValue() { // FeatureStructure token = this.cas.createFS(this.tokenType); LowLevelCAS llcas = cas.getLowLevelCAS(); - int i = llcas.ll_createFS(this.tokenType.getCode()); + int i = llcas.ll_createFS(tokenType.getCode()); AnnotationFS token = llcas.ll_getFSForRef(i); - assertTrue(token.getFeatureValue(this.tokenTypeFeat) == null); - assertTrue(token.getStringValue(this.lemmaFeat) == null); - boolean caughtExc = false; - try { - token.getFeatureValue(this.sentLenFeat); - } catch (CASRuntimeException e) { - caughtExc = true; - assertTrue(e.getMessageKey().equals(CASRuntimeException.INAPPROP_FEAT)); - } - assertTrue(caughtExc); - FeatureStructure word = this.cas.createFS(this.wordType); - token.setFeatureValue(this.tokenTypeFeat, word); - caughtExc = false; - try { - token.setFeatureValue(this.lemmaFeat, word); - } catch (CASRuntimeException e) { - caughtExc = true; - assertTrue(e.getMessageKey().equals(CASRuntimeException.INAPPROP_RANGE)); - } - assertTrue(caughtExc); - - try { - token.setFeatureValue(this.tokenTypeFeat, null); - } catch (CASRuntimeException e) { - assertTrue(false); - } - - caughtExc = false; - try { - token.setFeatureValue(this.startFeature, null); - } catch (CASRuntimeException e) { - assertTrue(e.getMessageKey().equals(CASRuntimeException.INAPPROP_RANGE)); - caughtExc = true; - } - assertTrue(caughtExc); + assertTrue(token.getFeatureValue(tokenTypeFeat) == null); + assertTrue(token.getStringValue(lemmaFeat) == null); + + assertThatExceptionOfType(CASRuntimeException.class) // + .isThrownBy(() -> token.getFeatureValue(sentLenFeat)) // + .extracting(CASRuntimeException::getMessageKey) // + .isEqualTo(CASRuntimeException.INAPPROP_FEAT); + + FeatureStructure word = cas.createFS(wordType); + token.setFeatureValue(tokenTypeFeat, word); + + assertThatExceptionOfType(CASRuntimeException.class) // + .isThrownBy(() -> token.setFeatureValue(lemmaFeat, word)); + + assertThatNoException() // + .isThrownBy(() -> token.setFeatureValue(tokenTypeFeat, null)); + + assertThatExceptionOfType(CASRuntimeException.class) // + .isThrownBy(() -> token.setFeatureValue(startFeature, null)) // + .extracting(CASRuntimeException::getMessageKey) // + .isEqualTo(CASRuntimeException.INAPPROP_RANGE); // a "getter" test, not "setter" test, on purpose - caughtExc = false; - try { - token.getFeatureValue(this.startFeature); - } catch (CASRuntimeException e) { - assertTrue(e.getMessageKey().equals(CASRuntimeException.INAPPROP_RANGE_NOT_FS)); - caughtExc = true; - } - assertTrue(caughtExc); - - assertTrue(token.getStringValue(this.lemmaFeat) == null); + assertThatExceptionOfType(CASRuntimeException.class) // + .isThrownBy(() -> token.getFeatureValue(startFeature)) // + .extracting(CASRuntimeException::getMessageKey) // + .isEqualTo(CASRuntimeException.INAPPROP_RANGE_NOT_FS); + + assertTrue(token.getStringValue(lemmaFeat) == null); String testString = "test"; - token.setStringValue(this.lemmaFeat, testString); - assertTrue(token.getStringValue(this.lemmaFeat).equals(testString)); + token.setStringValue(lemmaFeat, testString); + assertTrue(token.getStringValue(lemmaFeat).equals(testString)); testString = ""; - token.setStringValue(this.lemmaFeat, testString); - assertTrue(token.getStringValue(this.lemmaFeat).equals(testString)); + token.setStringValue(lemmaFeat, testString); + assertTrue(token.getStringValue(lemmaFeat).equals(testString)); // test low level token.setFeatureValue(tokenTypeFeat, word); @@ -401,33 +373,29 @@ public class FeatureStructureTest { public void testSetFloatValue() { // AnnotationFS token = (AnnotationFS) this.cas.createFS(this.tokenType); LowLevelCAS llcas = cas.getLowLevelCAS(); - int i = llcas.ll_createFS(this.tokenType.getCode()); + int i = llcas.ll_createFS(tokenType.getCode()); Annotation token = llcas.ll_getFSForRef(i); - assertTrue(token.getFloatValue(this.tokenFloatFeat) == 0.0f); + assertTrue(token.getFloatValue(tokenFloatFeat) == 0.0f); + float f = -3.2f; - token.setFloatValue(this.tokenFloatFeat, f); - assertTrue(token.getFloatValue(this.tokenFloatFeat) == f); + token.setFloatValue(tokenFloatFeat, f); + assertTrue(token.getFloatValue(tokenFloatFeat) == f); + f = 51234.132f; - token.setFloatValue(this.tokenFloatFeat, f); - assertTrue(token.getFloatValue(this.tokenFloatFeat) == f); - boolean caughtExc = false; - try { - token.setFloatValue(this.tokenTypeFeat, 0.0f); - } catch (CASRuntimeException e) { - caughtExc = true; - assertTrue(e.getMessageKey().equals(CASRuntimeException.INAPPROP_RANGE)); - } - assertTrue(caughtExc); - assertTrue(token.getFloatValue(this.tokenFloatFeat) == f); - caughtExc = false; - try { - token.setFloatValue(this.sentLenFeat, 0.0f); - } catch (CASRuntimeException e) { - caughtExc = true; - assertTrue(e.getMessageKey().equals(CASRuntimeException.INAPPROP_RANGE)); - } - assertTrue(caughtExc); - assertTrue(token.getFloatValue(this.tokenFloatFeat) == f); + token.setFloatValue(tokenFloatFeat, f); + assertTrue(token.getFloatValue(tokenFloatFeat) == f); + + assertThatExceptionOfType(CASRuntimeException.class) // + .isThrownBy(() -> token.setFloatValue(tokenTypeFeat, 0.0f)) // + .extracting(CASRuntimeException::getMessageKey) // + .isEqualTo(CASRuntimeException.INAPPROP_RANGE); + assertTrue(token.getFloatValue(tokenFloatFeat) == f); + + assertThatExceptionOfType(CASRuntimeException.class) // + .isThrownBy(() -> token.setFloatValue(sentLenFeat, 0.0f)) // + .extracting(CASRuntimeException::getMessageKey) // + .isEqualTo(CASRuntimeException.INAPPROP_RANGE); + assertTrue(token.getFloatValue(tokenFloatFeat) == f); // low level int ffc = ((FeatureImpl) tokenFloatFeat).getCode(); @@ -440,18 +408,21 @@ public class FeatureStructureTest { public void testSetLongValue() { // AnnotationFS token = (AnnotationFS) this.cas.createFS(this.tokenType); LowLevelCAS llcas = cas.getLowLevelCAS(); - int i = llcas.ll_createFS(this.tokenType.getCode()); + int i = llcas.ll_createFS(tokenType.getCode()); AnnotationFS token = llcas.ll_getFSForRef(i); - assertTrue(token.getLongValue(this.tokenLongFeat) == 0.0f); + assertTrue(token.getLongValue(tokenLongFeat) == 0.0f); + long f = -34L; - token.setLongValue(this.tokenLongFeat, f); - assertTrue(token.getLongValue(this.tokenLongFeat) == f); + token.setLongValue(tokenLongFeat, f); + assertTrue(token.getLongValue(tokenLongFeat) == f); + f = 8_000_000_003L; - token.setLongValue(this.tokenLongFeat, f); - assertTrue(token.getLongValue(this.tokenLongFeat) == f); + token.setLongValue(tokenLongFeat, f); + assertTrue(token.getLongValue(tokenLongFeat) == f); + f = -8_000_000_003L; - token.setLongValue(this.tokenLongFeat, f); - assertTrue(token.getLongValue(this.tokenLongFeat) == f); + token.setLongValue(tokenLongFeat, f); + assertTrue(token.getLongValue(tokenLongFeat) == f); // low level int ffc = ((FeatureImpl) tokenLongFeat).getCode(); @@ -459,29 +430,32 @@ public class FeatureStructureTest { assertEquals(1, h); long g = 23; - token.setLongValue(this.tokenLongFeat, g); - assertEquals(g, token.getLongValue(this.tokenLongFeat)); + token.setLongValue(tokenLongFeat, g); + assertEquals(g, token.getLongValue(tokenLongFeat)); llcas.ll_setIntValue(token._id(), ffc, h); - assertEquals(f, token.getLongValue(this.tokenLongFeat)); + assertEquals(f, token.getLongValue(tokenLongFeat)); } @Test public void testSetDoubleValue() { // AnnotationFS token = (AnnotationFS) this.cas.createFS(this.tokenType); LowLevelCAS llcas = cas.getLowLevelCAS(); - int i = llcas.ll_createFS(this.tokenType.getCode()); + int i = llcas.ll_createFS(tokenType.getCode()); AnnotationFS token = llcas.ll_getFSForRef(i); - assertTrue(token.getDoubleValue(this.tokenDoubleFeat) == 0.0f); + assertTrue(token.getDoubleValue(tokenDoubleFeat) == 0.0f); + double f = -34.56D; - token.setDoubleValue(this.tokenDoubleFeat, f); - assertTrue(token.getDoubleValue(this.tokenDoubleFeat) == f); + token.setDoubleValue(tokenDoubleFeat, f); + assertTrue(token.getDoubleValue(tokenDoubleFeat) == f); + f = 8_000_000_003.24852D; - token.setDoubleValue(this.tokenDoubleFeat, f); - assertTrue(token.getDoubleValue(this.tokenDoubleFeat) == f); + token.setDoubleValue(tokenDoubleFeat, f); + assertTrue(token.getDoubleValue(tokenDoubleFeat) == f); + f = -8_000_000_003D; - token.setDoubleValue(this.tokenDoubleFeat, f); - assertTrue(token.getDoubleValue(this.tokenDoubleFeat) == f); + token.setDoubleValue(tokenDoubleFeat, f); + assertTrue(token.getDoubleValue(tokenDoubleFeat) == f); // low level int ffc = ((FeatureImpl) tokenDoubleFeat).getCode(); @@ -489,11 +463,11 @@ public class FeatureStructureTest { assertEquals(1, h); double g = 23; - token.setDoubleValue(this.tokenDoubleFeat, g); - Assertions.assertThat(token.getDoubleValue(this.tokenDoubleFeat)).isEqualTo(g); + token.setDoubleValue(tokenDoubleFeat, g); + Assertions.assertThat(token.getDoubleValue(tokenDoubleFeat)).isEqualTo(g); llcas.ll_setIntValue(token._id(), ffc, h); - Assertions.assertThat(token.getDoubleValue(this.tokenDoubleFeat)).isEqualTo(f); + Assertions.assertThat(token.getDoubleValue(tokenDoubleFeat)).isEqualTo(f); } @Test @@ -501,101 +475,71 @@ public class FeatureStructureTest { // AnnotationFS token = (AnnotationFS) this.cas.createFS(this.tokenType); // AnnotationFS token = (AnnotationFS) this.cas.createFS(this.tokenType); LowLevelCAS llcas = cas.getLowLevelCAS(); - int j = llcas.ll_createFS(this.tokenType.getCode()); + int j = llcas.ll_createFS(tokenType.getCode()); AnnotationFS token = llcas.ll_getFSForRef(j); - assertTrue(token.getIntValue(this.startFeature) == 0); + assertTrue(token.getIntValue(startFeature) == 0); + int i = 3; - token.setIntValue(this.startFeature, i); - assertTrue(token.getIntValue(this.startFeature) == i); + token.setIntValue(startFeature, i); + assertTrue(token.getIntValue(startFeature) == i); + i = -123456; - token.setIntValue(this.startFeature, i); - assertTrue(token.getIntValue(this.startFeature) == i); - boolean caughtExc = false; - try { - token.setIntValue(this.tokenTypeFeat, 0); - } catch (CASRuntimeException e) { - caughtExc = true; - assertTrue(e.getMessageKey().equals(CASRuntimeException.INAPPROP_RANGE)); - } - assertTrue(caughtExc); - assertTrue(token.getIntValue(this.startFeature) == i); - caughtExc = false; - try { - token.setIntValue(this.sentLenFeat, 0); - } catch (CASRuntimeException e) { - caughtExc = true; - assertTrue(e.getMessageKey().equals(CASRuntimeException.INAPPROP_FEAT)); - } - assertTrue(caughtExc); - assertTrue(token.getIntValue(this.startFeature) == i); + token.setIntValue(startFeature, i); + assertTrue(token.getIntValue(startFeature) == i); + + assertThatExceptionOfType(CASRuntimeException.class) // + .isThrownBy(() -> token.setIntValue(tokenTypeFeat, 0)) // + .extracting(CASRuntimeException::getMessageKey) // + .isEqualTo(CASRuntimeException.INAPPROP_RANGE); + assertTrue(token.getIntValue(startFeature) == i); + + assertThatExceptionOfType(CASRuntimeException.class) // + .isThrownBy(() -> token.setIntValue(sentLenFeat, 0)) // + .extracting(CASRuntimeException::getMessageKey) // + .isEqualTo(CASRuntimeException.INAPPROP_FEAT); + assertTrue(token.getIntValue(startFeature) == i); } @Test public void testStrings() { - FeatureStructure lp = this.cas.createFS(this.langPairType); + FeatureStructure lp = cas.createFS(langPairType); assertTrue(lp != null); + // Check that all strings are initially null. - try { - assertTrue(lp.getStringValue(this.lang1) == null); - } catch (Exception e) { - assertTrue(false); - } - try { - assertTrue(lp.getStringValue(this.lang2) == null); - } catch (Exception e) { - assertTrue(false); - } - try { - assertTrue(lp.getStringValue(this.descr) == null); - } catch (Exception e) { - assertTrue(false); - } + assertTrue(lp.getStringValue(lang1) == null); + assertTrue(lp.getStringValue(lang2) == null); + assertTrue(lp.getStringValue(descr) == null); + // FeatureStructure topFS = cas.createFS(topType); String val = "Some string."; - try { - lp.setStringValue(this.descr, val); - assertTrue(val.equals(lp.getStringValue(this.descr))); - } catch (CASRuntimeException e) { - assertTrue(false); - } - try { - lp.setStringValue(this.descr, null); - assertTrue(lp.getStringValue(this.descr) == null); - } catch (CASRuntimeException e) { - assertTrue(false); - } - try { - lp.setStringValue(this.lang1, CASTestSetup.GROUP_1_LANGUAGES[0]); - lp.setStringValue(this.lang2, CASTestSetup.GROUP_2_LANGUAGES[2]); - } catch (Exception e) { - assertTrue(false); - } - boolean exc = false; - try { - lp.setStringValue(this.lang1, CASTestSetup.GROUP_2_LANGUAGES[0]); - } catch (CASRuntimeException e) { - assertTrue(e.getMessageKey().equals(CASRuntimeException.ILLEGAL_STRING_VALUE)); - exc = true; - } - assertTrue(exc); - exc = false; - try { - lp.setStringValue(this.lang2, val); - } catch (CASRuntimeException e) { - assertTrue(e.getMessageKey().equals(CASRuntimeException.ILLEGAL_STRING_VALUE)); - exc = true; - } - assertTrue(exc); + lp.setStringValue(descr, val); + assertTrue(val.equals(lp.getStringValue(descr))); + + lp.setStringValue(descr, null); + assertTrue(lp.getStringValue(descr) == null); + + lp.setStringValue(lang1, GROUP_1_LANGUAGES[0]); + lp.setStringValue(lang2, GROUP_2_LANGUAGES[2]); + + assertThatExceptionOfType(CASRuntimeException.class) // + .isThrownBy(() -> lp.setStringValue(lang1, GROUP_2_LANGUAGES[0])) + .extracting(CASRuntimeException::getMessageKey) // + .isEqualTo(CASRuntimeException.ILLEGAL_STRING_VALUE); + + assertThatExceptionOfType(CASRuntimeException.class) // + .isThrownBy(() -> lp.setStringValue(lang2, val)) + .extracting(CASRuntimeException::getMessageKey) // + .isEqualTo(CASRuntimeException.ILLEGAL_STRING_VALUE); // Regression: toString() used to fail because string subtypes were // incorrectly classified as ref types. lp.toString(); - LowLevelCAS llc = this.cas.getLowLevelCAS(); + LowLevelCAS llc = cas.getLowLevelCAS(); LowLevelTypeSystem llts = llc.ll_getTypeSystem(); - final int tokenTypeCode = llts.ll_getCodeForType(this.tokenType); + final int tokenTypeCode = llts.ll_getCodeForType(tokenType); final int addr = llc.ll_createFS(tokenTypeCode); - final int lemmaFeatCode = llts.ll_getCodeForFeature(this.lemmaFeat); + final int lemmaFeatCode = llts.ll_getCodeForFeature(lemmaFeat); llc.ll_setStringValue(addr, lemmaFeatCode, "test", true); assertTrue(llc.ll_getCharBufferValueSize(addr, lemmaFeatCode) == 4); @@ -603,16 +547,21 @@ public class FeatureStructureTest { final int stringcode = llc.ll_getIntValue(addr, lemmaFeatCode); assertTrue(stringcode == 1); + llc.ll_setStringValue(addr, lemmaFeatCode, "test", true); assertEquals(llc.ll_getIntValue(addr, lemmaFeatCode), 1); // should not change + llc.ll_setStringValue(addr, lemmaFeatCode, "test2", true); assertEquals(llc.ll_getIntValue(addr, lemmaFeatCode), 2); + llc.ll_setIntValue(addr, lemmaFeatCode, 1); assertEquals(llc.ll_getIntValue(addr, lemmaFeatCode), 1); assertEquals(llc.ll_getStringValue(addr, lemmaFeatCode), "test"); + llc.ll_setIntValue(addr, lemmaFeatCode, 0); assertEquals(llc.ll_getIntValue(addr, lemmaFeatCode), 0); assertTrue(llc.ll_getStringValue(addr, lemmaFeatCode) == null); + llc.ll_setIntValue(addr, lemmaFeatCode, 2); assertEquals(llc.ll_getStringValue(addr, lemmaFeatCode), "test2"); @@ -629,16 +578,16 @@ public class FeatureStructureTest { @Test public void testToString() { - FeatureStructure listFS = this.cas.createFS(this.neListType); - listFS.setFeatureValue(this.tlFeature, listFS); + FeatureStructure listFS = cas.createFS(neListType); + listFS.setFeatureValue(tlFeature, listFS); System.out.println("toString for fslist, tail -> node, head is null"); System.out.println(listFS.toString()); - FeatureStructure value = this.cas.createFS(this.tokenType); - FeatureStructure newList = this.cas.createFS(this.neListType); - newList.setFeatureValue(this.tlFeature, listFS); - newList.setFeatureValue(this.hdFeature, value); - listFS.setFeatureValue(this.hdFeature, value); + FeatureStructure value = cas.createFS(tokenType); + FeatureStructure newList = cas.createFS(neListType); + newList.setFeatureValue(tlFeature, listFS); + newList.setFeatureValue(hdFeature, value); + listFS.setFeatureValue(hdFeature, value); System.out.println( "toString for fslist, tail is prev, prev's head: new token, head is same as rpev's head"); System.out.println(newList.toString());
