Avoid deprecated APIs

4 files changed, 118 insertions, 107 deletions

diff --git a/container-search/src/test/java/com/yahoo/search/query/profile/types/test/NativePropertiesTestCase.java b/container-search/src/test/java/com/yahoo/search/query/profile/types/test/NativePropertiesTestCase.java
index 85015bee851..606d1fdd306 100644
--- a/container-search/src/test/java/com/yahoo/search/query/profile/types/test/NativePropertiesTestCase.java
+++ b/container-search/src/test/java/com/yahoo/search/query/profile/types/test/NativePropertiesTestCase.java
@@ -11,6 +11,7 @@ import org.junit.Test;
 
 import static org.hamcrest.CoreMatchers.containsString;
 import static org.junit.Assert.assertThat;
+import static org.junit.Assert.assertTrue;
 import static org.junit.Assert.fail;
 
 /**
@@ -39,9 +40,7 @@ public class NativePropertiesTestCase {
             fail("Above statement should throw");
         } catch (IllegalArgumentException e) {
             // As expected.
-            assertThat(
-                    Exceptions.toMessageString(e),
-                    containsString(
+            assertTrue(Exceptions.toMessageString(e).contains(
                             "Could not set 'notnative' to '5':"
                             + " 'notnative' is not declared in query profile type 'strict', and the type is strict"));
         }
diff --git a/container-search/src/test/java/com/yahoo/search/query/profile/types/test/QueryProfileTypeTestCase.java b/container-search/src/test/java/com/yahoo/search/query/profile/types/test/QueryProfileTypeTestCase.java
index 44e8147c09b..2e88c9fd0a4 100644
--- a/container-search/src/test/java/com/yahoo/search/query/profile/types/test/QueryProfileTypeTestCase.java
+++ b/container-search/src/test/java/com/yahoo/search/query/profile/types/test/QueryProfileTypeTestCase.java
@@ -26,10 +26,8 @@ import java.net.URLEncoder;
 import java.nio.charset.StandardCharsets;
 import java.util.List;
 
-import static org.hamcrest.CoreMatchers.containsString;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertNull;
-import static org.junit.Assert.assertThat;
 import static org.junit.Assert.assertTrue;
 import static org.junit.Assert.fail;
 
@@ -96,13 +94,13 @@ public class QueryProfileTypeTestCase {
 
     @Test
     public void testTypedOfPrimitivesAssignmentNonStrict() {
-        QueryProfile profile=new QueryProfile("test");
+        QueryProfile profile = new QueryProfile("test");
         profile.setType(testtype);
         registry.register(profile);
 
-        profile.set("myString","anyValue", registry);
+        profile.set("myString", "anyValue", registry);
         profile.set("nontypedString", "anyValueToo", registry); // legal because this is not strict
-        assertWrongType(profile,"integer","myInteger","notInteger");
+        assertWrongType(profile,"integer", "myInteger","notInteger");
         assertWrongType(profile, "integer", "myInteger", "1.5");
         profile.set("myInteger", 3, registry);
         assertWrongType(profile,"long","myLong","notLong");
@@ -137,7 +135,7 @@ public class QueryProfileTypeTestCase {
         assertEquals("anyValueToo", properties.get("nontypedString"));
         assertEquals(3, properties.get("myInteger"));
         assertEquals(3, properties.get("Int"));
-        assertEquals(4000000000000l, properties.get("myLong"));
+        assertEquals(4000000000000L, properties.get("myLong"));
         assertEquals(3.14f, properties.get("myFloat"));
         assertEquals(2.18, properties.get("myDouble"));
         assertEquals(true, properties.get("myBoolean"));
@@ -163,7 +161,7 @@ public class QueryProfileTypeTestCase {
 
     @Test
     public void testTypedOfPrimitivesAssignmentStrict() {
-        QueryProfile profile=new QueryProfile("test");
+        QueryProfile profile = new QueryProfile("test");
         profile.setType(testtypeStrict);
 
         profile.set("myString", "anyValue", registry);
@@ -173,13 +171,13 @@ public class QueryProfileTypeTestCase {
         profile.set("myInteger", 3, registry);
         assertWrongType(profile,"long","myLong","notLong");
         assertWrongType(profile, "long", "myLong", "1.5");
-        profile.set("myLong", 4000000000000l, registry);
+        profile.set("myLong", 4000000000000L, registry);
         assertWrongType(profile, "float", "myFloat", "notFloat");
         profile.set("myFloat", 3.14f, registry);
         assertWrongType(profile, "double", "myDouble", "notDouble");
         profile.set("myDouble",2.18, registry);
-        profile.set("myQueryProfile.anyString","value1", registry);
-        profile.set("myQueryProfile.anyDouble",8.76, registry);
+        profile.set("myQueryProfile.anyString", "value1", registry);
+        profile.set("myQueryProfile.anyDouble", 8.76, registry);
         profile.set("myUserQueryProfile.myUserString", "value2", registry);
         assertNotPermitted(profile, "myUserQueryProfile.anyString", "value3"); // Illegal because this is strict
         assertWrongType(profile, "integer", "myUserQueryProfile.myUserInteger", "notInteger");
@@ -191,7 +189,7 @@ public class QueryProfileTypeTestCase {
         assertEquals("anyValue", cprofile.get("myString"));
         assertNull(cprofile.get("nontypedString"));
         assertEquals(3, cprofile.get("myInteger"));
-        assertEquals(4000000000000l, cprofile.get("myLong"));
+        assertEquals(4000000000000L, cprofile.get("myLong"));
         assertEquals(3.14f, cprofile.get("myFloat"));
         assertEquals(2.18, cprofile.get("myDouble"));
         assertEquals("value1", cprofile.get("myQueryProfile.anyString"));
@@ -205,25 +203,25 @@ public class QueryProfileTypeTestCase {
     /** Tests assigning a subprofile directly */
     @Test
     public void testTypedAssignmentOfQueryProfilesNonStrict() {
-        QueryProfile profile=new QueryProfile("test");
+        QueryProfile profile = new QueryProfile("test");
         profile.setType(testtype);
 
         QueryProfile map1=new QueryProfile("myMap1");
-        map1.set("key1","value1", registry);
+        map1.set("key1", "value1", registry);
 
         QueryProfile map2=new QueryProfile("myMap2");
-        map2.set("key2","value2", registry);
+        map2.set("key2", "value2", registry);
 
         QueryProfile myUser=new QueryProfile("myUser");
         myUser.setType(user);
-        myUser.set("myUserString","userValue1", registry);
-        myUser.set("myUserInteger",442, registry);
+        myUser.set("myUserString", "userValue1", registry);
+        myUser.set("myUserInteger", 442, registry);
 
         assertWrongType(profile,"reference to a query profile","myQueryProfile","aString");
-        profile.set("myQueryProfile",map1, registry);
-        profile.set("someMap",map2, registry); // Legal because this is not strict
-        assertWrongType(profile,"reference to a query profile of type 'user'","myUserQueryProfile",map1);
-        profile.set("myUserQueryProfile",myUser, registry);
+        profile.set("myQueryProfile", map1, registry);
+        profile.set("someMap", map2, registry); // Legal because this is not strict
+        assertWrongType(profile, "reference to a query profile of type 'user'", "myUserQueryProfile", map1);
+        profile.set("myUserQueryProfile", myUser, registry);
 
         CompiledQueryProfile cprofile = profile.compile(null);
 
@@ -236,25 +234,25 @@ public class QueryProfileTypeTestCase {
     /** Tests assigning a subprofile directly */
     @Test
     public void testTypedAssignmentOfQueryProfilesStrict() {
-        QueryProfile profile=new QueryProfile("test");
+        QueryProfile profile = new QueryProfile("test");
         profile.setType(testtypeStrict);
 
         QueryProfile map1=new QueryProfile("myMap1");
-        map1.set("key1","value1", registry);
+        map1.set("key1", "value1", registry);
 
         QueryProfile map2=new QueryProfile("myMap2");
-        map2.set("key2","value2", registry);
+        map2.set("key2", "value2", registry);
 
-        QueryProfile myUser=new QueryProfile("myUser");
+        QueryProfile myUser = new QueryProfile("myUser");
         myUser.setType(userStrict);
-        myUser.set("myUserString","userValue1", registry);
-        myUser.set("myUserInteger",442, registry);
+        myUser.set("myUserString", "userValue1", registry);
+        myUser.set("myUserInteger", 442, registry);
 
         assertWrongType(profile,"reference to a query profile","myQueryProfile","aString");
-        profile.set("myQueryProfile",map1, registry);
-        assertNotPermitted(profile,"someMap",map2);
-        assertWrongType(profile,"reference to a query profile of type 'userStrict'","myUserQueryProfile",map1);
-        profile.set("myUserQueryProfile",myUser, registry);
+        profile.set("myQueryProfile", map1, registry);
+        assertNotPermitted(profile,"someMap", map2);
+        assertWrongType(profile,"reference to a query profile of type 'userStrict'", "myUserQueryProfile", map1);
+        profile.set("myUserQueryProfile", myUser, registry);
 
         CompiledQueryProfile cprofile = profile.compile(null);
 
@@ -271,15 +269,15 @@ public class QueryProfileTypeTestCase {
         profile.setType(testtype);
 
         QueryProfile map1 = new QueryProfile("myMap1");
-        map1.set("key1","value1", registry);
+        map1.set("key1", "value1", registry);
 
         QueryProfile map2 = new QueryProfile("myMap2");
-        map2.set("key2","value2", registry);
+        map2.set("key2", "value2", registry);
 
         QueryProfile myUser = new QueryProfile("myUser");
         myUser.setType(user);
-        myUser.set("myUserString","userValue1", registry);
-        myUser.set("myUserInteger",442, registry);
+        myUser.set("myUserString", "userValue1", registry);
+        myUser.set("myUserInteger", 442, registry);
 
         registry.register(profile);
         registry.register(map1);
@@ -311,18 +309,18 @@ public class QueryProfileTypeTestCase {
      */
     @Test
     public void testTypedOverridingOfQueryProfileReferencesNonStrictThroughQuery() {
-        QueryProfile profile=new QueryProfile("test");
+        QueryProfile profile = new QueryProfile("test");
         profile.setType(testtype);
 
         QueryProfile myUser=new QueryProfile("myUser");
         myUser.setType(user);
-        myUser.set("myUserString","userValue1", registry);
-        myUser.set("myUserInteger",442, registry);
+        myUser.set("myUserString", "userValue1", registry);
+        myUser.set("myUserInteger", 442, registry);
 
-        QueryProfile newUser=new QueryProfile("newUser");
+        QueryProfile newUser = new QueryProfile("newUser");
         newUser.setType(user);
-        newUser.set("myUserString","newUserValue1", registry);
-        newUser.set("myUserInteger",845, registry);
+        newUser.set("myUserString", "newUserValue1", registry);
+        newUser.set("myUserInteger", 845, registry);
 
         QueryProfileRegistry registry = new QueryProfileRegistry();
         registry.register(profile);
@@ -331,7 +329,9 @@ public class QueryProfileTypeTestCase {
         CompiledQueryProfileRegistry cRegistry = registry.compile();
         CompiledQueryProfile cprofile = cRegistry.getComponent("test");
 
-        Query query = new Query(HttpRequest.createTestRequest("?myUserQueryProfile=newUser", com.yahoo.jdisc.http.HttpRequest.Method.GET), cprofile);
+        Query query = new Query(HttpRequest.createTestRequest("?myUserQueryProfile=newUser",
+                                                              com.yahoo.jdisc.http.HttpRequest.Method.GET),
+                                cprofile);
 
         assertEquals(0, query.errors().size());
 
@@ -500,8 +500,8 @@ public class QueryProfileTypeTestCase {
             fail("Above statement should throw");
         } catch (IllegalArgumentException e) {
             // As expected.
-            assertThat(Exceptions.toMessageString(e),
-                       containsString("Could not set 'myUserQueryProfile.nondeclared' to 'someValue': 'nondeclared' is not declared in query profile type 'userStrict', and the type is strict"));
+            assertTrue(Exceptions.toMessageString(e).contains(
+                       "Could not set 'myUserQueryProfile.nondeclared' to 'someValue': 'nondeclared' is not declared in query profile type 'userStrict', and the type is strict"));
         }
     }
 
@@ -615,8 +615,8 @@ public class QueryProfileTypeTestCase {
             fail("Above statement should throw");
         } catch (IllegalArgumentException e) {
             // As expected.
-            assertThat(Exceptions.toMessageString(e),
-                       containsString("Could not set 'subMap.typeProfile.someValue' to 'value': 'someValue' is not declared in query profile type 'testtypeStrict', and the type is strict"));
+            assertTrue(Exceptions.toMessageString(e).contains(
+                       "Could not set 'subMap.typeProfile.someValue' to 'value': 'someValue' is not declared in query profile type 'testtypeStrict', and the type is strict"));
         }
     }
 
diff --git a/container-search/src/test/java/com/yahoo/search/query/textserialize/item/test/ParseItemTestCase.java b/container-search/src/test/java/com/yahoo/search/query/textserialize/item/test/ParseItemTestCase.java
index 4da2edf8306..aa0d692ec92 100644
--- a/container-search/src/test/java/com/yahoo/search/query/textserialize/item/test/ParseItemTestCase.java
+++ b/container-search/src/test/java/com/yahoo/search/query/textserialize/item/test/ParseItemTestCase.java
@@ -1,7 +1,19 @@
 // Copyright Yahoo. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
 package com.yahoo.search.query.textserialize.item.test;
 
-import com.yahoo.prelude.query.*;
+import com.yahoo.prelude.query.AndItem;
+import com.yahoo.prelude.query.ExactStringItem;
+import com.yahoo.prelude.query.IntItem;
+import com.yahoo.prelude.query.NearItem;
+import com.yahoo.prelude.query.NotItem;
+import com.yahoo.prelude.query.ONearItem;
+import com.yahoo.prelude.query.OrItem;
+import com.yahoo.prelude.query.PhraseItem;
+import com.yahoo.prelude.query.PrefixItem;
+import com.yahoo.prelude.query.RankItem;
+import com.yahoo.prelude.query.SubstringItem;
+import com.yahoo.prelude.query.SuffixItem;
+import com.yahoo.prelude.query.WordItem;
 import com.yahoo.search.query.textserialize.item.ItemContext;
 import com.yahoo.search.query.textserialize.item.ItemFormHandler;
 import com.yahoo.search.query.textserialize.parser.ParseException;
@@ -10,10 +22,9 @@ import org.junit.Test;
 
 import java.io.StringReader;
 
-import static org.hamcrest.core.Is.is;
-import static org.hamcrest.core.IsInstanceOf.instanceOf;
+import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertNull;
-import static org.junit.Assert.assertThat;
+import static org.junit.Assert.assertTrue;
 
 /**
  * @author Tony Vaagenes
@@ -29,50 +40,50 @@ public class ParseItemTestCase {
 
     @Test
     public void parse_and() throws ParseException {
-        assertThat(parse("(AND)"), instanceOf(AndItem.class));
+        assertTrue(parse("(AND)") instanceof AndItem);
     }
 
     @Test
     public void parse_and_with_children() throws ParseException {
         AndItem andItem = (AndItem) parse("(AND (WORD 'first') (WORD 'second'))");
 
-        assertThat(andItem.getItemCount(), is(2));
-        assertThat(getWord(andItem.getItem(0)), is("first"));
+        assertEquals(2, andItem.getItemCount());
+        assertEquals("first", getWord(andItem.getItem(0)));
     }
 
     @Test
     public void parse_or() throws ParseException {
-        assertThat(parse("(OR)"), instanceOf(OrItem.class));
+        assertTrue(parse("(OR)") instanceof OrItem);
     }
 
     @Test
     public void parse_and_not_rest() throws ParseException {
-        assertThat(parse("(AND-NOT-REST)"), instanceOf(NotItem.class));
+        assertTrue(parse("(AND-NOT-REST)") instanceof NotItem);
     }
 
     @Test
     public void parse_and_not_rest_with_children() throws ParseException {
         NotItem notItem = (NotItem) parse("(AND-NOT-REST (WORD 'positive') (WORD 'negative'))");
-        assertThat(getWord(notItem.getPositiveItem()), is("positive"));
-        assertThat(getWord(notItem.getItem(1)), is("negative"));
+        assertEquals("positive", getWord(notItem.getPositiveItem()));
+        assertEquals("negative", getWord(notItem.getItem(1)));
     }
 
     @Test
     public void parse_and_not_rest_with_only_negated_children() throws ParseException {
         NotItem notItem = (NotItem) parse("(AND-NOT-REST null (WORD 'negated-item'))");
         assertNull(notItem.getPositiveItem());
-        assertThat(notItem.getItem(1), instanceOf(WordItem.class));
+        assertTrue(notItem.getItem(1) instanceof WordItem);
     }
 
     @Test
     public void parse_rank() throws ParseException {
-        assertThat(parse("(RANK (WORD 'first'))"), instanceOf(RankItem.class));
+        assertTrue(parse("(RANK (WORD 'first'))") instanceof RankItem);
     }
 
     @Test
     public void parse_word() throws ParseException {
         WordItem wordItem = (WordItem) parse("(WORD 'text')");
-        assertThat(wordItem.getWord(), is("text"));
+        assertEquals("text", wordItem.getWord());
     }
 
     @Test(expected = IllegalArgumentException.class)
@@ -88,65 +99,65 @@ public class ParseItemTestCase {
     @Test
     public void parse_int() throws ParseException {
         IntItem intItem = (IntItem) parse("(INT '[42;]')");
-        assertThat(intItem.getNumber(), is("[42;]"));
+        assertEquals("[42;]", intItem.getNumber());
     }
 
     @Test
     public void parse_range() throws ParseException {
         IntItem intItem = (IntItem) parse("(INT '[42;73]')");
-        assertThat(intItem.getNumber(), is("[42;73]"));
+        assertEquals("[42;73]", intItem.getNumber());
     }
 
     @Test
     public void parse_range_withlimit() throws ParseException {
         IntItem intItem = (IntItem) parse("(INT '[42;73;32]')");
-        assertThat(intItem.getNumber(), is("[42;73;32]"));
+        assertEquals("[42;73;32]", intItem.getNumber());
     }
 
     @Test
     public void parse_prefix() throws ParseException {
         PrefixItem prefixItem = (PrefixItem) parse("(PREFIX 'word')");
-        assertThat(prefixItem.getWord(), is("word"));
+        assertEquals("word", prefixItem.getWord());
     }
 
     @Test
     public void parse_subString() throws ParseException {
         SubstringItem subStringItem = (SubstringItem) parse("(SUBSTRING 'word')");
-        assertThat(subStringItem.getWord(), is("word"));
+        assertEquals("word", subStringItem.getWord());
     }
 
     @Test
     public void parse_exactString() throws ParseException {
         ExactStringItem subStringItem = (ExactStringItem) parse("(EXACT 'word')");
-        assertThat(subStringItem.getWord(), is("word"));
+        assertEquals("word", subStringItem.getWord());
     }
 
     @Test
     public void parse_suffix() throws ParseException {
         SuffixItem suffixItem = (SuffixItem) parse("(SUFFIX 'word')");
-        assertThat(suffixItem.getWord(), is("word"));
+        assertEquals("word", suffixItem.getWord());
     }
 
     @Test
     public void parse_phrase() throws ParseException {
         PhraseItem phraseItem = (PhraseItem) parse("(PHRASE (WORD 'word'))");
-        assertThat(phraseItem.getItem(0), instanceOf(WordItem.class));
+        assertTrue(phraseItem.getItem(0) instanceof WordItem);
     }
 
     @Test
     public void parse_near() throws ParseException {
-        assertThat(parse("(NEAR)"), instanceOf(NearItem.class));
+        assertTrue(parse("(NEAR)") instanceof NearItem);
     }
 
     @Test
     public void parse_onear() throws ParseException {
-        assertThat(parse("(ONEAR)"), instanceOf(ONearItem.class));
+        assertTrue(parse("(ONEAR)") instanceof ONearItem);
     }
 
     @Test
     public void parse_near_with_distance() throws ParseException {
         NearItem nearItem = (NearItem) parse("(NEAR {'distance' 42} (WORD 'first'))");
-        assertThat(nearItem.getDistance(), is(42));
+        assertEquals(42, nearItem.getDistance());
     }
 
     @Test
@@ -154,23 +165,24 @@ public class ParseItemTestCase {
         AndItem andItem = (AndItem) parse("(AND (WORD {'id' '1'} 'first') (WORD {'connectivity' ['1' 23.5]} 'second'))");
         WordItem secondItem = (WordItem) andItem.getItem(1);
 
-        assertThat(secondItem.getConnectedItem(), is(andItem.getItem(0)));
-        assertThat(secondItem.getConnectivity(), is(23.5));
+        assertEquals(andItem.getItem(0), secondItem.getConnectedItem());
+        assertEquals(23.5, secondItem.getConnectivity(), 0.000001);
     }
 
     @Test
     public void parse_word_with_index() throws ParseException {
         WordItem wordItem = (WordItem) parse("(WORD {'index' 'someIndex'} 'text')");
-        assertThat(wordItem.getIndexName(), is("someIndex"));
+        assertEquals("someIndex", wordItem.getIndexName());
     }
 
     @Test
     public void parse_unicode_word() throws ParseException {
         WordItem wordItem = (WordItem) parse("(WORD 'trăm')");
-        assertThat(wordItem.getWord(), is("trăm"));
+        assertEquals("trăm", wordItem.getWord());
     }
 
     public static String getWord(Object item) {
         return ((WordItem)item).getWord();
     }
+
 }
diff --git a/container-search/src/test/java/com/yahoo/search/query/textserialize/serializer/test/SerializeItemTestCase.java b/container-search/src/test/java/com/yahoo/search/query/textserialize/serializer/test/SerializeItemTestCase.java
index c73ec4db588..133382cbe91 100644
--- a/container-search/src/test/java/com/yahoo/search/query/textserialize/serializer/test/SerializeItemTestCase.java
+++ b/container-search/src/test/java/com/yahoo/search/query/textserialize/serializer/test/SerializeItemTestCase.java
@@ -15,44 +15,43 @@ import org.junit.Test;
 
 import static com.yahoo.search.query.textserialize.item.test.ParseItemTestCase.parse;
 import static com.yahoo.search.query.textserialize.item.test.ParseItemTestCase.getWord;
-import static org.hamcrest.core.Is.is;
-import static org.hamcrest.core.IsInstanceOf.instanceOf;
-import static org.junit.Assert.assertThat;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
 
 /**
  * @author Tony Vaagenes
  */
 public class SerializeItemTestCase {
+
     @Test
     public void serialize_word_item() {
         WordItem item = new WordItem("test that \" and \\ works");
         item.setIndexName("index\"Name");
 
         WordItem deSerialized = serializeThenParse(item);
-        assertThat(deSerialized.getWord(), is(item.getWord()));
-        assertThat(deSerialized.getIndexName(), is(item.getIndexName()));
+        assertEquals(item.getWord(), deSerialized.getWord());
+        assertEquals(item.getIndexName(), deSerialized.getIndexName());
     }
 
     @Test
-    public void serialize_and_item() throws ParseException {
+    public void serialize_and_item() {
         AndItem andItem = new AndItem();
         andItem.addItem(new WordItem("first"));
         andItem.addItem(new WordItem("second"));
 
         AndItem deSerialized = serializeThenParse(andItem);
-        assertThat(getWord(deSerialized.getItem(0)), is("first"));
-        assertThat(getWord(deSerialized.getItem(1)), is("second"));
-        assertThat(deSerialized.getItemCount(), is(2));
+        assertEquals("first", getWord(deSerialized.getItem(0)));
+        assertEquals("second", getWord(deSerialized.getItem(1)));
+        assertEquals(2, deSerialized.getItemCount());
     }
 
     @Test
-    public void serialize_or_item() throws ParseException {
-        assertThat(serializeThenParse(new OrItem()),
-                instanceOf(OrItem.class));
+    public void serialize_or_item() {
+        assertTrue(serializeThenParse(new OrItem()) instanceof OrItem);
     }
 
     @Test
-    public void serialize_not_item() throws ParseException {
+    public void serialize_not_item() {
         NotItem notItem = new NotItem();
         {
             notItem.addItem(new WordItem("first"));
@@ -63,7 +62,7 @@ public class SerializeItemTestCase {
     }
 
     @Test
-    public void serialize_near_item() throws ParseException {
+    public void serialize_near_item() {
         int distance = 23;
         NearItem nearItem = new NearItem(distance);
         {
@@ -73,8 +72,8 @@ public class SerializeItemTestCase {
 
         NearItem deSerialized = serializeThenParse(nearItem);
 
-        assertThat(deSerialized.getDistance(), is(distance));
-        assertThat(deSerialized.getItemCount(), is(2));
+        assertEquals(distance, deSerialized.getDistance());
+        assertEquals(2, deSerialized.getItemCount());
     }
 
     @Test
@@ -83,22 +82,22 @@ public class SerializeItemTestCase {
         phraseItem.setIndexName("indexName");
 
         PhraseItem deSerialized = serializeThenParse(phraseItem);
-        assertThat(deSerialized.getItem(0), is(phraseItem.getItem(0)));
-        assertThat(deSerialized.getItem(1), is(phraseItem.getItem(1)));
-        assertThat(deSerialized.getIndexName(), is(phraseItem.getIndexName()));
+        assertEquals(phraseItem.getItem(0), deSerialized.getItem(0));
+        assertEquals(phraseItem.getItem(1), deSerialized.getItem(1));
+        assertEquals(phraseItem.getIndexName(), deSerialized.getIndexName());
     }
 
     @Test
-    public void serialize_equiv_item() throws ParseException {
+    public void serialize_equiv_item() {
         EquivItem equivItem = new EquivItem();
         equivItem.addItem(new WordItem("first"));
 
         EquivItem deSerialized = serializeThenParse(equivItem);
-        assertThat(deSerialized.getItemCount(), is(1));
+        assertEquals(1, deSerialized.getItemCount());
     }
 
     @Test
-    public void serialize_connectivity() throws ParseException {
+    public void serialize_connectivity() {
         OrItem orItem = new OrItem();
         {
             WordItem first = new WordItem("first");
@@ -113,35 +112,35 @@ public class SerializeItemTestCase {
         WordItem first = (WordItem) deSerialized.getItem(0);
         Item second = deSerialized.getItem(1);
 
-        assertThat(first.getConnectedItem(), is(second));
-        assertThat(first.getConnectivity(), is(3.14));
+        assertEquals(second, first.getConnectedItem());
+        assertEquals(3.14, first.getConnectivity(), 0.0000001);
     }
 
     @Test
-    public void serialize_significance() throws ParseException {
+    public void serialize_significance() {
         EquivItem equivItem = new EquivItem();
         equivItem.setSignificance(24.2);
 
         EquivItem deSerialized = serializeThenParse(equivItem);
-        assertThat(deSerialized.getSignificance(), is(24.2));
+        assertEquals(24.2, deSerialized.getSignificance(), 0.00000001);
     }
 
     @Test
-    public void serialize_unique_id() throws ParseException {
+    public void serialize_unique_id() {
         EquivItem equivItem = new EquivItem();
         equivItem.setUniqueID(42);
 
         EquivItem deSerialized = serializeThenParse(equivItem);
-        assertThat(deSerialized.getUniqueID(), is(42));
+        assertEquals(42, deSerialized.getUniqueID());
     }
 
     @Test
-    public void serialize_weight() throws ParseException {
+    public void serialize_weight() {
         EquivItem equivItem = new EquivItem();
         equivItem.setWeight(42);
 
         EquivItem deSerialized = serializeThenParse(equivItem);
-        assertThat(deSerialized.getWeight(), is(42));
+        assertEquals(42, deSerialized.getWeight());
     }
 
     private static String serialize(Item item) {
@@ -156,4 +155,5 @@ public class SerializeItemTestCase {
             throw new RuntimeException(e);
         }
     }
+
 }