tamaya-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From anat...@apache.org
Subject [incubator-tamaya] branch master updated: TAMAYA-217: convert test assertions to AssertJ
Date Wed, 16 Jan 2019 20:45:34 GMT
This is an automated email from the ASF dual-hosted git repository.

anatole pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/incubator-tamaya.git


The following commit(s) were added to refs/heads/master by this push:
     new 2514b74  TAMAYA-217: convert test assertions to AssertJ
     new 71bf164  Merge pull request #32 from acoburn/TAMAYA-217
2514b74 is described below

commit 2514b740ca31a05c5d339adb25864bd6927f69cf
Author: Aaron Coburn <acoburn@apache.org>
AuthorDate: Tue Jan 8 14:29:57 2019 -0500

    TAMAYA-217: convert test assertions to AssertJ
    
    This continues some earlier work on the test code to consolidate
    the assertions to use only AssertJ.
---
 .../apache/tamaya/ConfigurationSnapshotTest.java   |  64 ++++----
 .../java/org/apache/tamaya/InvocationRecorder.java |   5 +-
 .../tamaya/spi/ConfigurationContextTest.java       |  28 ++--
 .../apache/tamaya/spi/ConversionContextTest.java   |  39 +++--
 .../org/apache/tamaya/spi/FilterContextTest.java   |  15 +-
 .../java/org/apache/tamaya/spi/ListValueTest.java  | 165 ++++++++++----------
 .../org/apache/tamaya/spi/ObjectValueTest.java     | 172 ++++++++++-----------
 .../org/apache/tamaya/spi/PropertySourceTest.java  |  17 +-
 .../org/apache/tamaya/spi/PropertyValueTest.java   | 170 ++++++++++----------
 .../BuildablePropertySourceProviderTest.java       |   7 +-
 .../spisupport/BuildablePropertySourceTest.java    |  10 +-
 .../spisupport/ConfigValueEvaluatorTest.java       |  14 +-
 .../DefaultConfigValueEvaluatorTest.java           |   3 +-
 .../DefaultConfigurationSnapshotTest.java          | 148 +++++++++---------
 .../spisupport/DefaultMetaDataProviderTest.java    |  34 ++--
 .../DefaultPropertySourceSnapshotTest.java         |  36 ++---
 .../PropertySourceChangeSupportTest.java           |  36 ++---
 .../propertysource/SimplePropertySourceTest.java   |   3 +-
 .../propertysource/SystemPropertySourceTest.java   |   8 +-
 19 files changed, 478 insertions(+), 496 deletions(-)

diff --git a/code/api/src/test/java/org/apache/tamaya/ConfigurationSnapshotTest.java b/code/api/src/test/java/org/apache/tamaya/ConfigurationSnapshotTest.java
index 475dc2b..973f217 100644
--- a/code/api/src/test/java/org/apache/tamaya/ConfigurationSnapshotTest.java
+++ b/code/api/src/test/java/org/apache/tamaya/ConfigurationSnapshotTest.java
@@ -23,133 +23,133 @@ import org.junit.Test;
 
 import java.util.Collections;
 
-import static org.junit.Assert.*;
+import static org.assertj.core.api.Assertions.assertThat;
 
 public class ConfigurationSnapshotTest {
 
     public void testEMPTY(){
-        assertNotNull(ConfigurationSnapshot.EMPTY);
+        assertThat(ConfigurationSnapshot.EMPTY).isNotNull();
     }
 
     @Test
     public void testEMPTY_timestamp(){
-        assertTrue(ConfigurationSnapshot.EMPTY.getTimestamp()==0);
+        assertThat(ConfigurationSnapshot.EMPTY.getTimestamp()).isEqualTo(0);
     }
 
     @Test
     public void testEMPTY_get(){
-        assertNull(ConfigurationSnapshot.EMPTY.get("foo"));
+        assertThat(ConfigurationSnapshot.EMPTY.get("foo")).isNull();
     }
 
     @Test
     public void testEMPTY_getOptional(){
-        assertNotNull(ConfigurationSnapshot.EMPTY.getOptional("foo"));
-        assertFalse(ConfigurationSnapshot.EMPTY.getOptional("foo").isPresent());
+        assertThat(ConfigurationSnapshot.EMPTY.getOptional("foo")).isNotNull();
+        assertThat(ConfigurationSnapshot.EMPTY.getOptional("foo").isPresent()).isFalse();
     }
 
     @Test
     public void testEMPTY_getOrDefault_noValue(){
-        assertNull(ConfigurationSnapshot.EMPTY.getOrDefault("foo", null));
+        assertThat(ConfigurationSnapshot.EMPTY.getOrDefault("foo", null)).isNull();
     }
 
     @Test
     public void testEMPTY_getOrDefault_withValue(){
-        assertEquals("foo", ConfigurationSnapshot.EMPTY.getOrDefault("foo", "foo"));
+        assertThat("foo").isEqualTo(ConfigurationSnapshot.EMPTY.getOrDefault("foo", "foo"));
     }
 
     @Test
     public void testEMPTY_getOptional_Iterable(){
-        assertNotNull(ConfigurationSnapshot.EMPTY.getOptional(Collections.singleton("foo")));
-        assertFalse(ConfigurationSnapshot.EMPTY.getOptional(Collections.singleton("foo")).isPresent());
+        assertThat(ConfigurationSnapshot.EMPTY.getOptional(Collections.singleton("foo"))).isNotNull();
+        assertThat(ConfigurationSnapshot.EMPTY.getOptional(Collections.singleton("foo")).isPresent()).isFalse();
     }
 
     @Test
     public void testEMPTY_getOptional_Class_Iterable(){
-        assertNotNull(ConfigurationSnapshot.EMPTY.getOptional(Collections.singleton("foo"), String.class));
-        assertFalse(ConfigurationSnapshot.EMPTY.getOptional(Collections.singleton("foo"), String.class).isPresent());
+        assertThat(ConfigurationSnapshot.EMPTY.getOptional(Collections.singleton("foo"), String.class)).isNotNull();
+        assertThat(ConfigurationSnapshot.EMPTY.getOptional(Collections.singleton("foo"), String.class).isPresent()).isFalse();
     }
 
     @Test
     public void testEMPTY_getOptional_Typeliteral_Iterable(){
-        assertNotNull(ConfigurationSnapshot.EMPTY.getOptional(Collections.singleton("foo"), TypeLiteral.of(String.class)));
-        assertFalse(ConfigurationSnapshot.EMPTY.getOptional(Collections.singleton("foo"), TypeLiteral.of(String.class)).isPresent());
+        assertThat(ConfigurationSnapshot.EMPTY.getOptional(Collections.singleton("foo"), TypeLiteral.of(String.class))).isNotNull();
+        assertThat(ConfigurationSnapshot.EMPTY.getOptional(Collections.singleton("foo"), TypeLiteral.of(String.class)).isPresent()).isFalse();
     }
 
     @Test
     public void testEMPTY_get_Iterable(){
-        assertNull(ConfigurationSnapshot.EMPTY.get(Collections.singleton("foo")));
+        assertThat(ConfigurationSnapshot.EMPTY.get(Collections.singleton("foo"))).isNull();
     }
 
     @Test
     public void testEMPTY_get_Iterable_Class(){
-        assertNull(ConfigurationSnapshot.EMPTY.get(Collections.singleton("foo"), String.class));
+        assertThat(ConfigurationSnapshot.EMPTY.get(Collections.singleton("foo"), String.class)).isNull();
     }
 
     @Test
     public void testEMPTY_getOrDefault_Class_withValue(){
-        assertEquals("foo", ConfigurationSnapshot.EMPTY.getOrDefault("foo", String.class, "foo"));
+        assertThat("foo").isEqualTo(ConfigurationSnapshot.EMPTY.getOrDefault("foo", String.class, "foo"));
     }
 
     @Test
     public void testEMPTY_getOrDefault_TypeLiteral_withValue(){
-        assertEquals("foo", ConfigurationSnapshot.EMPTY.getOrDefault("foo", TypeLiteral.of(String.class), "foo"));
+        assertThat("foo").isEqualTo(ConfigurationSnapshot.EMPTY.getOrDefault("foo", TypeLiteral.of(String.class), "foo"));
     }
 
     @Test
     public void testEMPTY_get_Iterable_TypeLiteral(){
-        assertNull(ConfigurationSnapshot.EMPTY.get(Collections.singleton("foo"), TypeLiteral.of(String.class)));
+        assertThat((String) ConfigurationSnapshot.EMPTY.get(Collections.singleton("foo"), TypeLiteral.of(String.class))).isNull();
     }
 
     @Test
     public void testEMPTY_get_Classl(){
-        assertNull(ConfigurationSnapshot.EMPTY.get("foo", TypeLiteral.of(String.class)));
+        assertThat((String) ConfigurationSnapshot.EMPTY.get("foo", TypeLiteral.of(String.class))).isNull();
     }
 
     @Test
     public void testEMPTY_get_TypeLiteral(){
-        assertNull(ConfigurationSnapshot.EMPTY.get("foo", TypeLiteral.of(String.class)));
+        assertThat((String) ConfigurationSnapshot.EMPTY.get("foo", TypeLiteral.of(String.class))).isNull();
     }
 
     @Test
     public void testEMPTY_getKeys(){
-        assertNotNull(ConfigurationSnapshot.EMPTY.getKeys());
-        assertTrue(ConfigurationSnapshot.EMPTY.getKeys().isEmpty());
+        assertThat(ConfigurationSnapshot.EMPTY.getKeys()).isNotNull();
+        assertThat(ConfigurationSnapshot.EMPTY.getKeys().isEmpty()).isTrue();
     }
 
     @Test
     public void testEMPTY_getContext(){
-        assertEquals(ConfigurationContext.EMPTY, ConfigurationSnapshot.EMPTY.getContext());
+        assertThat(ConfigurationContext.EMPTY).isEqualTo(ConfigurationSnapshot.EMPTY.getContext());
     }
 
     @Test
     public void testEMPTY_getPropertiest(){
-        assertNotNull(ConfigurationSnapshot.EMPTY.getProperties());
-        assertTrue(ConfigurationSnapshot.EMPTY.getProperties().isEmpty());
+        assertThat(ConfigurationSnapshot.EMPTY.getProperties()).isNotNull();
+        assertThat(ConfigurationSnapshot.EMPTY.getProperties().isEmpty()).isTrue();
     }
 
     @Test
     public void testEMPTY_toBuildert(){
-        assertNotNull(ConfigurationSnapshot.EMPTY.toBuilder());
+        assertThat(ConfigurationSnapshot.EMPTY.toBuilder()).isNotNull();
     }
 
     @Test
     public void testEMPTY_toStringt(){
-        assertNotNull(ConfigurationSnapshot.EMPTY.toString());
+        assertThat(ConfigurationSnapshot.EMPTY.toString()).isNotNull();
     }
 
     @Test
     public void testEMPTY_getSnapshot(){
-        assertEquals(ConfigurationSnapshot.EMPTY, ConfigurationSnapshot.EMPTY.getSnapshot());
+        assertThat(ConfigurationSnapshot.EMPTY).isEqualTo(ConfigurationSnapshot.EMPTY.getSnapshot());
     }
 
     @Test
     public void testEMPTY_getSnapshot_Keys(){
-        assertEquals(ConfigurationSnapshot.EMPTY, ConfigurationSnapshot.EMPTY.getSnapshot("foo"));
+        assertThat(ConfigurationSnapshot.EMPTY).isEqualTo(ConfigurationSnapshot.EMPTY.getSnapshot("foo"));
     }
 
     @Test
     public void testEMPTY_getSnapshot_Iterable(){
-        assertEquals(ConfigurationSnapshot.EMPTY, ConfigurationSnapshot.EMPTY.getSnapshot(Collections.singletonList("foo")));
+        assertThat(ConfigurationSnapshot.EMPTY).isEqualTo(ConfigurationSnapshot.EMPTY.getSnapshot(Collections.singletonList("foo")));
     }
 
-}
\ No newline at end of file
+}
diff --git a/code/api/src/test/java/org/apache/tamaya/InvocationRecorder.java b/code/api/src/test/java/org/apache/tamaya/InvocationRecorder.java
index a3ebdc7..228c98b 100644
--- a/code/api/src/test/java/org/apache/tamaya/InvocationRecorder.java
+++ b/code/api/src/test/java/org/apache/tamaya/InvocationRecorder.java
@@ -18,8 +18,7 @@
  */
 package org.apache.tamaya;
 
-
-import org.junit.Assert;
+import static org.assertj.core.api.Assertions.*;
 
 import java.lang.reflect.Method;
 import java.lang.reflect.Proxy;
@@ -71,6 +70,6 @@ public class InvocationRecorder {
                 }
             }
         }
-        Assert.fail("No such invocation: "+method + Arrays.toString(params));
+        fail("No such invocation: "+method + Arrays.toString(params));
     }
 }
diff --git a/code/api/src/test/java/org/apache/tamaya/spi/ConfigurationContextTest.java b/code/api/src/test/java/org/apache/tamaya/spi/ConfigurationContextTest.java
index 591b274..c9958d7 100644
--- a/code/api/src/test/java/org/apache/tamaya/spi/ConfigurationContextTest.java
+++ b/code/api/src/test/java/org/apache/tamaya/spi/ConfigurationContextTest.java
@@ -21,7 +21,7 @@ package org.apache.tamaya.spi;
 import org.apache.tamaya.TypeLiteral;
 import org.junit.Test;
 
