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 <acob...@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());
}
}