-import static org.junit.Assert.*;
+import static org.assertj.core.api.Assertions.assertThat;
 
 /**
  * Tests the abstract functionality of {@link ConfigurationContext}.
@@ -30,18 +30,18 @@ public class ConfigurationContextTest {
 
     @Test
     public void test_EMPTY(){
-        assertNull(ConfigurationContext.EMPTY.getPropertySource("foo"));
-        assertNotNull(ConfigurationContext.EMPTY.getPropertySources());
-        assertTrue(ConfigurationContext.EMPTY.getPropertySources().isEmpty());
-        assertNotNull(ConfigurationContext.EMPTY.getMetaData("foo"));
-        assertNotNull(ConfigurationContext.EMPTY.getPropertyConverters());
-        assertTrue(ConfigurationContext.EMPTY.getPropertyConverters().isEmpty());
-        assertNotNull(ConfigurationContext.EMPTY.getPropertyFilters());
-        assertTrue(ConfigurationContext.EMPTY.getPropertyFilters().isEmpty());
-        assertNotNull(ConfigurationContext.EMPTY.getServiceContext());
-        assertNotNull(ConfigurationContext.EMPTY.getPropertyConverters(TypeLiteral.of(Boolean.class)));
-        assertTrue(ConfigurationContext.EMPTY.getPropertyConverters(TypeLiteral.of(Boolean.class)).isEmpty());
-        assertNotNull(ConfigurationContext.EMPTY.toString());
+        assertThat(ConfigurationContext.EMPTY.getPropertySource("foo")).isNull();
+        assertThat(ConfigurationContext.EMPTY.getPropertySources()).isNotNull();
+        assertThat(ConfigurationContext.EMPTY.getPropertySources().isEmpty()).isTrue();
+        assertThat(ConfigurationContext.EMPTY.getMetaData("foo")).isNotNull();
+        assertThat(ConfigurationContext.EMPTY.getPropertyConverters()).isNotNull();
+        assertThat(ConfigurationContext.EMPTY.getPropertyConverters().isEmpty()).isTrue();
+        assertThat(ConfigurationContext.EMPTY.getPropertyFilters()).isNotNull();
+        assertThat(ConfigurationContext.EMPTY.getPropertyFilters().isEmpty()).isTrue();
+        assertThat(ConfigurationContext.EMPTY.getServiceContext()).isNotNull();
+        assertThat(ConfigurationContext.EMPTY.getPropertyConverters(TypeLiteral.of(Boolean.class))).isNotNull();
+        assertThat(ConfigurationContext.EMPTY.getPropertyConverters(TypeLiteral.of(Boolean.class)).isEmpty()).isTrue();
+        assertThat(ConfigurationContext.EMPTY.toString()).isNotNull();
     }
 
-}
\ No newline at end of file
+}
diff --git a/code/api/src/test/java/org/apache/tamaya/spi/ConversionContextTest.java b/code/api/src/test/java/org/apache/tamaya/spi/ConversionContextTest.java
index 7e6110e..2b56c84 100644
--- a/code/api/src/test/java/org/apache/tamaya/spi/ConversionContextTest.java
+++ b/code/api/src/test/java/org/apache/tamaya/spi/ConversionContextTest.java
@@ -29,8 +29,7 @@ import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
 
-import static org.assertj.core.api.Assertions.*;
-import static org.junit.Assert.*;
+import static org.assertj.core.api.Assertions.assertThat;
 
 /**
  * Tests for {@link ConversionContext}, created by atsticks on 20.08.16.
@@ -104,10 +103,10 @@ public class ConversionContextTest {
         ConversionContext ctx = new ConversionContext.Builder("toString", TypeLiteral.of(List.class))
                 .addSupportedFormats(MyConverter.class, "0.0.0.0/nnn", "x.x.x.x/yyy")
                 .setValues(PropertyValue.createValue("test", "value")).build();
-        assertNotNull(ctx.getValues());
-        assertEquals(ctx.getValues().size(), 1);
-        assertEquals("value", ctx.getValues().get(0).getValue());
-        assertEquals("test", ctx.getValues().get(0).getKey());
+        assertThat(ctx.getValues()).isNotNull();
+        assertThat(ctx.getValues().size()).isEqualTo(1);
+        assertThat("value").isEqualTo(ctx.getValues().get(0).getValue());
+        assertThat("test").isEqualTo(ctx.getValues().get(0).getKey());
     }
 
     @Test
@@ -115,10 +114,10 @@ public class ConversionContextTest {
         ConversionContext ctx = new ConversionContext.Builder("toString", TypeLiteral.of(List.class))
                 .addSupportedFormats(MyConverter.class, "0.0.0.0/nnn", "x.x.x.x/yyy")
                 .setValues(Collections.singletonList(PropertyValue.createValue("test", "value"))).build();
-        assertNotNull(ctx.getValues());
-        assertEquals(ctx.getValues().size(), 1);
-        assertEquals("value", ctx.getValues().get(0).getValue());
-        assertEquals("test", ctx.getValues().get(0).getKey());
+        assertThat(ctx.getValues()).isNotNull();
+        assertThat(ctx.getValues().size()).isEqualTo(1);
+        assertThat("value").isEqualTo(ctx.getValues().get(0).getValue());
+        assertThat("test").isEqualTo(ctx.getValues().get(0).getKey());
     }
 
     @Test
@@ -126,7 +125,7 @@ public class ConversionContextTest {
         ConversionContext ctx = new ConversionContext.Builder("toString", TypeLiteral.of(List.class))
                 .addSupportedFormats(MyConverter.class, "0.0.0.0/nnn", "x.x.x.x/yyy")
                 .setValues(PropertyValue.createValue("test", "value")).build();
-        assertNotNull(ctx.getConfigurationContext());
+        assertThat(ctx.getConfigurationContext()).isNotNull();
     }
 
     @Test
@@ -135,21 +134,21 @@ public class ConversionContextTest {
                 .addSupportedFormats(MyConverter.class, "0.0.0.0/nnn", "x.x.x.x/yyy")
                 .setValues(PropertyValue.createValue("test", "value")
                 .setMeta("meta1", "val1").setMeta("meta2", "val2")).build();
-        assertNotNull(ctx.getMeta());
-        assertFalse(ctx.getMeta().isEmpty());
-        assertEquals(2, ctx.getMeta().size());
+        assertThat(ctx.getMeta()).isNotNull();
+        assertThat(ctx.getMeta().isEmpty()).isFalse();
+        assertThat(2).isEqualTo(ctx.getMeta().size());
     }
 
     @Test
     public void testBuilderToString() {
         ConversionContext.Builder b = new ConversionContext.Builder("toString", TypeLiteral.of(List.class))
                 .addSupportedFormats(MyConverter.class, "0.0.0.0/nnn", "x.x.x.x/yyy");
-        assertNotNull(b.toString());
-        assertTrue(b.toString().contains("targetType=TypeLiteral{type=interface java.util.List}"));
-        assertTrue(b.toString().contains("supportedFormats=[0.0.0.0/nnn (MyConverter), x.x.x.x/yyy (MyConverter)]"));
-        assertTrue(b.toString().contains("annotatedElement"));
-        assertTrue(b.toString().contains("key='toString'"));
-        assertTrue(b.toString().contains("Builder"));
+        assertThat(b.toString()).isNotNull();
+        assertThat(b.toString().contains("targetType=TypeLiteral{type=interface java.util.List}")).isTrue();
+        assertThat(b.toString().contains("supportedFormats=[0.0.0.0/nnn (MyConverter), x.x.x.x/yyy (MyConverter)]")).isTrue();
+        assertThat(b.toString().contains("annotatedElement")).isTrue();
+        assertThat(b.toString().contains("key='toString'")).isTrue();
+        assertThat(b.toString().contains("Builder")).isTrue();
     }
 
     private static final AnnotatedElement MyAnnotatedElement = new AnnotatedElement() {
diff --git a/code/api/src/test/java/org/apache/tamaya/spi/FilterContextTest.java b/code/api/src/test/java/org/apache/tamaya/spi/FilterContextTest.java
index 48b9ba9..19aeb72 100644
--- a/code/api/src/test/java/org/apache/tamaya/spi/FilterContextTest.java
+++ b/code/api/src/test/java/org/apache/tamaya/spi/FilterContextTest.java
@@ -27,10 +27,7 @@ import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 
-import static junit.framework.TestCase.assertNull;
-import static org.assertj.core.api.Assertions.*;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
+import static org.assertj.core.api.Assertions.assertThat;
 
 /**
  * Tests for {@link FilterContext}.
@@ -41,10 +38,10 @@ public class FilterContextTest {
     public void constructorWithContext() {
         PropertyValue val = new PropertyValue(null, "");
         FilterContext ctx = new FilterContext(val, ConfigurationContext.EMPTY);
-        assertEquals(val, ctx.getProperty());
-        assertEquals(ConfigurationContext.EMPTY, ctx.getConfigurationContext());
-        assertNotNull(ctx.getConfigEntries());
-        assertEquals(1, ctx.getAllValues().size());
+        assertThat(val).isEqualTo(ctx.getProperty());
+        assertThat(ConfigurationContext.EMPTY).isEqualTo(ctx.getConfigurationContext());
+        assertThat(ctx.getConfigEntries()).isNotNull();
+        assertThat(1).isEqualTo(ctx.getAllValues().size());
     }
 
 //    @Test
@@ -152,4 +149,4 @@ public class FilterContextTest {
         assertThat(toString.endsWith("}")).isTrue();
     }
 
-}
\ No newline at end of file
+}
diff --git a/code/api/src/test/java/org/apache/tamaya/spi/ListValueTest.java b/code/api/src/test/java/org/apache/tamaya/spi/ListValueTest.java
index 6f27a0e..dbcb12a 100644
--- a/code/api/src/test/java/org/apache/tamaya/spi/ListValueTest.java
+++ b/code/api/src/test/java/org/apache/tamaya/spi/ListValueTest.java
@@ -23,8 +23,7 @@ import org.junit.Test;
 import java.util.Iterator;
 import java.util.List;
 
-import static org.junit.Assert.*;
-import static org.junit.Assert.assertEquals;
+import static org.assertj.core.api.Assertions.assertThat;
 
 /**
  * Tests for {@link ListValue}.
@@ -34,15 +33,15 @@ public class ListValueTest {
     @Test
     public void getCreation() {
         ListValue lv = PropertyValue.createList();
-        assertNotNull(lv);
+        assertThat(lv).isNotNull();
         lv = PropertyValue.createList("k");
-        assertNotNull(lv);
-        assertEquals("k", lv.getKey());
+        assertThat(lv).isNotNull();
+        assertThat("k").isEqualTo(lv.getKey());
     }
 
     @Test
     public void getValueType() {
-        assertEquals(PropertyValue.ValueType.ARRAY, PropertyValue.createList().getValueType());
+        assertThat(PropertyValue.ValueType.ARRAY).isEqualTo(PropertyValue.createList().getValueType());
     }
 
     @Test
@@ -52,22 +51,22 @@ public class ListValueTest {
         lv.add(val);
         PropertyValue val2 = PropertyValue.createValue("k2", "v2");
         lv.add(val2);
-        assertEquals(0, lv.getIndex(val));
-        assertEquals(1, lv.getIndex(val2));
+        assertThat(0).isEqualTo(lv.getIndex(val));
+        assertThat(1).isEqualTo(lv.getIndex(val2));
         PropertyValue val3 = PropertyValue.createValue("k3", "v");
-        assertEquals(-1, lv.getIndex(val3));
+        assertThat(-1).isEqualTo(lv.getIndex(val3));
     }
 
     @Test
     public void getSize() {
         ListValue lv = PropertyValue.createList();
-        assertEquals(0, lv.getSize());
+        assertThat(0).isEqualTo(lv.getSize());
         PropertyValue val = PropertyValue.createValue("k", "v");
         lv.add(val);
-        assertEquals(1, lv.getSize());
+        assertThat(1).isEqualTo(lv.getSize());
         PropertyValue val2 = PropertyValue.createValue("k", "v");
         lv.add(val2);
-        assertEquals(2, lv.getSize());
+        assertThat(2).isEqualTo(lv.getSize());
     }
 
     @Test
@@ -77,15 +76,15 @@ public class ListValueTest {
         lv.add(val);
         PropertyValue val2 = PropertyValue.createValue("k", "v");
         lv.add(val2);
-        assertNotNull(lv.getValues());
-        assertEquals(2, lv.getValues().size());
-        assertEquals(val, lv.getValues().get(0));
-        assertEquals(val2, lv.getValues().get(1));
+        assertThat(lv.getValues()).isNotNull();
+        assertThat(2).isEqualTo(lv.getValues().size());
+        assertThat(val).isEqualTo(lv.getValues().get(0));
+        assertThat(val2).isEqualTo(lv.getValues().get(1));
         lv.add(val2);
-        assertNotNull(lv.getValues());
-        assertEquals(2, lv.getValues().size());
-        assertEquals(val, lv.getValues().get(0));
-        assertEquals(val2, lv.getValues().get(1));
+        assertThat(lv.getValues()).isNotNull();
+        assertThat(2).isEqualTo(lv.getValues().size());
+        assertThat(val).isEqualTo(lv.getValues().get(0));
+        assertThat(val2).isEqualTo(lv.getValues().get(1));
     }
 
     @Test
@@ -98,9 +97,9 @@ public class ListValueTest {
         List<PropertyValue> result = lv.getValues(
                 pv -> "k1".equals(pv.getKey())
         );
-        assertNotNull(result);
-        assertEquals(1, result.size());
-        assertEquals(val, result.get(0));
+        assertThat(result).isNotNull();
+        assertThat(1).isEqualTo(result.size());
+        assertThat(val).isEqualTo(result.get(0));
     }
 
     @Test
@@ -111,12 +110,12 @@ public class ListValueTest {
         lv.add(val);
         lv.add(val2);
         Iterator iter = lv.iterator();
-        assertNotNull(iter);
-        assertTrue(iter.hasNext());
-        assertEquals(val, iter.next());
-        assertTrue(iter.hasNext());
-        assertEquals(val2, iter.next());
-        assertFalse(iter.hasNext());
+        assertThat(iter).isNotNull();
+        assertThat(iter.hasNext()).isTrue();
+        assertThat(val).isEqualTo(iter.next());
+        assertThat(iter.hasNext()).isTrue();
+        assertThat(val2).isEqualTo(iter.next());
+        assertThat(iter.hasNext()).isFalse();
     }
 
     @Test
@@ -126,8 +125,8 @@ public class ListValueTest {
         lv.add(val);
         lv.add(val);
         lv.add(val);
-        assertEquals(1, lv.getSize());
-        assertEquals(val, lv.get(0));
+        assertThat(1).isEqualTo(lv.getSize());
+        assertThat(val).isEqualTo(lv.get(0));
 
     }
 
@@ -135,48 +134,48 @@ public class ListValueTest {
     public void addValue_Value() {
         ListValue lv = PropertyValue.createList();
         lv.addValue("v");
-        assertEquals(1, lv.getSize());
-        assertEquals("v", lv.get(0).getValue());
+        assertThat(1).isEqualTo(lv.getSize());
+        assertThat("v").isEqualTo(lv.get(0).getValue());
         lv.addValue("v2");
-        assertEquals(2, lv.getSize());
-        assertEquals("v2", lv.get(1).getValue());
+        assertThat(2).isEqualTo(lv.getSize());
+        assertThat("v2").isEqualTo(lv.get(1).getValue());
         lv.addValue("v");
-        assertEquals(3, lv.getSize());
-        assertEquals("v", lv.get(2).getValue());
+        assertThat(3).isEqualTo(lv.getSize());
+        assertThat("v").isEqualTo(lv.get(2).getValue());
     }
 
     @Test
     public void addValue_KeyValue() {
         ListValue lv = PropertyValue.createList();
         lv.addValue("k", "v");
-        assertEquals(1, lv.getSize());
-        assertEquals("v", lv.get(0).getValue());
-        assertEquals("k", lv.get(0).getKey());
+        assertThat(1).isEqualTo(lv.getSize());
+        assertThat("v").isEqualTo(lv.get(0).getValue());
+        assertThat("k").isEqualTo(lv.get(0).getKey());
         lv.addValue("k2", "v2");
-        assertEquals(2, lv.getSize());
-        assertEquals("v2", lv.get(1).getValue());
-        assertEquals("k2", lv.get(1).getKey());
+        assertThat(2).isEqualTo(lv.getSize());
+        assertThat("v2").isEqualTo(lv.get(1).getValue());
+        assertThat("k2").isEqualTo(lv.get(1).getKey());
         lv.addValue("k", "v");
-        assertEquals(3, lv.getSize());
-        assertEquals("v", lv.get(2).getValue());
-        assertEquals("k", lv.get(2).getKey());
+        assertThat(3).isEqualTo(lv.getSize());
+        assertThat("v").isEqualTo(lv.get(2).getValue());
+        assertThat("k").isEqualTo(lv.get(2).getKey());
     }
 
     @Test
     public void addValues() {
         ListValue lv = PropertyValue.createList();
         lv.addValues("v", "v1", "v");
-        assertEquals(3, lv.getSize());
-        assertEquals("v", lv.get(0).getValue());
-        assertEquals("v1", lv.get(1).getValue());
-        assertEquals("v", lv.get(2).getValue());
+        assertThat(3).isEqualTo(lv.getSize());
+        assertThat("v").isEqualTo(lv.get(0).getValue());
+        assertThat("v1").isEqualTo(lv.get(1).getValue());
+        assertThat("v").isEqualTo(lv.get(2).getValue());
     }
 
     @Test
     public void addObject() {
         ListValue lv = PropertyValue.createList();
         lv.addObject();
-        assertEquals(1, lv.getSize());
+        assertThat(1).isEqualTo(lv.getSize());
         ObjectValue ov = (ObjectValue)lv.get(0);
     }
 
@@ -184,27 +183,27 @@ public class ListValueTest {
     public void addObject_Key() {
         ListValue lv = PropertyValue.createList();
         lv.addObject("key");
-        assertEquals(1, lv.getSize());
+        assertThat(1).isEqualTo(lv.getSize());
         ObjectValue ov = (ObjectValue)lv.get(0);
-        assertEquals("key", ov.getKey());
+        assertThat("key").isEqualTo(ov.getKey());
     }
 
     @Test
     public void addList() {
         ListValue lv = PropertyValue.createList();
         lv.addList();
-        assertEquals(1, lv.getSize());
+        assertThat(1).isEqualTo(lv.getSize());
         ListValue ov = (ListValue)lv.get(0);
-        assertEquals("", ov.getKey());
+        assertThat("").isEqualTo(ov.getKey());
     }
 
     @Test
     public void addList_Key() {
         ListValue lv = PropertyValue.createList();
         lv.addList("key");
-        assertEquals(1, lv.getSize());
+        assertThat(1).isEqualTo(lv.getSize());
         ListValue ov = (ListValue)lv.get(0);
-        assertEquals("key", ov.getKey());
+        assertThat("key").isEqualTo(ov.getKey());
     }
 
     @Test
@@ -212,10 +211,10 @@ public class ListValueTest {
         ListValue lv = PropertyValue.createList();
         lv.addList("list");
         lv.addObject("object");
-        assertNotNull(lv.getValues(""));
-        assertEquals(0, lv.getValues("").size());
-        assertEquals(1, lv.getValues("list").size());
-        assertEquals(1, lv.getValues("object").size());
+        assertThat(lv.getValues("")).isNotNull();
+        assertThat(0).isEqualTo(lv.getValues("").size());
+        assertThat(1).isEqualTo(lv.getValues("list").size());
+        assertThat(1).isEqualTo(lv.getValues("object").size());
     }
 
     @Test
@@ -223,8 +222,8 @@ public class ListValueTest {
         ListValue lv = PropertyValue.createList("foo");
         lv.addList("list");
         PropertyValue pv = lv.toPropertyValue();
-        assertNotNull(pv);
-        assertEquals(pv.getKey(), lv.getKey());
+        assertThat(pv).isNotNull();
+        assertThat(pv.getKey()).isEqualTo(lv.getKey());
     }
 
     @Test
@@ -232,10 +231,10 @@ public class ListValueTest {
         ListValue lv = PropertyValue.createList("foo");
         lv.addList("list").setValue("a");
         ObjectValue ov = lv.toObjectValue();
-        assertNotNull(ov);
-        assertEquals(ov.getKey(), lv.getKey());
-        assertNotNull(ov.getValue("list[0]"));
-        assertEquals(lv.getLists("list").get(0).getValue(), ov.getValue("list[0]").getValue());
+        assertThat(ov).isNotNull();
+        assertThat(ov.getKey()).isEqualTo(lv.getKey());
+        assertThat(ov.getValue("list[0]")).isNotNull();
+        assertThat(lv.getLists("list").get(0).getValue()).isEqualTo(ov.getValue("list[0]").getValue());
     }
 
     @Test
@@ -243,17 +242,17 @@ public class ListValueTest {
         ListValue lv = PropertyValue.createList("foo");
         lv.addList("list");
         ListValue lv2 = lv.toListValue();
-        assertTrue(lv == lv2);
+        assertThat(lv == lv2).isTrue();
     }
 
     @Test
     public void mutable() {
         ListValue lv = PropertyValue.createList("foo");
         lv.addList("list");
-        assertFalse(lv.isImmutable());
+        assertThat(lv.isImmutable()).isFalse();
         ListValue lv2 = lv.mutable();
-        assertFalse(lv2.isImmutable());
-        assertTrue(lv == lv2);
+        assertThat(lv2.isImmutable()).isFalse();
+        assertThat(lv == lv2).isTrue();
     }
 
     @Test
@@ -261,10 +260,10 @@ public class ListValueTest {
         ListValue lv1 = PropertyValue.createList("foo");
         lv1.addList("list");
         ListValue lv2 = lv1.deepClone();
-        assertTrue(lv1.getValues()!=lv2.getValues());
-        assertTrue(lv1.getMeta()!=lv2.getMeta());
-        assertTrue(lv1.equals(lv2));
-        assertTrue(lv1.iterator().next()!=lv2.iterator().next());
+        assertThat(lv1.getValues()!=lv2.getValues()).isTrue();
+        assertThat(lv1.getMeta()!=lv2.getMeta()).isTrue();
+        assertThat(lv1.equals(lv2)).isTrue();
+        assertThat(lv1.iterator().next()!=lv2.iterator().next()).isTrue();
     }
 
     @Test
@@ -273,7 +272,7 @@ public class ListValueTest {
         lv1.addList("list");
         ListValue lv2 = PropertyValue.createList("foo");
         lv2.addList("list");
-        assertTrue(lv1.equals(lv2));
+        assertThat(lv1.equals(lv2)).isTrue();
     }
 
     @Test
@@ -282,23 +281,23 @@ public class ListValueTest {
         lv1.addList("list");
         ListValue lv2 = PropertyValue.createList("foo");
         lv2.addList("list");
-        assertTrue(lv1.hashCode() == lv2.hashCode());
+        assertThat(lv1.hashCode() == lv2.hashCode()).isTrue();
     }
 
     @Test
     public void testToString() {
         ListValue lv1 = PropertyValue.createList("foo");
         String toString = lv1.toString();
-        assertNotNull(toString);
+        assertThat(toString).isNotNull();
         lv1.addList("list");
         toString = lv1.toString();
-        assertNotNull(toString);
+        assertThat(toString).isNotNull();
         lv1.addObject("object");
         toString = lv1.toString();
-        assertNotNull(toString);
+        assertThat(toString).isNotNull();
         lv1.addValue("valueKey");
         toString = lv1.toString();
-        assertNotNull(toString);
-        assertEquals("PropertyValue[ARRAY]{'foo', size='3'}", toString);
+        assertThat(toString).isNotNull();
+        assertThat("PropertyValue[ARRAY]{'foo', size='3'}").isEqualTo(toString);
     }
-}
\ No newline at end of file
+}
diff --git a/code/api/src/test/java/org/apache/tamaya/spi/ObjectValueTest.java b/code/api/src/test/java/org/apache/tamaya/spi/ObjectValueTest.java
index e5266a0..95eed0f 100644
--- a/code/api/src/test/java/org/apache/tamaya/spi/ObjectValueTest.java
+++ b/code/api/src/test/java/org/apache/tamaya/spi/ObjectValueTest.java
@@ -25,7 +25,7 @@ import java.util.HashMap;
 import java.util.Iterator;
 import java.util.Map;
 
-import static org.junit.Assert.*;
+import static org.assertj.core.api.Assertions.assertThat;
 
 /**
  * Tests for {@link ObjectValue}.
@@ -35,15 +35,15 @@ public class ObjectValueTest {
     @Test
     public void getCreation() {
         ObjectValue ov = PropertyValue.createObject();
-        assertNotNull(ov);
+        assertThat(ov).isNotNull();
         ov = PropertyValue.createObject("k");
-        assertNotNull(ov);
-        assertEquals("k", ov.getKey());
+        assertThat(ov).isNotNull();
+        assertThat("k").isEqualTo(ov.getKey());
     }
 
     @Test
     public void getValueType() {
-        assertEquals(PropertyValue.ValueType.ARRAY, PropertyValue.createList().getValueType());
+        assertThat(PropertyValue.ValueType.ARRAY).isEqualTo(PropertyValue.createList().getValueType());
     }
 
     @Test
@@ -53,24 +53,24 @@ public class ObjectValueTest {
         ov.set(val);
         PropertyValue val2 = PropertyValue.createValue("k2", "v2");
         ov.set(val2);
-        assertEquals(val, ov.getValue(val.getKey()));
-        assertEquals(val2, ov.getValue(val2.getKey()));
-        assertNull(ov.getValue("foo"));
+        assertThat(val).isEqualTo(ov.getValue(val.getKey()));
+        assertThat(val2).isEqualTo(ov.getValue(val2.getKey()));
+        assertThat(ov.getValue("foo")).isNull();
     }
 
     @Test
     public void getSize() {
         ObjectValue ov = PropertyValue.createObject();
-        assertEquals(0, ov.getSize());
+        assertThat(0).isEqualTo(ov.getSize());
         PropertyValue val = PropertyValue.createValue("k", "v");
         ov.set(val);
-        assertEquals(1, ov.getSize());
+        assertThat(1).isEqualTo(ov.getSize());
         PropertyValue val2 = PropertyValue.createValue("k2", "v");
         ov.set(val2);
-        assertEquals(2, ov.getSize());
+        assertThat(2).isEqualTo(ov.getSize());
         PropertyValue val3 = PropertyValue.createValue("k2", "v");
         ov.set(val3);
-        assertEquals(2, ov.getSize());
+        assertThat(2).isEqualTo(ov.getSize());
     }
 
     @Test
@@ -80,15 +80,15 @@ public class ObjectValueTest {
         ov.set(val);
         PropertyValue val2 = PropertyValue.createValue("k2", "v");
         ov.set(val2);
-        assertNotNull(ov.getValues());
-        assertEquals(2, ov.getValues().size());
-        assertEquals(val, ov.getValue("k1"));
-        assertEquals(val2, ov.getValue("k2"));
+        assertThat(ov.getValues()).isNotNull();
+        assertThat(2).isEqualTo(ov.getValues().size());
+        assertThat(val).isEqualTo(ov.getValue("k1"));
+        assertThat(val2).isEqualTo(ov.getValue("k2"));
         ov.set(val2);
-        assertNotNull(ov.getValues());
-        assertEquals(2, ov.getValues().size());
-        assertEquals(val, ov.getValue("k1"));
-        assertEquals(val2, ov.getValue("k2"));
+        assertThat(ov.getValues()).isNotNull();
+        assertThat(2).isEqualTo(ov.getValues().size());
+        assertThat(val).isEqualTo(ov.getValue("k1"));
+        assertThat(val2).isEqualTo(ov.getValue("k2"));
     }
 
     @Test
@@ -99,11 +99,11 @@ public class ObjectValueTest {
         PropertyValue val2 = ov.getOrSetValue("k2",
                 () -> PropertyValue.createValue("foo", "bar"));
         PropertyValue pv = ov.getOrSetValue("foo",  () -> PropertyValue.createValue("foo", "bar"));
-        assertNotNull(pv);
-        assertEquals(3, ov.getValues().size());
-        assertEquals(val, ov.getValue("k1"));
-        assertEquals(val2, ov.getValue("k2"));
-        assertEquals(pv, ov.getValue("foo"));
+        assertThat(pv).isNotNull();
+        assertThat(3).isEqualTo(ov.getValues().size());
+        assertThat(val).isEqualTo(ov.getValue("k1"));
+        assertThat(val2).isEqualTo(ov.getValue("k2"));
+        assertThat(pv).isEqualTo(ov.getValue("foo"));
     }
 
     @Test
@@ -115,9 +115,9 @@ public class ObjectValueTest {
         map.put("foo", "bar");
         ov.setValues(map);
         PropertyValue pv = ov.getValue("foo");
-        assertNotNull(pv);
-        assertEquals("foo", pv.getKey());
-        assertEquals("bar", pv.getValue());
+        assertThat(pv).isNotNull();
+        assertThat("foo").isEqualTo(pv.getKey());
+        assertThat("bar").isEqualTo(pv.getValue());
     }
 
     @Test
@@ -128,12 +128,12 @@ public class ObjectValueTest {
         ov.set(val);
         ov.set(val2);
         Iterator iter = ov.iterator();
-        assertNotNull(iter);
-        assertTrue(iter.hasNext());
-        assertEquals(val, iter.next());
-        assertTrue(iter.hasNext());
-        assertEquals(val2, iter.next());
-        assertFalse(iter.hasNext());
+        assertThat(iter).isNotNull();
+        assertThat(iter.hasNext()).isTrue();
+        assertThat(val).isEqualTo(iter.next());
+        assertThat(iter.hasNext()).isTrue();
+        assertThat(val2).isEqualTo(iter.next());
+        assertThat(iter.hasNext()).isFalse();
     }
 
     @Test
@@ -143,8 +143,8 @@ public class ObjectValueTest {
         ov.set(val);
         ov.set(val);
         ov.set(val);
-        assertEquals(1, ov.getSize());
-        assertEquals(val, ov.getValue("k"));
+        assertThat(1).isEqualTo(ov.getSize());
+        assertThat(val).isEqualTo(ov.getValue("k"));
 
     }
 
@@ -152,39 +152,39 @@ public class ObjectValueTest {
     public void getSet_Value() {
         ObjectValue ov = PropertyValue.createObject();
         ov.setValue("v");
-        assertEquals(0, ov.getSize());
-        assertEquals("v", ov.getValue());
+        assertThat(0).isEqualTo(ov.getSize());
+        assertThat("v").isEqualTo(ov.getValue());
     }
 
     @Test
     public void setValue_KeyValue() {
         ObjectValue ov = PropertyValue.createObject();
         ov.setValue("k", "v");
-        assertEquals(1, ov.getSize());
-        assertEquals("v", ov.getValue("k").getValue());
-        assertEquals("k", ov.getValue("k").getKey());
+        assertThat(1).isEqualTo(ov.getSize());
+        assertThat("v").isEqualTo(ov.getValue("k").getValue());
+        assertThat("k").isEqualTo(ov.getValue("k").getKey());
         ov.setValue("k2", "v2");
-        assertEquals(2, ov.getSize());
-        assertEquals("v2", ov.getValue("k2").getValue());
-        assertEquals("k2", ov.getValue("k2").getKey());
+        assertThat(2).isEqualTo(ov.getSize());
+        assertThat("v2").isEqualTo(ov.getValue("k2").getValue());
+        assertThat("k2").isEqualTo(ov.getValue("k2").getKey());
         ov.setValue("k", "v");
-        assertEquals(2, ov.getSize());
-        assertEquals("v", ov.getValue("k").getValue());
-        assertEquals("k", ov.getValue("k").getKey());
+        assertThat(2).isEqualTo(ov.getSize());
+        assertThat("v").isEqualTo(ov.getValue("k").getValue());
+        assertThat("k").isEqualTo(ov.getValue("k").getKey());
     }
 
     @Test
     public void setValue_WithCompositeKey_Single() {
         ObjectValue ov = PropertyValue.createObject();
         ov.setValueWithCompositeKey("k1.k2.k3", "v");
-        assertEquals(1, ov.getSize());
+        assertThat(1).isEqualTo(ov.getSize());
         ObjectValue treeNode = (ObjectValue)ov.getValue("k1");
-        assertNotNull(treeNode);
+        assertThat(treeNode).isNotNull();
         treeNode = (ObjectValue)treeNode.getValue("k2");
-        assertNotNull(treeNode);
+        assertThat(treeNode).isNotNull();
         PropertyValue finalValue = treeNode.getValue("k3");
-        assertNotNull(finalValue);
-        assertEquals("v", finalValue.getValue());
+        assertThat(finalValue).isNotNull();
+        assertThat("v").isEqualTo(finalValue.getValue());
     }
 
 
@@ -192,19 +192,19 @@ public class ObjectValueTest {
     public void setObject() {
         ObjectValue ov = PropertyValue.createObject();
         ov.setObject("k");
-        assertEquals(1, ov.getSize());
+        assertThat(1).isEqualTo(ov.getSize());
         ObjectValue ov2 = (ObjectValue)ov.getValue("k");
-        assertNotNull(ov2);
-        assertEquals("k", ov2.getKey());
+        assertThat(ov2).isNotNull();
+        assertThat("k").isEqualTo(ov2.getKey());
     }
 
     @Test
     public void setList() {
         ObjectValue ov = PropertyValue.createObject();
         ov.setList("k");
-        assertEquals(1, ov.getSize());
+        assertThat(1).isEqualTo(ov.getSize());
         ListValue lv = (ListValue)ov.getValue("k");
-        assertEquals("k", lv.getKey());
+        assertThat("k").isEqualTo(lv.getKey());
     }
 
     @Test
@@ -215,8 +215,8 @@ public class ObjectValueTest {
         ov.setObject("k3");
         ov.setValue("k4", "v");
         Collection<PropertyValue> values = ov.getValues();
-        assertNotNull(values);
-        assertEquals(4, values.size());
+        assertThat(values).isNotNull();
+        assertThat(4).isEqualTo(values.size());
     }
 
     @Test
@@ -229,9 +229,9 @@ public class ObjectValueTest {
         Collection<PropertyValue> values = ov.getValues(
                 pv -> "k1".equals(pv.getKey())
         );
-        assertNotNull(values);
-        assertEquals(1, values.size());
-        assertEquals("k1", values.iterator().next().getKey());
+        assertThat(values).isNotNull();
+        assertThat(1).isEqualTo(values.size());
+        assertThat("k1").isEqualTo(values.iterator().next().getKey());
     }
 
     @Test
@@ -242,8 +242,8 @@ public class ObjectValueTest {
         ov.setObject("k3");
         ov.setValue("k4", "v");
         Collection<PropertyValue> values = ov.getValues();
-        assertNotNull(values);
-        assertEquals(4, values.size());
+        assertThat(values).isNotNull();
+        assertThat(4).isEqualTo(values.size());
     }
 
     @Test
@@ -251,8 +251,8 @@ public class ObjectValueTest {
         ObjectValue ov = PropertyValue.createObject("foo");
         ov.setList("list");
         PropertyValue pv = ov.toPropertyValue();
-        assertNotNull(pv);
-        assertEquals(pv.getKey(), ov.getKey());
+        assertThat(pv).isNotNull();
+        assertThat(pv.getKey()).isEqualTo(ov.getKey());
     }
 
     @Test
@@ -260,10 +260,10 @@ public class ObjectValueTest {
         ObjectValue ov = PropertyValue.createObject("foo");
         ov.setList("list").setValue("a");
         ListValue lv = ov.toListValue();
-        assertNotNull(lv);
-        assertEquals(lv.getKey(), ov.getKey());
-        assertNotNull(lv.get(0));
-        assertEquals(ov.getValue("list").getValue(), lv.get(0).getValue());
+        assertThat(lv).isNotNull();
+        assertThat(lv.getKey()).isEqualTo(ov.getKey());
+        assertThat(lv.get(0)).isNotNull();
+        assertThat(ov.getValue("list").getValue()).isEqualTo(lv.get(0).getValue());
     }
 
     @Test
@@ -271,17 +271,17 @@ public class ObjectValueTest {
         ObjectValue ov = PropertyValue.createObject("foo");
         ov.setList("list");
         ObjectValue ov2 = ov.toObjectValue();
-        assertTrue(ov == ov2);
+        assertThat(ov == ov2).isTrue();
     }
 
     @Test
     public void mutable() {
         ObjectValue ov = PropertyValue.createObject("foo");
         ov.setList("list");
-        assertFalse(ov.isImmutable());
+        assertThat(ov.isImmutable()).isFalse();
         ObjectValue ov2 = ov.mutable();
-        assertFalse(ov2.isImmutable());
-        assertTrue(ov == ov2);
+        assertThat(ov2.isImmutable()).isFalse();
+        assertThat(ov == ov2).isTrue();
     }
 
     @Test
@@ -289,10 +289,10 @@ public class ObjectValueTest {
         ObjectValue ov1 = PropertyValue.createObject("foo");
         ov1.setList("list");
         ObjectValue ov2 = ov1.deepClone();
-        assertTrue(ov1.getValues()!=ov2.getValues());
-        assertTrue(ov1.getMeta()!=ov2.getMeta());
-        assertTrue(ov1.equals(ov2));
-        assertTrue(ov1.iterator().next()!=ov2.iterator().next());
+        assertThat(ov1.getValues()!=ov2.getValues()).isTrue();
+        assertThat(ov1.getMeta()!=ov2.getMeta()).isTrue();
+        assertThat(ov1.equals(ov2)).isTrue();
+        assertThat(ov1.iterator().next()!=ov2.iterator().next()).isTrue();
     }
 
     @Test
@@ -301,7 +301,7 @@ public class ObjectValueTest {
         ov1.setList("list");
         ObjectValue ov2 = PropertyValue.createObject("foo");
         ov2.setList("list");
-        assertTrue(ov1.equals(ov2));
+        assertThat(ov1.equals(ov2)).isTrue();
     }
 
     @Test
@@ -310,23 +310,23 @@ public class ObjectValueTest {
         ov1.setList("list");
         ObjectValue ov2 = PropertyValue.createObject("foo");
         ov2.setList("list");
-        assertTrue(ov1.hashCode() == ov2.hashCode());
+        assertThat(ov1.hashCode() == ov2.hashCode()).isTrue();
     }
 
     @Test
     public void testToString() {
         ObjectValue ov1 = PropertyValue.createObject("foo");
         String toString = ov1.toString();
-        assertNotNull(toString);
+        assertThat(toString).isNotNull();
         ov1.setList("list");
         toString = ov1.toString();
-        assertNotNull(toString);
+        assertThat(toString).isNotNull();
         ov1.setObject("object");
         toString = ov1.toString();
-        assertNotNull(toString);
+        assertThat(toString).isNotNull();
         ov1.setValue("valueKey", "value");
         toString = ov1.toString();
-        assertNotNull(toString);
-        assertEquals("PropertyValue[MAP]{'foo', size='3'}", toString);
+        assertThat(toString).isNotNull();
+        assertThat("PropertyValue[MAP]{'foo', size='3'}").isEqualTo(toString);
     }
-}
\ No newline at end of file
+}
diff --git a/code/api/src/test/java/org/apache/tamaya/spi/PropertySourceTest.java b/code/api/src/test/java/org/apache/tamaya/spi/PropertySourceTest.java
index 911ac01..8035072 100644
--- a/code/api/src/test/java/org/apache/tamaya/spi/PropertySourceTest.java
+++ b/code/api/src/test/java/org/apache/tamaya/spi/PropertySourceTest.java
@@ -24,9 +24,8 @@ import java.util.Set;
 import java.util.function.BiConsumer;
 
 import org.junit.Test;
-import static org.assertj.core.api.Assertions.*;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
+
+import static org.assertj.core.api.Assertions.assertThat;
 import static org.mockito.Mockito.mock;
 
 public class PropertySourceTest {
@@ -48,17 +47,17 @@ public class PropertySourceTest {
 
     @Test
     public void getOrdinal(){
-        assertEquals(0, new PropertySourceImpl().getOrdinal());
+        assertThat(0).isEqualTo(new PropertySourceImpl().getOrdinal());
         PropertySourceImpl ps = new PropertySourceImpl();
         ps.value = PropertyValue.createValue(PropertySource.TAMAYA_ORDINAL, "123");
-        assertEquals(123, ps.getOrdinal());
+        assertThat(123).isEqualTo(ps.getOrdinal());
         ps.value = PropertyValue.createValue(PropertySource.TAMAYA_ORDINAL, "abc");
-        assertEquals(0, ps.getOrdinal());
+        assertThat(0).isEqualTo(ps.getOrdinal());
     }
 
     @Test
     public void getVersion(){
-        assertEquals("N/A", new PropertySourceImpl().getVersion());
+        assertThat("N/A").isEqualTo(new PropertySourceImpl().getVersion());
     }
 
     @Test
@@ -80,12 +79,12 @@ public class PropertySourceTest {
 
     @Test
     public void isScannable() {
-        assertTrue(new PropertySourceImpl().isScannable());
+        assertThat(new PropertySourceImpl().isScannable()).isTrue();
     }
 
     @Test
     public void getChangeSupport() {
-        assertEquals(ChangeSupport.UNSUPPORTED, new PropertySourceImpl().getChangeSupport());
+        assertThat(ChangeSupport.UNSUPPORTED).isEqualTo(new PropertySourceImpl().getChangeSupport());
     }
 
     public class PropertySourceImpl implements PropertySource {
diff --git a/code/api/src/test/java/org/apache/tamaya/spi/PropertyValueTest.java b/code/api/src/test/java/org/apache/tamaya/spi/PropertyValueTest.java
index a4d177e..be6e7a3 100644
--- a/code/api/src/test/java/org/apache/tamaya/spi/PropertyValueTest.java
+++ b/code/api/src/test/java/org/apache/tamaya/spi/PropertyValueTest.java
@@ -18,16 +18,12 @@
  */
 package org.apache.tamaya.spi;
 
-import org.assertj.core.api.Assertions;
 import org.junit.Test;
 
 import java.util.HashMap;
 import java.util.Map;
 
-import static org.assertj.core.api.Assertions.*;
-import static org.junit.Assert.*;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotEquals;
+import static org.assertj.core.api.Assertions.assertThat;
 
 @SuppressWarnings("unchecked")
 public class PropertyValueTest {
@@ -45,9 +41,9 @@ public class PropertyValueTest {
     @Test
     public void builder() throws Exception {
         PropertyValueBuilder b = PropertyValue.builder("a", "b");
-        assertNotNull(b);
-        assertEquals("a", b.key);
-        assertEquals("b", b.source);
+        assertThat(b).isNotNull();
+        assertThat("a").isEqualTo(b.key);
+        assertThat("b").isEqualTo(b.source);
     }
 
     @Test
@@ -74,7 +70,7 @@ public class PropertyValueTest {
                 .setMeta("k", "v2")
                 .setMeta(meta);
         assertThat(pv.getMeta().get("k")).isNull();
-        Assertions.assertThat(pv.getMeta()).hasSize(2);
+        assertThat(pv.getMeta()).hasSize(2);
         assertThat(pv.getMeta().get("1")).isEqualTo("2");
         assertThat(pv.getMeta().get("a")).isEqualTo("b");
     }
@@ -113,14 +109,14 @@ public class PropertyValueTest {
         PropertyValue pv = PropertyValue.createObject("k")
                 .setMeta(meta);
         assertThat(pv.getMeta()).isEqualTo(meta);
-        Assertions.assertThat(pv.getMeta()).isEqualTo(meta);
+        assertThat(pv.getMeta()).isEqualTo(meta);
     }
 
     @Test
     public void testGetMetaEntries2() throws Exception {
         PropertyValue pv = PropertyValue.of("k", "v", null);
-        Assertions.assertThat(pv.getMeta()).isNotNull();
-        Assertions.assertThat(pv.getMeta().isEmpty()).isTrue();
+        assertThat(pv.getMeta()).isNotNull();
+        assertThat(pv.getMeta().isEmpty()).isTrue();
     }
 
     @Test
@@ -129,13 +125,13 @@ public class PropertyValueTest {
         map.put("a", "b");
         map.put("b", "c");
         Map<String, PropertyValue> result = PropertyValue.map(map, "source");
-        assertNotNull(result);
-        assertEquals(map.size(), result.size());
+        assertThat(result).isNotNull();
+        assertThat(map.size()).isEqualTo(result.size());
        for(PropertyValue pv:result.values()){
-           assertEquals("source", pv.getMetaEntry("source"));
+           assertThat("source").isEqualTo(pv.getMetaEntry("source"));
        }
-        assertEquals("b", map.get("a"));
-        assertEquals("c", map.get("b"));
+        assertThat("b").isEqualTo(map.get("a"));
+        assertThat("c").isEqualTo(map.get("b"));
     }
 
     @Test
@@ -147,15 +143,15 @@ public class PropertyValueTest {
         meta.put("m1", "m1v");
         meta.put("m2", "m2v");
         Map<String, PropertyValue> result = PropertyValue.map(map, "source", meta);
-        assertNotNull(result);
-        assertEquals(map.size(), result.size());
+        assertThat(result).isNotNull();
+        assertThat(map.size()).isEqualTo(result.size());
         for(PropertyValue pv:result.values()){
-            assertEquals("source", pv.getMetaEntry("source"));
-            assertEquals("m1v", pv.getMeta("m1"));
-            assertEquals("m2v", pv.getMeta("m2"));
+            assertThat("source").isEqualTo(pv.getMetaEntry("source"));
+            assertThat("m1v").isEqualTo(pv.getMeta("m1"));
+            assertThat("m2v").isEqualTo(pv.getMeta("m2"));
         }
-        assertEquals("b", map.get("a"));
-        assertEquals("c", map.get("b"));
+        assertThat("b").isEqualTo(map.get("a"));
+        assertThat("c").isEqualTo(map.get("b"));
     }
 
     @Test
@@ -177,28 +173,28 @@ public class PropertyValueTest {
     @Test
     public void testGetKey() throws Exception {
         PropertyValue pv = PropertyValue.of("k", "v", "testGetKey");
-        Assertions.assertThat(pv.getKey()).isEqualTo("k");
+        assertThat(pv.getKey()).isEqualTo("k");
     }
 
     @Test
     public void testGetValue() throws Exception {
         PropertyValue pv = PropertyValue.of("k", "v", "testGetValue");
-        Assertions.assertThat(pv.getValue()).isEqualTo("v");
+        assertThat(pv.getValue()).isEqualTo("v");
     }
 
     @Test
     public void testGetSource() throws Exception {
         PropertyValue pv = PropertyValue.of("k", "v", "testGetSource");
-        Assertions.assertThat(pv.getSource()).isEqualTo("testGetSource");
+        assertThat(pv.getSource()).isEqualTo("testGetSource");
         pv = PropertyValue.of("k", "v", "testGetSource");
-        Assertions.assertThat(pv.getSource()).isEqualTo("testGetSource");
+        assertThat(pv.getSource()).isEqualTo("testGetSource");
     }
 
     @Test
     public void testGetMetaEntry() throws Exception {
         PropertyValue pv = PropertyValue.createObject("k")
                 .setMeta("k", "v2");
-        Assertions.assertThat(pv.getKey()).isEqualTo("k");
+        assertThat(pv.getKey()).isEqualTo("k");
         assertThat(pv.getMeta().get("k")).isEqualTo("v2");
     }
 
@@ -235,88 +231,88 @@ public class PropertyValueTest {
 
     @Test
     public void newXXX() {
-        assertNotNull(PropertyValue.createValue("", null));
-        assertNotNull(PropertyValue.createObject());
-        assertNotNull(PropertyValue.createObject(""));
-        assertNotNull(PropertyValue.createList());
-        assertNotNull(PropertyValue.createList(""));
+        assertThat(PropertyValue.createValue("", null)).isNotNull();
+        assertThat(PropertyValue.createObject()).isNotNull();
+        assertThat(PropertyValue.createObject("")).isNotNull();
+        assertThat(PropertyValue.createList()).isNotNull();
+        assertThat(PropertyValue.createList("")).isNotNull();
     }
 
     @Test
     public void valueOf() {
         PropertyValue foo = PropertyValue.createValue("foo", "bar");
-        assertNotNull(foo);
-        assertEquals("foo", foo.getKey());
-        assertEquals("bar", foo.getValue());
+        assertThat(foo).isNotNull();
+        assertThat("foo").isEqualTo(foo.getKey());
+        assertThat("bar").isEqualTo(foo.getValue());
     }
 
     @Test
     public void arrayOf() {
         ListValue foo = PropertyValue.createList("foo");
-        assertNotNull(foo);
-        assertEquals("foo", foo.getKey());
+        assertThat(foo).isNotNull();
+        assertThat("foo").isEqualTo(foo.getKey());
     }
 
     @Test
     public void objectOf() {
         ObjectValue root = PropertyValue.createObject("bar");
-        assertTrue(root.getSize() == 0);
-        assertNotNull(root.setValue("foo", null));
-        assertFalse(root.getSize()==0);
-        assertNotNull(root.getValue("foo"));
-        assertNull(root.getValue("foo").getValue());
-        assertNotNull(root.setValue("foo", "bar"));
-        assertEquals(root.getValue("foo").getValue(), "bar");
-        assertTrue(root.getSize()==1);
+        assertThat(root.getSize() == 0).isTrue();
+        assertThat(root.setValue("foo", null)).isNotNull();
+        assertThat(root.getSize()==0).isFalse();
+        assertThat(root.getValue("foo")).isNotNull();
+        assertThat(root.getValue("foo").getValue()).isNull();
+        assertThat(root.setValue("foo", "bar")).isNotNull();
+        assertThat(root.getValue("foo").getValue()).isEqualTo("bar");
+        assertThat(root.getSize()==1).isTrue();
     }
 
     @Test
     public void addMeta() {
         PropertyValue root = PropertyValue.createObject();
         root.setMeta("a", Integer.valueOf(3));
-        assertEquals(Integer.valueOf(3).toString(), root.getMeta("a"));
+        assertThat(Integer.valueOf(3).toString()).isEqualTo(root.getMeta("a"));
     }
 
     @Test
     public void getKey() {
         PropertyValue root = PropertyValue.createObject("a");
-        assertEquals("a", root.getKey());
+        assertThat("a").isEqualTo(root.getKey());
     }
 
     @Test
     public void getQualifiedKey() {
         ObjectValue root = PropertyValue.createObject("a");
-        assertEquals("a", root.getQualifiedKey());
+        assertThat("a").isEqualTo(root.getQualifiedKey());
         ObjectValue child = PropertyValue.createObject("b");
         ObjectValue n = root.set(child);
-        assertEquals("a.b", child.getQualifiedKey());
+        assertThat("a.b").isEqualTo(child.getQualifiedKey());
         PropertyValue added = child.setValue("c", null);
-        assertEquals("a.b.c", added.getQualifiedKey());
+        assertThat("a.b.c").isEqualTo(added.getQualifiedKey());
     }
 
     @Test
     public void isLeaf() {
         PropertyValue n = PropertyValue.createValue("", "");
-        assertTrue(n.isLeaf());
+        assertThat(n.isLeaf()).isTrue();
         n = PropertyValue.createList("");
-        assertFalse(n.isLeaf());
+        assertThat(n.isLeaf()).isFalse();
     }
 
     @Test
     public void isImmutable() {
         PropertyValue n = PropertyValue.createValue("", "");
-        assertFalse(n.isImmutable());
+        assertThat(n.isImmutable()).isFalse();
         n.immutable();
-        assertTrue(n.isImmutable());
-        assertFalse(n.mutable().isImmutable());
+        assertThat(n.isImmutable()).isTrue();
+        assertThat(n.mutable().isImmutable()).isFalse();
     }
 
     @Test
     public void isRoot() {
         PropertyValue n = PropertyValue.createValue("", "");
-        assertTrue(n.isRoot());
+        assertThat(n.isRoot()).isTrue();
         n = PropertyValue.createValue("", "").setParent(n);
-        assertFalse(n.isRoot());
+        assertThat(n.isRoot()).isFalse();
     }
 
     @Test(expected=IllegalStateException.class)
@@ -332,64 +328,64 @@ public class PropertyValueTest {
         n.immutable();
         n = n.mutable();
         n.setValue("jhgjg");
-        assertEquals("jhgjg", n.getValue());
+        assertThat("jhgjg").isEqualTo(n.getValue());
     }
 
     @Test
     public void getParent() {
         ObjectValue n = PropertyValue.createObject("");
-        assertNull(n.getParent());
+        assertThat(n.getParent()).isNull();
         PropertyValue val = n.setObject("b");
-        assertNotNull(n.getValue("b"));
-        assertEquals(val, n.getValue("b"));
-        assertNotNull(n.getValue("b").getParent());
+        assertThat(n.getValue("b")).isNotNull();
+        assertThat(val).isEqualTo(n.getValue("b"));
+        assertThat(n.getValue("b").getParent()).isNotNull();
     }
 
     @Test
     public void size(){
         PropertyValue n = PropertyValue.createValue("key", "");
-        assertEquals(0, n.getSize());
-        assertFalse(n.iterator().hasNext());
+        assertThat(0).isEqualTo(n.getSize());
+        assertThat(n.iterator().hasNext()).isFalse();
     }
 
     @Test
     public void setValue() {
         PropertyValue n = PropertyValue.createValue("key", "");
-        assertEquals("", n.getValue());
+        assertThat("").isEqualTo(n.getValue());
         n.setValue("jhgjg");
-        assertEquals("jhgjg", n.getValue());
+        assertThat("jhgjg").isEqualTo(n.getValue());
     }
 
     @Test
     public void setKey() {
         PropertyValue n = PropertyValue.createValue("key", "");
-        assertEquals("key", n.getKey());
+        assertThat("key").isEqualTo(n.getKey());
         n.setKey("jhgjg");
-        assertEquals("jhgjg", n.getKey());
+        assertThat("jhgjg").isEqualTo(n.getKey());
     }
 
     @Test
     public void toBuilder() {
         PropertyValue n = PropertyValue.createValue("key", "");
-        assertNotNull(n.toBuilder());
+        assertThat(n.toBuilder()).isNotNull();
     }
 
     @Test
     public void toPropertyValue() {
         PropertyValue n = PropertyValue.createValue("key", "");
-        assertTrue(n == n.toPropertyValue());
+        assertThat(n == n.toPropertyValue()).isTrue();
     }
 
     @Test
     public void toObjectValue() {
         PropertyValue n = PropertyValue.createValue("key", "");
-        assertNotNull(n.toObjectValue());
+        assertThat(n.toObjectValue()).isNotNull();
     }
 
     @Test
     public void toListValue() {
         PropertyValue n = PropertyValue.createValue("key", "");
-        assertNotNull(n.toListValue());
+        assertThat(n.toListValue()).isNotNull();
     }
 
 //    @Test
@@ -436,11 +432,11 @@ public class PropertyValueTest {
         array.addValue("cVal2");
         Map<String,String> map = n.toMap();
         System.out.println(map);
-        assertEquals(4, map.size());
-        assertEquals("aVal", map.get("a"));
-        assertEquals("b3Val", map.get("b.b2.b3"));
-        assertEquals("cVal1", map.get("c[0]"));
-        assertEquals("cVal2", map.get("c[1]"));
+        assertThat(4).isEqualTo(map.size());
+        assertThat("aVal").isEqualTo(map.get("a"));
+        assertThat("b3Val").isEqualTo(map.get("b.b2.b3"));
+        assertThat("cVal1").isEqualTo(map.get("c[0]"));
+        assertThat("cVal2").isEqualTo(map.get("c[1]"));
     }
 
     @Test
@@ -449,18 +445,18 @@ public class PropertyValueTest {
         n.setValue("a", "aVal");
         n.setValue("b.b2.b3", "b3Val");
         n.setValue("c", "cVal2");
-        assertEquals("a = aVal\n" +
+        assertThat("a = aVal\n" +
                 "b.b2.b3 = b3Val\n" +
-                "c = cVal2\n", n.asString());
+                "c = cVal2\n").isEqualTo(n.asString());
     }
 
     @Test
     public void equals() {
-        assertEquals(PropertyValue.createObject(), PropertyValue.createObject());
-        assertNotEquals(PropertyValue.createObject("a"), PropertyValue.createObject());
-        assertEquals(PropertyValue.createObject(""), PropertyValue.createObject());
+        assertThat(PropertyValue.createObject()).isEqualTo(PropertyValue.createObject());
+        assertThat(PropertyValue.createObject("a")).isNotEqualTo(PropertyValue.createObject());
+        assertThat(PropertyValue.createObject("")).isEqualTo(PropertyValue.createObject());
         PropertyValue root = PropertyValue.createObject();
-        assertEquals(root, root);
+        assertThat(root).isEqualTo(root);
     }
 
     @Test
@@ -469,7 +465,7 @@ public class PropertyValueTest {
         n.setValue("a", "aVal");
         n.setValue("b.b2.b3", "b3Val");
         n.setValue("c", "cVal1");
-        assertEquals("PropertyValue[MAP]{'', size='3'}", n.toString());
+        assertThat("PropertyValue[MAP]{'', size='3'}").isEqualTo(n.toString());
     }
 
-}
\ No newline at end of file
+}
diff --git a/code/spi-support/src/test/java/org/apache/tamaya/spisupport/BuildablePropertySourceProviderTest.java b/code/spi-support/src/test/java/org/apache/tamaya/spisupport/BuildablePropertySourceProviderTest.java
index b69e936..e90e22d 100644
--- a/code/spi-support/src/test/java/org/apache/tamaya/spisupport/BuildablePropertySourceProviderTest.java
+++ b/code/spi-support/src/test/java/org/apache/tamaya/spisupport/BuildablePropertySourceProviderTest.java
@@ -25,7 +25,6 @@ import org.apache.tamaya.spisupport.propertysource.BuildablePropertySourceProvid
 import org.junit.Test;
 
 import static org.assertj.core.api.Assertions.*;
-import static org.junit.Assert.assertNotNull;
 
 public class BuildablePropertySourceProviderTest {
 
@@ -90,7 +89,7 @@ public class BuildablePropertySourceProviderTest {
 
     @Test
     public void testToString(){
-        assertNotNull(BuildablePropertySourceProvider.builder().toString());
-        assertNotNull(BuildablePropertySourceProvider.builder().build().toString());
+        assertThat(BuildablePropertySourceProvider.builder().toString()).isNotNull();
+        assertThat(BuildablePropertySourceProvider.builder().build().toString()).isNotNull();
     }
-}
\ No newline at end of file
+}
diff --git a/code/spi-support/src/test/java/org/apache/tamaya/spisupport/BuildablePropertySourceTest.java b/code/spi-support/src/test/java/org/apache/tamaya/spisupport/BuildablePropertySourceTest.java
index 23ddf8d..8a5bbd2 100644
--- a/code/spi-support/src/test/java/org/apache/tamaya/spisupport/BuildablePropertySourceTest.java
+++ b/code/spi-support/src/test/java/org/apache/tamaya/spisupport/BuildablePropertySourceTest.java
@@ -27,8 +27,6 @@ import org.apache.tamaya.spisupport.propertysource.BuildablePropertySource;
 import org.junit.Test;
 
 import static org.assertj.core.api.Assertions.*;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
 
 public class BuildablePropertySourceTest {
     @Test
@@ -153,14 +151,14 @@ public class BuildablePropertySourceTest {
 
     @Test
     public void testToString(){
-        assertNotNull(BuildablePropertySource.builder().toString());
-        assertNotNull(BuildablePropertySource.builder().build().toString());
+        assertThat(BuildablePropertySource.builder().toString()).isNotNull();
+        assertThat(BuildablePropertySource.builder().build().toString()).isNotNull();
     }
 
     @Test
     public void testGetChangeSupport(){
-        assertEquals(ChangeSupport.IMMUTABLE, BuildablePropertySource.builder().build().getChangeSupport());
+        assertThat(ChangeSupport.IMMUTABLE).isEqualTo(BuildablePropertySource.builder().build().getChangeSupport());
     }
 
 
-}
\ No newline at end of file
+}
diff --git a/code/spi-support/src/test/java/org/apache/tamaya/spisupport/ConfigValueEvaluatorTest.java b/code/spi-support/src/test/java/org/apache/tamaya/spisupport/ConfigValueEvaluatorTest.java
index 4b3b7d2..63cd003 100644
--- a/code/spi-support/src/test/java/org/apache/tamaya/spisupport/ConfigValueEvaluatorTest.java
+++ b/code/spi-support/src/test/java/org/apache/tamaya/spisupport/ConfigValueEvaluatorTest.java
@@ -29,7 +29,7 @@ import java.util.Collections;
 import java.util.List;
 import java.util.Map;
 
-import static org.junit.Assert.*;
+import static org.assertj.core.api.Assertions.assertThat;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.when;
 
@@ -50,20 +50,20 @@ public class ConfigValueEvaluatorTest {
     @Test
     public void evaluteRawValue() {
             PropertyValue value = evaluator.evaluateRawValue("foo", ConfigurationContext.EMPTY);
-            assertNull(value);
+            assertThat(value).isNull();
     }
 
     @Test
     public void evaluteAllValues() {
         List<PropertyValue> values = evaluator.evaluateAllValues("foo", ConfigurationContext.EMPTY);
-        assertNotNull(values);
-        assertTrue(values.isEmpty());
+        assertThat(values).isNotNull();
+        assertThat(values.isEmpty()).isTrue();
     }
 
     @Test
     public void evaluateRawValues() {
         Map<String, PropertyValue> map = evaluator.evaluateRawValues(ConfigurationContext.EMPTY);
-        assertNotNull(map);
-        assertTrue(map.isEmpty());
+        assertThat(map).isNotNull();
+        assertThat(map.isEmpty()).isTrue();
     }
-}
\ No newline at end of file
+}
diff --git a/code/spi-support/src/test/java/org/apache/tamaya/spisupport/DefaultConfigValueEvaluatorTest.java b/code/spi-support/src/test/java/org/apache/tamaya/spisupport/DefaultConfigValueEvaluatorTest.java
index b2c0ed2..341c34f 100644
--- a/code/spi-support/src/test/java/org/apache/tamaya/spisupport/DefaultConfigValueEvaluatorTest.java
+++ b/code/spi-support/src/test/java/org/apache/tamaya/spisupport/DefaultConfigValueEvaluatorTest.java
@@ -23,7 +23,6 @@ import org.apache.tamaya.Configuration;
 import org.apache.tamaya.spi.PropertyValue;
 import org.junit.Test;
 import static org.assertj.core.api.Assertions.*;
-import static org.junit.Assert.assertNotNull;
 
 /**
  *
@@ -59,7 +58,7 @@ public class DefaultConfigValueEvaluatorTest {
 
     @Test
     public void testToString(){
-        assertNotNull(new DefaultConfigValueEvaluator().toString());
+        assertThat(new DefaultConfigValueEvaluator().toString()).isNotNull();
     }
     
 }
diff --git a/code/spi-support/src/test/java/org/apache/tamaya/spisupport/DefaultConfigurationSnapshotTest.java b/code/spi-support/src/test/java/org/apache/tamaya/spisupport/DefaultConfigurationSnapshotTest.java
index 2e20ad1..c1f73ec 100644
--- a/code/spi-support/src/test/java/org/apache/tamaya/spisupport/DefaultConfigurationSnapshotTest.java
+++ b/code/spi-support/src/test/java/org/apache/tamaya/spisupport/DefaultConfigurationSnapshotTest.java
@@ -30,7 +30,7 @@ import java.util.Collections;
 import java.util.HashMap;
 import java.util.Map;
 
-import static org.junit.Assert.*;
+import static org.assertj.core.api.Assertions.assertThat;
 import static org.mockito.Mockito.doReturn;
 import static org.mockito.Mockito.mock;
 
@@ -62,8 +62,8 @@ public class DefaultConfigurationSnapshotTest {
 
         long poiEnd = System.nanoTime();
 
-        assertTrue(fc.getTimestamp()>poiStart);
-        assertTrue(fc.getTimestamp()<poiEnd);
+        assertThat(fc.getTimestamp()>poiStart).isTrue();
+        assertThat(fc.getTimestamp()<poiEnd).isTrue();
     }
 
 
@@ -76,7 +76,7 @@ public class DefaultConfigurationSnapshotTest {
 
         DefaultConfigurationSnapshot fc = new DefaultConfigurationSnapshot(source);
 
-        assertNotNull(fc);
+        assertThat(fc).isNotNull();
     }
 
     /*
@@ -94,7 +94,7 @@ public class DefaultConfigurationSnapshotTest {
         DefaultConfigurationSnapshot fcA = new DefaultConfigurationSnapshot(configuration);
         DefaultConfigurationSnapshot fcB = new DefaultConfigurationSnapshot(configuration);
 
-        assertNotEquals(fcA, fcB);
+        assertThat(fcA).isNotEqualTo(fcB);
     }
 
     /*
@@ -106,9 +106,9 @@ public class DefaultConfigurationSnapshotTest {
         Configuration config = Configuration.current();
         DefaultConfigurationSnapshot snapshot = new DefaultConfigurationSnapshot(config,
                 Arrays.asList("confkey1", "confkey2", "confkey3"));
-        assertEquals(config.getContext().getPropertySources().size(),snapshot.getContext().getPropertySources().size());
-        assertEquals(config.getContext().getPropertyConverters().size(),snapshot.getContext().getPropertyConverters().size());
-        assertEquals(config.getContext().getPropertyFilters().size(),snapshot.getContext().getPropertyFilters().size());
+        assertThat(config.getContext().getPropertySources().size()).isEqualTo(snapshot.getContext().getPropertySources().size());
+        assertThat(config.getContext().getPropertyConverters().size()).isEqualTo(snapshot.getContext().getPropertyConverters().size());
+        assertThat(config.getContext().getPropertyFilters().size()).isEqualTo(snapshot.getContext().getPropertyFilters().size());
     }
 
     @Test
@@ -116,18 +116,18 @@ public class DefaultConfigurationSnapshotTest {
         Configuration config = Configuration.current();
         DefaultConfigurationSnapshot snapshot = new DefaultConfigurationSnapshot(config,
                 Arrays.asList("confkey1", "confkey2", "confkey3"));
-        assertEquals("javaconf-value1", snapshot.get("confkey1"));
-        assertEquals("javaconf-value2", snapshot.get("confkey2"));
-        assertEquals("javaconf-value3", snapshot.get("confkey3"));
-        assertNull(snapshot.getOrDefault("confkey4", null));
-        assertEquals("javaconf-value1", snapshot.get("confkey1", String.class));
-        assertEquals("javaconf-value2", snapshot.get("confkey2", String.class));
-        assertEquals("javaconf-value3", snapshot.get("confkey3", String.class));
-        assertNull(snapshot.getOrDefault("confkey4", String.class, null));
-        assertEquals("javaconf-value1", snapshot.get("confkey1", TypeLiteral.of(String.class)));
-        assertEquals("javaconf-value2", snapshot.get("confkey2", TypeLiteral.of(String.class)));
-        assertEquals("javaconf-value3", snapshot.get("confkey3", TypeLiteral.of(String.class)));
-        assertNull(snapshot.getOrDefault("confkey4", TypeLiteral.of(String.class), null));
+        assertThat("javaconf-value1").isEqualTo(snapshot.get("confkey1"));
+        assertThat("javaconf-value2").isEqualTo(snapshot.get("confkey2"));
+        assertThat("javaconf-value3").isEqualTo(snapshot.get("confkey3"));
+        assertThat(snapshot.getOrDefault("confkey4", null)).isNull();
+        assertThat("javaconf-value1").isEqualTo(snapshot.get("confkey1", String.class));
+        assertThat("javaconf-value2").isEqualTo(snapshot.get("confkey2", String.class));
+        assertThat("javaconf-value3").isEqualTo(snapshot.get("confkey3", String.class));
+        assertThat(snapshot.getOrDefault("confkey4", String.class, null)).isNull();
+        assertThat("javaconf-value1").isEqualTo(snapshot.get("confkey1", TypeLiteral.of(String.class)));
+        assertThat("javaconf-value2").isEqualTo(snapshot.get("confkey2", TypeLiteral.of(String.class)));
+        assertThat("javaconf-value3").isEqualTo(snapshot.get("confkey3", TypeLiteral.of(String.class)));
+        assertThat((String) snapshot.getOrDefault("confkey4", TypeLiteral.of(String.class), null)).isNull();
     }
 
     @Test
@@ -136,12 +136,12 @@ public class DefaultConfigurationSnapshotTest {
         ConfigurationSnapshot snapshot = new DefaultConfigurationSnapshot(config,
                 Arrays.asList("confkey1", "confkey2", "confkey3"));
         snapshot = snapshot.getSnapshot(Arrays.asList("confkey1"));
-        assertEquals("javaconf-value1", snapshot.get("confkey1"));
-        assertNull(snapshot.getOrDefault("confkey2", null));
-        assertEquals("javaconf-value1", snapshot.get("confkey1", String.class));
-        assertNull(snapshot.getOrDefault("confkey2", String.class, null));
-        assertEquals("javaconf-value1", snapshot.get("confkey1", TypeLiteral.of(String.class)));
-        assertNull(snapshot.getOrDefault("confkey2", TypeLiteral.of(String.class), null));
+        assertThat("javaconf-value1").isEqualTo(snapshot.get("confkey1"));
+        assertThat(snapshot.getOrDefault("confkey2", null)).isNull();
+        assertThat("javaconf-value1").isEqualTo(snapshot.get("confkey1", String.class));
+        assertThat(snapshot.getOrDefault("confkey2", String.class, null)).isNull();
+        assertThat("javaconf-value1").isEqualTo(snapshot.get("confkey1", TypeLiteral.of(String.class)));
+        assertThat((String) snapshot.getOrDefault("confkey2", TypeLiteral.of(String.class), null)).isNull();
     }
 
     @Test
@@ -149,10 +149,10 @@ public class DefaultConfigurationSnapshotTest {
         Configuration config = Configuration.current();
         DefaultConfigurationSnapshot snapshot = new DefaultConfigurationSnapshot(config,
                 Arrays.asList("confkey1", "confkey2", "confkey3"));
-        assertEquals("javaconf-value1", snapshot.get(Arrays.asList("confkey1", "foo")));
-        assertEquals("javaconf-value2", snapshot.get(Arrays.asList("foo", "confkey2")));
-        assertEquals("javaconf-value1", snapshot.get(Arrays.asList("confkey1", "foo"), String.class));
-        assertEquals("javaconf-value2", snapshot.get(Arrays.asList("foo", "confkey2"), String.class));
+        assertThat("javaconf-value1").isEqualTo(snapshot.get(Arrays.asList("confkey1", "foo")));
+        assertThat("javaconf-value2").isEqualTo(snapshot.get(Arrays.asList("foo", "confkey2")));
+        assertThat("javaconf-value1").isEqualTo(snapshot.get(Arrays.asList("confkey1", "foo"), String.class));
+        assertThat("javaconf-value2").isEqualTo(snapshot.get(Arrays.asList("foo", "confkey2"), String.class));
     }
 
     @Test
@@ -160,12 +160,12 @@ public class DefaultConfigurationSnapshotTest {
         Configuration config = Configuration.current();
         DefaultConfigurationSnapshot snapshot = new DefaultConfigurationSnapshot(config,
                 Arrays.asList("confkey1", "confkey2", "confkey3"));
-        assertEquals("javaconf-value1", snapshot.getOrDefault("confkey1", "foo"));
-        assertEquals("javaconf-value2", snapshot.getOrDefault("confkey2", "foo"));
-        assertEquals("javaconf-value2", snapshot.getOrDefault("confkey2", String.class,"foo"));
-        assertEquals("javaconf-value3", snapshot.getOrDefault("confkey3", "foo"));
-        assertEquals("foo", snapshot.getOrDefault("confkey4", "foo"));
-        assertEquals("foo", snapshot.getOrDefault("confkey4", String.class,"foo"));
+        assertThat("javaconf-value1").isEqualTo(snapshot.getOrDefault("confkey1", "foo"));
+        assertThat("javaconf-value2").isEqualTo(snapshot.getOrDefault("confkey2", "foo"));
+        assertThat("javaconf-value2").isEqualTo(snapshot.getOrDefault("confkey2", String.class,"foo"));
+        assertThat("javaconf-value3").isEqualTo(snapshot.getOrDefault("confkey3", "foo"));
+        assertThat("foo").isEqualTo(snapshot.getOrDefault("confkey4", "foo"));
+        assertThat("foo").isEqualTo(snapshot.getOrDefault("confkey4", String.class,"foo"));
     }
 
     @Test
@@ -174,12 +174,12 @@ public class DefaultConfigurationSnapshotTest {
         DefaultConfigurationSnapshot snapshot = new DefaultConfigurationSnapshot(config,
                 Arrays.asList("confkey1", "confkey2", "confkey3", "missing"));
         Map<String, String> properties = snapshot.getProperties();
-        assertNotNull(properties);
-        assertEquals(3, properties.size());
-        assertEquals("javaconf-value1", properties.get("confkey1"));
-        assertEquals("javaconf-value2", properties.get("confkey2"));
-        assertEquals("javaconf-value3", properties.get("confkey3"));
-        assertEquals(null, properties.get("confkey4"));
+        assertThat(properties).isNotNull();
+        assertThat(properties).hasSize(3);
+        assertThat("javaconf-value1").isEqualTo(properties.get("confkey1"));
+        assertThat("javaconf-value2").isEqualTo(properties.get("confkey2"));
+        assertThat("javaconf-value3").isEqualTo(properties.get("confkey3"));
+        assertThat(properties.get("confkey4")).isNull();
     }
 
     @Test
@@ -189,9 +189,9 @@ public class DefaultConfigurationSnapshotTest {
                 Arrays.asList("confkey1", "confkey2", "confkey3", "foo"));
         ConfigurationSnapshot snapshot2 = new DefaultConfigurationSnapshot(config,
                 Arrays.asList("confkey1", "confkey2", "confkey3", "foo"));
-        assertNotEquals(snapshot1, snapshot2);
-        assertNotEquals(((DefaultConfigurationSnapshot) snapshot1).getId(),
-                ((DefaultConfigurationSnapshot) snapshot2).getId());
+        assertThat(snapshot1).isNotEqualTo(snapshot2);
+        assertThat(((DefaultConfigurationSnapshot) snapshot1).getId())
+            .isNotEqualTo(((DefaultConfigurationSnapshot) snapshot2).getId());
     }
 
     @Test
@@ -200,10 +200,10 @@ public class DefaultConfigurationSnapshotTest {
         ConfigurationSnapshot snapshot = new DefaultConfigurationSnapshot(config,
                 Arrays.asList("confkey1", "confkey2", "confkey3"));
         snapshot = snapshot.getSnapshot(Arrays.asList("confkey1"));
-        assertEquals("javaconf-value1", snapshot.getOrDefault("confkey1", "foo"));
-        assertEquals("foo", snapshot.getOrDefault("confkey2", "foo"));
-        assertEquals("javaconf-value1", snapshot.getOrDefault("confkey1", String.class,"foo"));
-        assertEquals("foo", snapshot.getOrDefault("confkey2", String.class, "foo"));
+        assertThat("javaconf-value1").isEqualTo(snapshot.getOrDefault("confkey1", "foo"));
+        assertThat("foo").isEqualTo(snapshot.getOrDefault("confkey2", "foo"));
+        assertThat("javaconf-value1").isEqualTo(snapshot.getOrDefault("confkey1", String.class,"foo"));
+        assertThat("foo").isEqualTo(snapshot.getOrDefault("confkey2", String.class, "foo"));
     }
 
     @Test
@@ -211,10 +211,10 @@ public class DefaultConfigurationSnapshotTest {
         Configuration config = Configuration.current();
         DefaultConfigurationSnapshot snapshot = new DefaultConfigurationSnapshot(config,
                 Arrays.asList("confkey1", "confkey2", "confkey3"));
-        assertEquals("javaconf-value1", snapshot.getOrDefault(Arrays.asList("confkey1", "foo"), "foo"));
-        assertEquals("foo", snapshot.getOrDefault(Arrays.asList("confkeyNone", "foo"), "foo"));
-        assertEquals("javaconf-value1", snapshot.getOrDefault(Arrays.asList("confkey1", "foo"), String.class, "foo"));
-        assertEquals("foo", snapshot.getOrDefault(Arrays.asList("confkeyNone", "foo"), String.class, "foo"));
+        assertThat("javaconf-value1").isEqualTo(snapshot.getOrDefault(Arrays.asList("confkey1", "foo"), "foo"));
+        assertThat("foo").isEqualTo(snapshot.getOrDefault(Arrays.asList("confkeyNone", "foo"), "foo"));
+        assertThat("javaconf-value1").isEqualTo(snapshot.getOrDefault(Arrays.asList("confkey1", "foo"), String.class, "foo"));
+        assertThat("foo").isEqualTo(snapshot.getOrDefault(Arrays.asList("confkeyNone", "foo"), String.class, "foo"));
     }
 
     @Test
@@ -222,11 +222,11 @@ public class DefaultConfigurationSnapshotTest {
         Configuration config = Configuration.current();
         DefaultConfigurationSnapshot snapshot = new DefaultConfigurationSnapshot(config,
                 Arrays.asList("confkey1", "confkey2", "confkey3"));
-        assertTrue(snapshot.getKeys().contains("confkey1"));
-        assertTrue(snapshot.getKeys().contains("confkey2"));
-        assertTrue(snapshot.getKeys().contains("confkey3"));
-        assertFalse(snapshot.getKeys().contains("confkey4"));
-        assertFalse(snapshot.getKeys().contains("foo"));
+        assertThat(snapshot.getKeys().contains("confkey1")).isTrue();
+        assertThat(snapshot.getKeys().contains("confkey2")).isTrue();
+        assertThat(snapshot.getKeys().contains("confkey3")).isTrue();
+        assertThat(snapshot.getKeys().contains("confkey4")).isFalse();
+        assertThat(snapshot.getKeys().contains("foo")).isFalse();
     }
 
     @Test
@@ -234,23 +234,23 @@ public class DefaultConfigurationSnapshotTest {
         Configuration config = Configuration.current();
         ConfigurationSnapshot snapshot = new DefaultConfigurationSnapshot(config,
                 Arrays.asList("confkey1", "confkey2", "confkey3"));
-        assertTrue(snapshot.getKeys().contains("confkey1"));
-        assertTrue(snapshot.getKeys().contains("confkey2"));
-        assertTrue(snapshot.getKeys().contains("confkey3"));
-        assertFalse(snapshot.getKeys().contains("confkey4"));
-        assertFalse(snapshot.getKeys().contains("foo"));
+        assertThat(snapshot.getKeys().contains("confkey1")).isTrue();
+        assertThat(snapshot.getKeys().contains("confkey2")).isTrue();
+        assertThat(snapshot.getKeys().contains("confkey3")).isTrue();
+        assertThat(snapshot.getKeys().contains("confkey4")).isFalse();
+        assertThat(snapshot.getKeys().contains("foo")).isFalse();
         snapshot = snapshot.getSnapshot(Arrays.asList("confkey1", "confkey2"));
-        assertTrue(snapshot.getKeys().contains("confkey1"));
-        assertTrue(snapshot.getKeys().contains("confkey2"));
-        assertFalse(snapshot.getKeys().contains("confkey3"));
-        assertFalse(snapshot.getKeys().contains("confkey4"));
-        assertFalse(snapshot.getKeys().contains("foo"));
+        assertThat(snapshot.getKeys().contains("confkey1")).isTrue();
+        assertThat(snapshot.getKeys().contains("confkey2")).isTrue();
+        assertThat(snapshot.getKeys().contains("confkey3")).isFalse();
+        assertThat(snapshot.getKeys().contains("confkey4")).isFalse();
+        assertThat(snapshot.getKeys().contains("foo")).isFalse();
         snapshot = snapshot.getSnapshot(Arrays.asList("confkey1", "foo"));
-        assertTrue(snapshot.getKeys().contains("confkey1"));
-        assertFalse(snapshot.getKeys().contains("confkey2"));
-        assertFalse(snapshot.getKeys().contains("confkey3"));
-        assertFalse(snapshot.getKeys().contains("confkey4"));
-        assertTrue(snapshot.getKeys().contains("foo"));
+        assertThat(snapshot.getKeys().contains("confkey1")).isTrue();
+        assertThat(snapshot.getKeys().contains("confkey2")).isFalse();
+        assertThat(snapshot.getKeys().contains("confkey3")).isFalse();
+        assertThat(snapshot.getKeys().contains("confkey4")).isFalse();
+        assertThat(snapshot.getKeys().contains("foo")).isTrue();
     }
 
-}
\ No newline at end of file
+}
diff --git a/code/spi-support/src/test/java/org/apache/tamaya/spisupport/DefaultMetaDataProviderTest.java b/code/spi-support/src/test/java/org/apache/tamaya/spisupport/DefaultMetaDataProviderTest.java
index 32aba25..270b02b 100644
--- a/code/spi-support/src/test/java/org/apache/tamaya/spisupport/DefaultMetaDataProviderTest.java
+++ b/code/spi-support/src/test/java/org/apache/tamaya/spisupport/DefaultMetaDataProviderTest.java
@@ -26,7 +26,7 @@ import java.util.Collections;
 import java.util.HashMap;
 import java.util.Map;
 
-import static org.junit.Assert.*;
+import static org.assertj.core.api.Assertions.assertThat;
 
 /**
  * Tests for {@link DefaultMetaDataProvider}.
@@ -41,58 +41,58 @@ public class DefaultMetaDataProviderTest {
     @Test
     public void init() {
         DefaultMetaDataProvider provider = new DefaultMetaDataProvider();
-        assertEquals(provider, provider.init(ConfigurationContext.EMPTY));
+        assertThat(provider).isEqualTo(provider.init(ConfigurationContext.EMPTY));
     }
 
     @Test
     public void getMetaData() {
         DefaultMetaDataProvider provider = new DefaultMetaDataProvider();
-        assertEquals(provider, provider.init(ConfigurationContext.EMPTY));
-        assertNotNull(provider.getMetaData("foo"));
+        assertThat(provider).isEqualTo(provider.init(ConfigurationContext.EMPTY));
+        assertThat(provider.getMetaData("foo")).isNotNull();
 
     }
 
     @Test
     public void setMeta() {
         DefaultMetaDataProvider provider = new DefaultMetaDataProvider();
-        assertEquals(provider, provider.init(ConfigurationContext.EMPTY));
+        assertThat(provider).isEqualTo(provider.init(ConfigurationContext.EMPTY));
         provider.setMeta("foo", "a", "b");
-        assertNotNull(provider.getMetaData("foo"));
-        assertEquals(1, provider.getMetaData("foo").size());
+        assertThat(provider.getMetaData("foo")).isNotNull();
+        assertThat(1).isEqualTo(provider.getMetaData("foo").size());
     }
 
     @Test
     public void setMeta_Map() {
         DefaultMetaDataProvider provider = new DefaultMetaDataProvider();
-        assertEquals(provider, provider.init(ConfigurationContext.EMPTY));
+        assertThat(provider).isEqualTo(provider.init(ConfigurationContext.EMPTY));
         Map<String,String> map = new HashMap<>();
         map.put("a", "b");
         provider.setMeta("foo", map);
-        assertNotNull(provider.getMetaData("foo"));
-        assertEquals(1, provider.getMetaData("foo").size());
+        assertThat(provider.getMetaData("foo")).isNotNull();
+        assertThat(1).isEqualTo(provider.getMetaData("foo").size());
 
     }
 
     @Test
     public void reset() {
         DefaultMetaDataProvider provider = new DefaultMetaDataProvider();
-        assertEquals(provider, provider.init(ConfigurationContext.EMPTY));
+        assertThat(provider).isEqualTo(provider.init(ConfigurationContext.EMPTY));
         provider.reset();
-        assertNotNull(provider.getMetaData("foo"));
-        assertTrue(provider.getMetaData("foo").isEmpty());
+        assertThat(provider.getMetaData("foo")).isNotNull();
+        assertThat(provider.getMetaData("foo").isEmpty()).isTrue();
     }
 
     @Test
     public void reset1() {
         DefaultMetaDataProvider provider = new DefaultMetaDataProvider();
-        assertEquals(provider, provider.init(ConfigurationContext.EMPTY));
+        assertThat(provider).isEqualTo(provider.init(ConfigurationContext.EMPTY));
         provider.reset();
-        assertNotNull(provider.getMetaData("foo"));
-        assertTrue(provider.getMetaData("foo").isEmpty());
+        assertThat(provider.getMetaData("foo")).isNotNull();
+        assertThat(provider.getMetaData("foo").isEmpty()).isTrue();
     }
 
 
     @Test
     public void testToString() {
     }
-}
\ No newline at end of file
+}
diff --git a/code/spi-support/src/test/java/org/apache/tamaya/spisupport/DefaultPropertySourceSnapshotTest.java b/code/spi-support/src/test/java/org/apache/tamaya/spisupport/DefaultPropertySourceSnapshotTest.java
index 2439029..f2bd222 100644
--- a/code/spi-support/src/test/java/org/apache/tamaya/spisupport/DefaultPropertySourceSnapshotTest.java
+++ b/code/spi-support/src/test/java/org/apache/tamaya/spisupport/DefaultPropertySourceSnapshotTest.java
@@ -25,7 +25,7 @@ import org.junit.Test;
 
 import java.util.Map;
 
-import static org.junit.Assert.*;
+import static org.assertj.core.api.Assertions.*;
 
 /**
  * Tests for {@link DefaultPropertySourceSnapshot}.
@@ -37,41 +37,41 @@ public class DefaultPropertySourceSnapshotTest {
     @Test
     public void testOf() throws Exception {
         PropertySource ps = DefaultPropertySourceSnapshot.of(myPS);
-        assertNotNull(ps);
+        assertThat(ps).isNotNull();
     }
 
     @Test
     public void testGetName() throws Exception {
         PropertySource ps = DefaultPropertySourceSnapshot.of(myPS);
         String name = ps.getName();
-        assertNotNull(name);
-        assertEquals(name, ps.getName());
+        assertThat(name).isNotNull();
+        assertThat(name).isEqualTo(ps.getName());
     }
 
     @Test
     public void testGetOrdinal() throws Exception {
         PropertySource ps = DefaultPropertySourceSnapshot.of(myPS);
-        assertEquals(PropertySourceComparator.getOrdinal(myPS),
-                PropertySourceComparator.getOrdinal(ps));
+        assertThat(PropertySourceComparator.getOrdinal(myPS))
+            .isEqualTo(PropertySourceComparator.getOrdinal(ps));
     }
 
     @Test
     public void testGet() throws Exception {
         PropertySource ps = DefaultPropertySourceSnapshot.of(myPS);
-        assertNotNull(ps);
+        assertThat(ps).isNotNull();
         for (Map.Entry<String, PropertyValue> e : myPS.getProperties().entrySet()) {
-            assertEquals(ps.get(e.getKey()).getValue(), e.getValue().getValue());
+            assertThat(ps.get(e.getKey()).getValue()).isEqualTo(e.getValue().getValue());
         }
     }
 
     @Test
     public void testGetProperties() throws Exception {
         PropertySource ps = DefaultPropertySourceSnapshot.of(myPS);
-        assertNotNull(ps);
-        assertNotNull(ps.getProperties());
-        assertFalse(ps.getProperties().isEmpty());
+        assertThat(ps).isNotNull();
+        assertThat(ps.getProperties()).isNotNull();
+        assertThat(ps.getProperties().isEmpty()).isFalse();
         for(Map.Entry en:myPS.getProperties().entrySet()){
-            assertEquals(en.getValue(), ps.get((String)en.getKey()));
+            assertThat(en.getValue()).isEqualTo(ps.get((String)en.getKey()));
         }
     }
 
@@ -79,8 +79,8 @@ public class DefaultPropertySourceSnapshotTest {
     public void testEquals() throws Exception {
         PropertySource ps1 = DefaultPropertySourceSnapshot.of(myPS);
         PropertySource ps2 = DefaultPropertySourceSnapshot.of(myPS);
-        assertEquals(ps1.getName(), ps2.getName());
-        assertEquals(ps1.getProperties().size(), ps2.getProperties().size());
+        assertThat(ps1.getName()).isEqualTo(ps2.getName());
+        assertThat(ps1.getProperties().size()).isEqualTo(ps2.getProperties().size());
     }
 
     @Test
@@ -104,8 +104,8 @@ public class DefaultPropertySourceSnapshotTest {
     public void testToString() throws Exception {
         PropertySource ps = DefaultPropertySourceSnapshot.of(myPS);
         String toString = ps.toString();
-        assertNotNull(toString);
-        assertTrue(toString.contains("FrozenPropertySource"));
-        assertTrue(toString.contains(myPS.getName()));
+        assertThat(toString).isNotNull();
+        assertThat(toString.contains("FrozenPropertySource")).isTrue();
+        assertThat(toString.contains(myPS.getName())).isTrue();
     }
-}
\ No newline at end of file
+}
diff --git a/code/spi-support/src/test/java/org/apache/tamaya/spisupport/PropertySourceChangeSupportTest.java b/code/spi-support/src/test/java/org/apache/tamaya/spisupport/PropertySourceChangeSupportTest.java
index 90e7b9e..0fe2a12 100644
--- a/code/spi-support/src/test/java/org/apache/tamaya/spisupport/PropertySourceChangeSupportTest.java
+++ b/code/spi-support/src/test/java/org/apache/tamaya/spisupport/PropertySourceChangeSupportTest.java
@@ -29,7 +29,7 @@ import java.util.Set;
 import java.util.concurrent.TimeUnit;
 import java.util.function.BiConsumer;
 
-import static org.junit.Assert.*;
+import static org.assertj.core.api.Assertions.assertThat;
 import static org.mockito.Matchers.any;
 import static org.mockito.Mockito.*;
 
@@ -42,9 +42,9 @@ public class PropertySourceChangeSupportTest {
     public void getChangeSupport() {
         PropertySource ps = BuildablePropertySource.builder().withName("test").build();
         PropertySourceChangeSupport support = new PropertySourceChangeSupport(ChangeSupport.IMMUTABLE, ps);
-        assertEquals(ChangeSupport.IMMUTABLE, support.getChangeSupport());
+        assertThat(ChangeSupport.IMMUTABLE).isEqualTo(support.getChangeSupport());
         support = new PropertySourceChangeSupport(ChangeSupport.UNSUPPORTED, ps);
-        assertEquals(ChangeSupport.UNSUPPORTED, support.getChangeSupport());
+        assertThat(ChangeSupport.UNSUPPORTED).isEqualTo(support.getChangeSupport());
     }
 
     @Test
@@ -53,12 +53,12 @@ public class PropertySourceChangeSupportTest {
         PropertySourceChangeSupport support = new PropertySourceChangeSupport(ChangeSupport.IMMUTABLE, ps);
         support.load(ps.getProperties());
         String v0 = support.getVersion();
-        assertNotNull(v0);
+        assertThat(v0).isNotNull();
         String v1 = support.getVersion();
         support.load(Collections.emptyMap());
         String v2 = support.getVersion();
-        assertEquals(v0, v1);
-        assertEquals(v1, v2);
+        assertThat(v0).isEqualTo(v1);
+        assertThat(v1).isEqualTo(v2);
     }
 
     @Test
@@ -67,12 +67,12 @@ public class PropertySourceChangeSupportTest {
         PropertySourceChangeSupport support = new PropertySourceChangeSupport(ChangeSupport.SUPPORTED, ps);
         support.load(ps.getProperties());
         String v0 = support.getVersion();
-        assertNotNull(v0);
+        assertThat(v0).isNotNull();
         String v1 = support.getVersion();
         support.load(Collections.emptyMap());
         String v2 = support.getVersion();
-        assertEquals(v0, v1);
-        assertNotEquals(v1, v2);
+        assertThat(v0).isEqualTo(v1);
+        assertThat(v1).isNotEqualTo(v2);
     }
 
     @Test
@@ -122,8 +122,8 @@ public class PropertySourceChangeSupportTest {
                 .withSimpleProperty("foo", "bar").build();
         PropertySourceChangeSupport support = new PropertySourceChangeSupport(ChangeSupport.IMMUTABLE, ps);
         support.load(ps.getProperties());
-        assertNotNull(support.getValue("foo"));
-        assertNull(support.getValue("bar"));
+        assertThat(support.getValue("foo")).isNotNull();
+        assertThat(support.getValue("bar")).isNull();
     }
 
     @Test
@@ -132,12 +132,12 @@ public class PropertySourceChangeSupportTest {
                 .withSimpleProperty("foo", "bar").build();
         PropertySourceChangeSupport support = new PropertySourceChangeSupport(ChangeSupport.IMMUTABLE, ps);
         Map properties = support.getProperties();
-        assertNotNull(properties);
-        assertTrue(properties.isEmpty());
+        assertThat(properties).isNotNull();
+        assertThat(properties.isEmpty()).isTrue();
         support.load(ps.getProperties());
         properties = support.getProperties();
-        assertNotNull(properties);
-        assertEquals(1, properties.size());
+        assertThat(properties).isNotNull();
+        assertThat(properties).hasSize(1);
     }
 
     @Test
@@ -150,7 +150,7 @@ public class PropertySourceChangeSupportTest {
         support.scheduleChangeMonitor(() -> Collections.emptyMap(), 500, TimeUnit.MILLISECONDS);
         Thread.sleep(600L);
         String v2 = support.getVersion();
-        assertNotEquals(v1, v2);
+        assertThat(v1).isNotEqualTo(v2);
     }
 
     @Test
@@ -164,6 +164,6 @@ public class PropertySourceChangeSupportTest {
         Thread.sleep(500L);
         support.cancelSchedule();
         String v2 = support.getVersion();
-        assertEquals(v1, v2);
+        assertThat(v1).isEqualTo(v2);
     }
-}
\ No newline at end of file
+}
diff --git a/code/spi-support/src/test/java/org/apache/tamaya/spisupport/propertysource/SimplePropertySourceTest.java b/code/spi-support/src/test/java/org/apache/tamaya/spisupport/propertysource/SimplePropertySourceTest.java
index aa34456..5d2fc2d 100644
--- a/code/spi-support/src/test/java/org/apache/tamaya/spisupport/propertysource/SimplePropertySourceTest.java
+++ b/code/spi-support/src/test/java/org/apache/tamaya/spisupport/propertysource/SimplePropertySourceTest.java
@@ -32,7 +32,6 @@ import java.util.Map;
 import java.util.UUID;
 
 import static org.assertj.core.api.Assertions.*;
-import static org.junit.Assert.assertEquals;
 
 public class SimplePropertySourceTest {
 
@@ -95,7 +94,7 @@ public class SimplePropertySourceTest {
     public void getChangeSupport(){
         URL resource = getClass().getResource("/valid-properties.xml");
         SimplePropertySource source = new SimplePropertySource(resource);
-        assertEquals(ChangeSupport.IMMUTABLE, source.getChangeSupport());
+        assertThat(ChangeSupport.IMMUTABLE).isEqualTo(source.getChangeSupport());
     }
 
     @Test
diff --git a/code/spi-support/src/test/java/org/apache/tamaya/spisupport/propertysource/SystemPropertySourceTest.java b/code/spi-support/src/test/java/org/apache/tamaya/spisupport/propertysource/SystemPropertySourceTest.java
index 271c47c..817a748 100644
--- a/code/spi-support/src/test/java/org/apache/tamaya/spisupport/propertysource/SystemPropertySourceTest.java
+++ b/code/spi-support/src/test/java/org/apache/tamaya/spisupport/propertysource/SystemPropertySourceTest.java
@@ -28,8 +28,6 @@ import org.junit.Test;
 import java.util.Map;
 import java.util.Properties;
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
 
 public class SystemPropertySourceTest {
 
@@ -38,10 +36,10 @@ public class SystemPropertySourceTest {
     @Test
     public void testConstrcutorWithPrefix() throws Exception {
         SystemPropertySource testPropertySource = new SystemPropertySource("PRE::");
-        assertNotNull(testPropertySource.getProperties());
+        assertThat(testPropertySource.getProperties()).isNotNull();
         for(Map.Entry en:System.getProperties().entrySet()){
-            assertEquals(System.getProperty(en.getKey().toString()),
-                    testPropertySource.get("PRE::"+en.getKey()).getValue());
+            assertThat(System.getProperty(en.getKey().toString()))
+                .isEqualTo(testPropertySource.get("PRE::"+en.getKey()).getValue());
         }
     }
 


Mime
View raw message