You are viewing a plain text version of this content. The canonical link for it is here.
Posted to dev@plc4x.apache.org by GitBox <gi...@apache.org> on 2018/02/16 18:35:27 UTC
[GitHub] sruehl closed pull request #4: Change from AssertJ to Hamcrest
sruehl closed pull request #4: Change from AssertJ to Hamcrest
URL: https://github.com/apache/incubator-plc4x/pull/4
This is a PR merged from a forked repository.
As GitHub hides the original diff on merge, it is displayed below for
the sake of provenance:
As this is a foreign pull request (from a fork), the diff is supplied
below (as it won't show otherwise due to GitHub magic):
diff --git a/integrations/apache-camel/src/test/java/org/apache/plc4x/camel/ConstantsTest.java b/integrations/apache-camel/src/test/java/org/apache/plc4x/camel/ConstantsTest.java
index 12703b29..b13c074e 100644
--- a/integrations/apache-camel/src/test/java/org/apache/plc4x/camel/ConstantsTest.java
+++ b/integrations/apache-camel/src/test/java/org/apache/plc4x/camel/ConstantsTest.java
@@ -18,23 +18,20 @@ Licensed to the Apache Software Foundation (ASF) under one
*/
package org.apache.plc4x.camel;
-import org.assertj.core.api.Assertions;
import org.junit.Test;
import java.lang.reflect.Constructor;
public class ConstantsTest {
- @Test
- public void testConstantsNotInstanceable() throws Exception {
- Assertions.assertThatThrownBy(() -> {
- try {
- Constructor<Constants> constructor = Constants.class.getDeclaredConstructor();
- constructor.setAccessible(true);
- constructor.newInstance();
- } catch (Exception e) {
- throw e.getCause();
- }
- }).isInstanceOf(IllegalStateException.class);
+ @Test(expected = IllegalStateException.class)
+ public void testConstantsNotInstanceable() throws Throwable {
+ try {
+ Constructor<Constants> constructor = Constants.class.getDeclaredConstructor();
+ constructor.setAccessible(true);
+ constructor.newInstance();
+ } catch (Exception e) {
+ throw e.getCause();
+ }
}
}
\ No newline at end of file
diff --git a/integrations/apache-camel/src/test/java/org/apache/plc4x/camel/PLC4XEndpointTest.java b/integrations/apache-camel/src/test/java/org/apache/plc4x/camel/PLC4XEndpointTest.java
index eaa45ffd..f2236156 100644
--- a/integrations/apache-camel/src/test/java/org/apache/plc4x/camel/PLC4XEndpointTest.java
+++ b/integrations/apache-camel/src/test/java/org/apache/plc4x/camel/PLC4XEndpointTest.java
@@ -19,10 +19,12 @@ Licensed to the Apache Software Foundation (ASF) under one
package org.apache.plc4x.camel;
import org.apache.camel.Component;
-import org.assertj.core.api.Assertions;
import org.junit.Before;
import org.junit.Test;
+import static org.hamcrest.core.Is.is;
+import static org.hamcrest.core.IsNull.notNullValue;
+import static org.junit.Assert.assertThat;
import static org.mockito.Mockito.mock;
public class PLC4XEndpointTest {
@@ -36,18 +38,17 @@ public void setUp() throws Exception {
@Test
public void createProducer() throws Exception {
- Assertions.assertThat(SUT.createProducer()).isNotNull();
+ assertThat(SUT.createProducer(), notNullValue());
}
- @Test
+ @Test(expected = UnsupportedOperationException.class)
public void createConsumer() throws Exception {
- Assertions.assertThatThrownBy(() -> SUT.createConsumer(null))
- .isInstanceOf(UnsupportedOperationException.class);
+ SUT.createConsumer(null);
}
@Test
public void isSingleton() throws Exception {
- Assertions.assertThat(SUT.isSingleton()).isTrue();
+ assertThat(SUT.isSingleton(), is(true));
}
}
\ No newline at end of file
diff --git a/integrations/apache-edgent/src/test/java/org/apache/plc4x/edgent/PlcConnectionAdapterTest.java b/integrations/apache-edgent/src/test/java/org/apache/plc4x/edgent/PlcConnectionAdapterTest.java
index 37e3ae21..16fd5818 100644
--- a/integrations/apache-edgent/src/test/java/org/apache/plc4x/edgent/PlcConnectionAdapterTest.java
+++ b/integrations/apache-edgent/src/test/java/org/apache/plc4x/edgent/PlcConnectionAdapterTest.java
@@ -35,7 +35,6 @@ Licensed to the Apache Software Foundation (ASF) under one
import org.apache.plc4x.java.api.messages.specific.TypeSafePlcWriteResponse;
import org.apache.plc4x.java.api.model.Address;
import org.apache.plc4x.test.FastTests;
-import org.assertj.core.api.Assertions;
import org.junit.Test;
import org.junit.experimental.categories.Category;
@@ -45,7 +44,14 @@ Licensed to the Apache Software Foundation (ASF) under one
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
-import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.hamcrest.core.Is.is;
+import static org.hamcrest.core.IsEqual.equalTo;
+import static org.hamcrest.core.IsNot.not;
+import static org.hamcrest.core.IsNull.notNullValue;
+import static org.hamcrest.core.IsNull.nullValue;
+import static org.hamcrest.core.IsSame.sameInstance;
+import static org.hamcrest.object.IsCompatibleType.typeCompatibleWith;
+import static org.junit.Assert.assertThat;
public class PlcConnectionAdapterTest {
@@ -61,9 +67,9 @@ protected MockConnection getMockConnection() throws PlcConnectionException {
public void testCtor1() throws Exception {
MockConnection mockConnection = getMockConnection();
PlcConnectionAdapter adapter = new PlcConnectionAdapter(mockConnection);
- Assertions.assertThat(mockConnection).isSameAs(adapter.getConnection());
+ assertThat(mockConnection, sameInstance(adapter.getConnection()));
// and again... multiple adapter.getConnection() returns the same
- Assertions.assertThat(mockConnection).isSameAs(adapter.getConnection());
+ assertThat(mockConnection, sameInstance(adapter.getConnection()));
adapter.close();
}
@@ -76,10 +82,10 @@ public void testCtor2() throws Exception {
MockConnection mockConnection = getMockConnection();
PlcConnectionAdapter adapter = new PlcConnectionAdapter(mockConnection.getUrl());
MockConnection mockConnection2 = (MockConnection) adapter.getConnection();
- Assertions.assertThat(mockConnection).isNotSameAs(mockConnection2);
- Assertions.assertThat(mockConnection.getUrl()).isSameAs(mockConnection2.getUrl());
+ assertThat(mockConnection, not(sameInstance(mockConnection2)));
+ assertThat(mockConnection.getUrl(), sameInstance(mockConnection2.getUrl()));
// and again... multiple adapter.getConnection() returns the same
- Assertions.assertThat(mockConnection2).isSameAs(adapter.getConnection());
+ assertThat(mockConnection2, sameInstance(adapter.getConnection()));
adapter.close();
}
@@ -93,12 +99,16 @@ public void testCheckDatatype() throws Exception {
PlcConnectionAdapter.checkDatatype(Float.class);
PlcConnectionAdapter.checkDatatype(String.class);
PlcConnectionAdapter.checkDatatype(Calendar.class);
- assertThatThrownBy(() ->
- PlcConnectionAdapter.checkDatatype(Long.class))
- .isInstanceOf(IllegalArgumentException.class);
- assertThatThrownBy(() ->
- PlcConnectionAdapter.checkDatatype(Double.class))
- .isInstanceOf(IllegalArgumentException.class);
+ }
+
+ @Test(expected = IllegalArgumentException.class)
+ public void testLongDataTypeIsInvalid() {
+ PlcConnectionAdapter.checkDatatype(Long.class);
+ }
+
+ @Test(expected = IllegalArgumentException.class)
+ public void testDoubleDataTypeIsInvalid() {
+ PlcConnectionAdapter.checkDatatype(Double.class);
}
private <T> void checkRead(MockConnection connection, TypeSafePlcReadRequest<T> request, T value) throws InterruptedException, ExecutionException {
@@ -108,9 +118,9 @@ public void testCheckDatatype() throws Exception {
CompletableFuture<TypeSafePlcReadResponse<T>> cf = connection.read(request);
- Assertions.assertThat(cf.isDone()).isTrue();
+ assertThat(cf.isDone(), is(true));
TypeSafePlcReadResponse<T> response = cf.get();
- Assertions.assertThat(value).isEqualTo(response.getResponseItems().get(0).getValues().get(0));
+ assertThat(value, equalTo(response.getResponseItems().get(0).getValues().get(0)));
}
@SuppressWarnings("unchecked")
@@ -121,9 +131,9 @@ public void testCheckDatatype() throws Exception {
CompletableFuture<TypeSafePlcWriteResponse<T>> cf = connection.write(request);
- Assertions.assertThat(cf.isDone()).isTrue();
+ assertThat(cf.isDone(), is(true));
PlcWriteResponse response = cf.get();
- Assertions.assertThat(response).isNotNull();
+ assertThat(response, notNullValue());
T writtenData = (T) connection.getDataValue(request.getRequestItems().get(0).getAddress());
if (writtenData.getClass().isArray()) {
writtenData = (T) Array.get(writtenData, 0);
@@ -131,7 +141,7 @@ public void testCheckDatatype() throws Exception {
if (List.class.isAssignableFrom(writtenData.getClass())) {
writtenData = (T) ((List) writtenData).get(0);
}
- Assertions.assertThat(value).isEqualTo(writtenData);
+ assertThat(value, equalTo(writtenData));
}
/*
@@ -150,8 +160,8 @@ public void testNewPlcReadRequest() throws Exception {
TypeSafePlcReadRequest<Boolean> request = PlcConnectionAdapter.newPlcReadRequest(Boolean.class, address);
ReadRequestItem<Boolean> requestItem = request.getCheckedReadRequestItems().get(0);
Class<Boolean> dataType = requestItem.getDatatype();
- Assertions.assertThat(dataType).isEqualTo(Boolean.class);
- Assertions.assertThat(address).isSameAs(requestItem.getAddress());
+ assertThat(dataType, equalTo(Boolean.class));
+ assertThat(address, sameInstance(requestItem.getAddress()));
checkRead(connection, request, true);
checkRead(connection, request, false);
}
@@ -159,8 +169,8 @@ public void testNewPlcReadRequest() throws Exception {
TypeSafePlcReadRequest<Byte> request = PlcConnectionAdapter.newPlcReadRequest(Byte.class, address);
ReadRequestItem<Byte> requestItem = request.getCheckedReadRequestItems().get(0);
Class<Byte> dataType = requestItem.getDatatype();
- Assertions.assertThat(dataType).isEqualTo(Byte.class);
- Assertions.assertThat(address).isSameAs(requestItem.getAddress());
+ assertThat(dataType, equalTo(Byte.class));
+ assertThat(address, sameInstance(requestItem.getAddress()));
checkRead(connection, request, (byte) 0x13);
checkRead(connection, request, (byte) 0x23);
}
@@ -168,8 +178,8 @@ public void testNewPlcReadRequest() throws Exception {
TypeSafePlcReadRequest<Short> request = PlcConnectionAdapter.newPlcReadRequest(Short.class, address);
ReadRequestItem<Short> requestItem = request.getCheckedReadRequestItems().get(0);
Class<Short> dataType = requestItem.getDatatype();
- Assertions.assertThat(dataType).isEqualTo(Short.class);
- Assertions.assertThat(address).isSameAs(requestItem.getAddress());
+ assertThat(dataType, equalTo(Short.class));
+ assertThat(address, sameInstance(requestItem.getAddress()));
checkRead(connection, request, (short) 13);
checkRead(connection, request, (short) 23);
}
@@ -177,8 +187,8 @@ public void testNewPlcReadRequest() throws Exception {
TypeSafePlcReadRequest<Integer> request = PlcConnectionAdapter.newPlcReadRequest(Integer.class, address);
ReadRequestItem<Integer> requestItem = request.getCheckedReadRequestItems().get(0);
Class<Integer> dataType = requestItem.getDatatype();
- Assertions.assertThat(dataType).isEqualTo(Integer.class);
- Assertions.assertThat(address).isSameAs(requestItem.getAddress());
+ assertThat(dataType, equalTo(Integer.class));
+ assertThat(address, sameInstance(requestItem.getAddress()));
checkRead(connection, request, 33);
checkRead(connection, request, -133);
}
@@ -186,8 +196,8 @@ public void testNewPlcReadRequest() throws Exception {
TypeSafePlcReadRequest<Float> request = PlcConnectionAdapter.newPlcReadRequest(Float.class, address);
ReadRequestItem<Float> requestItem = request.getCheckedReadRequestItems().get(0);
Class<Float> dataType = requestItem.getDatatype();
- Assertions.assertThat(dataType).isEqualTo(Float.class);
- Assertions.assertThat(address).isSameAs(requestItem.getAddress());
+ assertThat(dataType, equalTo(Float.class));
+ assertThat(address, sameInstance(requestItem.getAddress()));
checkRead(connection, request, 43.5f);
checkRead(connection, request, -143.5f);
}
@@ -195,8 +205,8 @@ public void testNewPlcReadRequest() throws Exception {
TypeSafePlcReadRequest<String> request = PlcConnectionAdapter.newPlcReadRequest(String.class, address);
ReadRequestItem<String> requestItem = request.getCheckedReadRequestItems().get(0);
Class<String> dataType = requestItem.getDatatype();
- Assertions.assertThat(dataType).isEqualTo(String.class);
- Assertions.assertThat(address).isSameAs(requestItem.getAddress());
+ assertThat(dataType, equalTo(String.class));
+ assertThat(address, sameInstance(requestItem.getAddress()));
checkRead(connection, request, "ReadySetGo");
checkRead(connection, request, "OneMoreTime");
}
@@ -204,8 +214,8 @@ public void testNewPlcReadRequest() throws Exception {
TypeSafePlcReadRequest<Calendar> request = PlcConnectionAdapter.newPlcReadRequest(Calendar.class, address);
ReadRequestItem<Calendar> requestItem = request.getCheckedReadRequestItems().get(0);
Class<Calendar> dataType = requestItem.getDatatype();
- Assertions.assertThat(dataType).isEqualTo(Calendar.class);
- Assertions.assertThat(address).isSameAs(requestItem.getAddress());
+ assertThat(dataType, equalTo(Calendar.class));
+ assertThat(address, sameInstance(requestItem.getAddress()));
checkRead(connection, request, Calendar.getInstance());
}
adapter.close();
@@ -228,48 +238,48 @@ public void testNewPlcWriteRequest() throws Exception {
TypeSafePlcWriteRequest<Boolean> request = PlcConnectionAdapter.newPlcWriteRequest(address, true);
WriteRequestItem<Boolean> requestItem = request.getCheckedRequestItems().get(0);
Class<Boolean> dataType = requestItem.getDatatype();
- Assertions.assertThat(Boolean.class).isAssignableFrom(dataType);
- Assertions.assertThat(address).isSameAs(requestItem.getAddress());
+ assertThat(dataType, typeCompatibleWith(Boolean.class));
+ assertThat(address, sameInstance(requestItem.getAddress()));
checkWrite(connection, request, true);
}
{
TypeSafePlcWriteRequest<Byte> request = PlcConnectionAdapter.newPlcWriteRequest(address, (byte) 0x113);
WriteRequestItem<Byte> requestItem = request.getCheckedRequestItems().get(0);
Class<Byte> dataType = requestItem.getDatatype();
- Assertions.assertThat(Byte.class).isAssignableFrom(dataType);
- Assertions.assertThat(address).isSameAs(requestItem.getAddress());
+ assertThat(dataType, typeCompatibleWith(Byte.class));
+ assertThat(address, sameInstance(requestItem.getAddress()));
checkWrite(connection, request, (byte) 0x113);
}
{
TypeSafePlcWriteRequest<Short> request = PlcConnectionAdapter.newPlcWriteRequest(address, (short) 113);
WriteRequestItem<Short> requestItem = request.getCheckedRequestItems().get(0);
Class<Short> dataType = requestItem.getDatatype();
- Assertions.assertThat(Short.class).isAssignableFrom(dataType);
- Assertions.assertThat(address).isSameAs(requestItem.getAddress());
+ assertThat(dataType, typeCompatibleWith(Short.class));
+ assertThat(address, sameInstance(requestItem.getAddress()));
checkWrite(connection, request, (short) 113);
}
{
TypeSafePlcWriteRequest<Integer> request = PlcConnectionAdapter.newPlcWriteRequest(address, 1033);
WriteRequestItem<Integer> requestItem = request.getCheckedRequestItems().get(0);
Class<Integer> dataType = requestItem.getDatatype();
- Assertions.assertThat(Integer.class).isAssignableFrom(dataType);
- Assertions.assertThat(address).isSameAs(requestItem.getAddress());
+ assertThat(dataType, typeCompatibleWith(Integer.class));
+ assertThat(address, sameInstance(requestItem.getAddress()));
checkWrite(connection, request, 1033);
}
{
TypeSafePlcWriteRequest<Float> request = PlcConnectionAdapter.newPlcWriteRequest(address, 1043.5f);
WriteRequestItem<Float> requestItem = request.getCheckedRequestItems().get(0);
Class<Float> dataType = requestItem.getDatatype();
- Assertions.assertThat(Float.class).isAssignableFrom(dataType);
- Assertions.assertThat(address).isSameAs(requestItem.getAddress());
+ assertThat(dataType, typeCompatibleWith(Float.class));
+ assertThat(address, sameInstance(requestItem.getAddress()));
checkWrite(connection, request, 1043.5f);
}
{
TypeSafePlcWriteRequest<String> request = PlcConnectionAdapter.newPlcWriteRequest(address, "A written value");
WriteRequestItem<String> requestItem = request.getCheckedRequestItems().get(0);
Class<String> dataType = requestItem.getDatatype();
- Assertions.assertThat(String.class).isAssignableFrom(dataType);
- Assertions.assertThat(address).isSameAs(requestItem.getAddress());
+ assertThat(dataType, typeCompatibleWith(String.class));
+ assertThat(address, sameInstance(requestItem.getAddress()));
checkWrite(connection, request, "A written value");
}
{
@@ -277,8 +287,8 @@ public void testNewPlcWriteRequest() throws Exception {
TypeSafePlcWriteRequest<Calendar> request = PlcConnectionAdapter.newPlcWriteRequest(address, calValue);
WriteRequestItem<Calendar> requestItem = request.getCheckedRequestItems().get(0);
Class<Calendar> dataType = requestItem.getDatatype();
- Assertions.assertThat(Calendar.class).isAssignableFrom(dataType);
- Assertions.assertThat(address).isSameAs(requestItem.getAddress());
+ assertThat(dataType, typeCompatibleWith(Calendar.class));
+ assertThat(address, sameInstance(requestItem.getAddress()));
checkWrite(connection, request, calValue);
}
adapter.close();
@@ -298,7 +308,7 @@ public void testNewSupplier() throws Exception {
{
Supplier<Boolean> supplier = adapter.newSupplier(Boolean.class, addressStr);
- Assertions.assertThat(supplier).isNotSameAs(adapter.newSupplier(Boolean.class, addressStr));
+ assertThat(supplier, not(sameInstance(adapter.newSupplier(Boolean.class, addressStr))));
checkSupplier(connection, address, supplier, true, false);
}
{
@@ -356,12 +366,12 @@ public void testNewSupplierNeg() throws Exception {
T readData = supplier.get();
// System.out.println("checkSupplier"+(readFailureCountTrigger > 0 ? "NEG" : "")+": value:"+value+" readData:"+readData);
if (readFailureCountTrigger <= 0)
- Assertions.assertThat(value).isEqualTo(readData);
+ assertThat(value, equalTo(readData));
else {
if (++readCount != readFailureCountTrigger)
- Assertions.assertThat(value).isEqualTo(readData);
+ assertThat(value, equalTo(readData));
else
- Assertions.assertThat(readData).isNull();
+ assertThat(readData, nullValue());
}
}
}
@@ -381,7 +391,7 @@ public void testNewConsumer1() throws Exception {
Consumer<?> consumer;
consumer = adapter.newConsumer(Boolean.class, addressStr);
- Assertions.assertThat(consumer).isNotSameAs(adapter.newConsumer(Boolean.class, addressStr));
+ assertThat(consumer, not(sameInstance(adapter.newConsumer(Boolean.class, addressStr))));
checkConsumer(connection, address, consumer, true, false);
consumer = adapter.newConsumer(Byte.class, addressStr);
@@ -444,12 +454,12 @@ public void testNewConsumer1Neg() throws Exception {
}
// System.out.println("checkConsumer"+(writeFailureCountTrigger > 0 ? "NEG" : "")+": value:"+value+" writtenData:"+writtenData);
if (writeFailureCountTrigger <= 0)
- Assertions.assertThat(value).isEqualTo(writtenData);
+ assertThat(value, equalTo(writtenData));
else {
if (++writeCount != writeFailureCountTrigger)
- Assertions.assertThat(value).isEqualTo(writtenData);
+ assertThat(value, equalTo(writtenData));
else
- Assertions.assertThat(previousValue).isEqualTo(writtenData);
+ assertThat(previousValue, equalTo(writtenData));
}
previousValue = value;
}
@@ -545,12 +555,12 @@ else if (value instanceof String)
}
// System.out.println("checkConsumerJson"+(writeFailureCountTrigger > 0 ? "NEG" : "")+": value:"+value+" writtenData:"+writtenData);
if (writeFailureCountTrigger <= 0)
- Assertions.assertThat(value).isEqualTo(writtenData);
+ assertThat(value, equalTo(writtenData));
else {
if (++writeCount != writeFailureCountTrigger)
- Assertions.assertThat(value).isEqualTo(writtenData);
+ assertThat(value, equalTo(writtenData));
else
- Assertions.assertThat(previousValue).isEqualTo(writtenData);
+ assertThat(previousValue, equalTo(writtenData));
}
previousValue = value;
}
diff --git a/plc4j/api/src/test/java/org/apache/plc4x/java/api/authentication/PlcUsernamePasswordAuthenticationTest.java b/plc4j/api/src/test/java/org/apache/plc4x/java/api/authentication/PlcUsernamePasswordAuthenticationTest.java
index 1576b738..29cd00d9 100644
--- a/plc4j/api/src/test/java/org/apache/plc4x/java/api/authentication/PlcUsernamePasswordAuthenticationTest.java
+++ b/plc4j/api/src/test/java/org/apache/plc4x/java/api/authentication/PlcUsernamePasswordAuthenticationTest.java
@@ -18,12 +18,14 @@ Licensed to the Apache Software Foundation (ASF) under one
*/
package org.apache.plc4x.java.api.authentication;
-import static org.assertj.core.api.Assertions.assertThat;
import org.apache.plc4x.test.FastTests;
import org.junit.Test;
import org.junit.experimental.categories.Category;
+import static org.hamcrest.core.IsEqual.equalTo;
+import static org.junit.Assert.assertThat;
+
public class PlcUsernamePasswordAuthenticationTest {
@Test
@@ -31,8 +33,8 @@ Licensed to the Apache Software Foundation (ASF) under one
public void authenication() {
PlcUsernamePasswordAuthentication authenication = new PlcUsernamePasswordAuthentication("user", "password");
- assertThat(authenication.getUsername()).isEqualTo("user").withFailMessage("Unexpected user name");
- assertThat(authenication.getPassword()).isEqualTo("password").withFailMessage("Unexpected password");
+ assertThat("Unexpected user name", authenication.getUsername(), equalTo("user"));
+ assertThat("Unexpected password", authenication.getPassword(), equalTo("password"));
}
}
\ No newline at end of file
diff --git a/plc4j/api/src/test/java/org/apache/plc4x/java/api/messages/APIMessageTests.java b/plc4j/api/src/test/java/org/apache/plc4x/java/api/messages/APIMessageTests.java
index 00358279..e2811b1d 100644
--- a/plc4j/api/src/test/java/org/apache/plc4x/java/api/messages/APIMessageTests.java
+++ b/plc4j/api/src/test/java/org/apache/plc4x/java/api/messages/APIMessageTests.java
@@ -19,8 +19,6 @@ Licensed to the Apache Software Foundation (ASF) under one
package org.apache.plc4x.java.api.messages;
-import static org.assertj.core.api.Assertions.assertThat;
-
import org.apache.plc4x.java.api.messages.items.ReadRequestItem;
import org.apache.plc4x.java.api.messages.items.ReadResponseItem;
import org.apache.plc4x.java.api.messages.items.WriteRequestItem;
@@ -33,7 +31,16 @@ Licensed to the Apache Software Foundation (ASF) under one
import org.junit.Test;
import org.junit.experimental.categories.Category;
-import java.util.*;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Optional;
+
+import static org.hamcrest.collection.IsCollectionWithSize.hasSize;
+import static org.hamcrest.collection.IsEmptyCollection.empty;
+import static org.hamcrest.collection.IsIterableContainingInOrder.contains;
+import static org.hamcrest.core.IsEqual.equalTo;
+import static org.junit.Assert.assertThat;
public class APIMessageTests {
@@ -43,9 +50,9 @@ Licensed to the Apache Software Foundation (ASF) under one
public void readRequestItemSize() {
MockAddress address = new MockAddress("mock:/DATA");
ReadRequestItem<Byte> readRequestItem = new ReadRequestItem<>(Byte.class, address, 1);
- assertThat(readRequestItem.getAddress()).isEqualTo(address).withFailMessage("Unexpected address");
- assertThat(readRequestItem.getDatatype()).isEqualTo(Byte.class).withFailMessage("Unexpected data type");
- assertThat(readRequestItem.getSize()).isEqualTo(1).withFailMessage("Unexpected size");
+ assertThat("Unexpected address", readRequestItem.getAddress(), equalTo(address));
+ assertThat("Unexpected data type", readRequestItem.getDatatype(), equalTo(Byte.class));
+ assertThat("Unexpected size", readRequestItem.getSize(), equalTo(1));
}
@Test
@@ -53,9 +60,9 @@ public void readRequestItemSize() {
public void readRequestItem() {
MockAddress address = new MockAddress("mock:/DATA");
ReadRequestItem<Byte> readRequestItem = new ReadRequestItem<>(Byte.class, address);
- assertThat(readRequestItem.getAddress()).isEqualTo(address).withFailMessage("Unexpected address");
- assertThat(readRequestItem.getDatatype()).isEqualTo(Byte.class).withFailMessage("Unexpected data type");
- assertThat(readRequestItem.getSize()).isEqualTo(1).withFailMessage("Unexpected size");
+ assertThat("Unexpected address", readRequestItem.getAddress(), equalTo(address));
+ assertThat("Unexpected data type", readRequestItem.getDatatype(), equalTo(Byte.class));
+ assertThat("Unexpected size", readRequestItem.getSize(), equalTo(1));
}
@Test
@@ -64,9 +71,9 @@ public void readResponseItem() {
MockAddress address = new MockAddress("mock:/DATA");
ReadRequestItem<Byte> readRequestItem = new ReadRequestItem<>(Byte.class, address, 1);
ReadResponseItem<Byte> readResponseItem = new ReadResponseItem<>(readRequestItem, ResponseCode.OK, Collections.emptyList());
- assertThat(readResponseItem.getResponseCode()).isEqualTo(ResponseCode.OK).withFailMessage("Unexpected response code");
- assertThat(readResponseItem.getValues()).isEmpty();
- assertThat(readResponseItem.getRequestItem()).isEqualTo(readRequestItem).withFailMessage("Unexpected read request item");
+ assertThat("Unexpected response code", readResponseItem.getResponseCode(), equalTo(ResponseCode.OK));
+ assertThat(readResponseItem.getValues(), empty());
+ assertThat("Unexpected read request item", readResponseItem.getRequestItem(), equalTo(readRequestItem));
}
@Test
@@ -75,9 +82,9 @@ public void writeRequestItem() {
MockAddress address = new MockAddress("mock:/DATA");
WriteRequestItem<Byte> writeRequestItem = new WriteRequestItem<>(Byte.class, address, (byte) 0x45);
- assertThat(writeRequestItem.getAddress()).isEqualTo(address).withFailMessage("Unexpected address");
- assertThat(writeRequestItem.getDatatype()).isEqualTo(Byte.class).withFailMessage("Unexpected data type");
- assertThat(writeRequestItem.getValues().get(0)).isEqualTo((byte) 0x45).withFailMessage("Unexpected value");
+ assertThat("Unexpected address", writeRequestItem.getAddress(), equalTo(address));
+ assertThat("Unexpected data type", writeRequestItem.getDatatype(), equalTo(Byte.class));
+ assertThat("Unexpected value", writeRequestItem.getValues().get(0), equalTo((byte) 0x45));
}
@Test
@@ -86,10 +93,10 @@ public void writeRequestItems() {
MockAddress address = new MockAddress("mock:/DATA");
Byte data[] = {(byte) 0x23, (byte) 0x84};
WriteRequestItem<Byte> writeRequestItem = new WriteRequestItem<>(Byte.class, address, data);
- assertThat(writeRequestItem.getAddress()).isEqualTo(address).withFailMessage("Unexpected address");
- assertThat(writeRequestItem.getDatatype()).isEqualTo(Byte.class).withFailMessage("Unexpected data type");
- assertThat(writeRequestItem.getValues().get(0)).isEqualTo((byte) 0x23).withFailMessage("Unexpected value");
- assertThat(writeRequestItem.getValues().get(1)).isEqualTo((byte) 0x84).withFailMessage("Unexpected value");
+ assertThat("Unexpected address", writeRequestItem.getAddress(), equalTo(address));
+ assertThat("Unexpected data type", writeRequestItem.getDatatype(), equalTo(Byte.class));
+ assertThat("Unexpected value", writeRequestItem.getValues().get(0), equalTo((byte) 0x23));
+ assertThat("Unexpected value", writeRequestItem.getValues().get(1), equalTo((byte) 0x84));
}
@Test
@@ -98,16 +105,16 @@ public void writeResponseItem() {
MockAddress address = new MockAddress("mock:/DATA");
WriteRequestItem<Byte> writeRequestItem = new WriteRequestItem<>(Byte.class, address, (byte) 0x3B);
WriteResponseItem<Byte> writeResponseItem = new WriteResponseItem<>(writeRequestItem, ResponseCode.OK);
- assertThat(writeResponseItem.getResponseCode()).isEqualTo(ResponseCode.OK).withFailMessage("Unexpected response code");
- assertThat(writeResponseItem.getRequestItem()).isEqualTo(writeRequestItem).withFailMessage("Unexpected response item");
+ assertThat("Unexpected response code", writeResponseItem.getResponseCode(), equalTo(ResponseCode.OK));
+ assertThat("Unexpected response item", writeResponseItem.getRequestItem(), equalTo(writeRequestItem));
}
@Test
@Category(FastTests.class)
public void plcReadRequestEmpty() {
PlcReadRequest plcReadRequest = new PlcReadRequest();
- assertThat(plcReadRequest.getRequestItems()).isEmpty();
- assertThat(plcReadRequest.getNumberOfItems()).isEqualTo(0).withFailMessage("Expected request items to be zero");
+ assertThat(plcReadRequest.getRequestItems(), empty());
+ assertThat("Expected request items to be zero", plcReadRequest.getNumberOfItems(), equalTo(0));
}
@Test
@@ -115,8 +122,8 @@ public void plcReadRequestEmpty() {
public void plcReadRequestAddress() {
MockAddress address = new MockAddress("mock:/DATA");
PlcReadRequest plcReadRequest = new TypeSafePlcReadRequest<>(Byte.class, address);
- assertThat(plcReadRequest.getRequestItems()).hasSize(1).withFailMessage("Expected one request item");
- assertThat(plcReadRequest.getNumberOfItems()).isEqualTo(1).withFailMessage("Expected one request item");
+ assertThat("Expected one request item", plcReadRequest.getRequestItems(), hasSize(1));
+ assertThat("Expected one request item", plcReadRequest.getNumberOfItems(), equalTo(1));
}
@Test
@@ -124,21 +131,21 @@ public void plcReadRequestAddress() {
public void plcReadRequestSize() {
MockAddress address = new MockAddress("mock:/DATA");
PlcReadRequest plcReadRequest = PlcReadRequest.builder().addItem(Byte.class, address, (byte) 1).build(Byte.class);
- assertThat(plcReadRequest.getRequestItems()).hasSize(1).withFailMessage("Expected one request item");
- assertThat(plcReadRequest.getNumberOfItems()).isEqualTo(1).withFailMessage("Expected one request item");
+ assertThat("Expected one request item", plcReadRequest.getRequestItems(), hasSize(1));
+ assertThat("Expected one request item", plcReadRequest.getNumberOfItems(), equalTo(1));
}
@Test
@Category(FastTests.class)
public void plcReadRequestAddItem() {
PlcReadRequest plcReadRequest = new PlcReadRequest();
- assertThat(plcReadRequest.getRequestItems()).isEmpty();
- assertThat(plcReadRequest.getNumberOfItems()).isEqualTo(0).withFailMessage("Expected request items to be zero");
+ assertThat(plcReadRequest.getRequestItems(), empty());
+ assertThat("Expected request items to be zero", plcReadRequest.getNumberOfItems(), equalTo(0));
MockAddress address = new MockAddress("mock:/DATA");
ReadRequestItem<Byte> readRequestItem = new ReadRequestItem<>(Byte.class, address, (byte) 1);
plcReadRequest.addItem(readRequestItem);
- assertThat(plcReadRequest.getRequestItems()).hasSize(1).withFailMessage("Expected one request item");
- assertThat(plcReadRequest.getNumberOfItems()).isEqualTo(1).withFailMessage("Expected one request item");
+ assertThat("Expected one request item", plcReadRequest.getRequestItems(), hasSize(1));
+ assertThat("Expected one request item", plcReadRequest.getNumberOfItems(), equalTo(1));
}
@Test
@@ -151,18 +158,18 @@ public void plcReadResponse() {
ReadResponseItem<Byte> readResponseItem = new ReadResponseItem<>(readRequestItem, ResponseCode.OK, Collections.emptyList());
responseItems.add(readResponseItem);
PlcReadResponse plcReadResponse = new PlcReadResponse(plcReadRequest, responseItems);
- assertThat(plcReadResponse.getRequest().getNumberOfItems()).isEqualTo(0).withFailMessage("Unexpected number of response items");
- assertThat(plcReadResponse.getRequest()).isEqualTo(plcReadRequest).withFailMessage("Unexpected read request");
- assertThat(plcReadResponse.getResponseItems()).hasSize(1).withFailMessage("Unexpected number of response items");
- assertThat(plcReadResponse.getResponseItems()).containsAll(responseItems).withFailMessage("Unexpected items in response items");
+ assertThat("Unexpected number of response items", plcReadResponse.getRequest().getNumberOfItems(), equalTo(0));
+ assertThat("Unexpected read request", plcReadResponse.getRequest(), equalTo(plcReadRequest));
+ assertThat("Unexpected number of response items", plcReadResponse.getResponseItems(), hasSize(1));
+ assertThat("Unexpected items in response items", plcReadResponse.getResponseItems(), contains(readResponseItem));
}
@Test
@Category(FastTests.class)
public void plcWriteRequestEmpty() {
PlcWriteRequest plcWriteRequest = new PlcWriteRequest();
- assertThat(plcWriteRequest.getRequestItems()).isEmpty();
- assertThat(plcWriteRequest.getNumberOfItems()).isEqualTo(0).withFailMessage("Expected request items to be zero");
+ assertThat(plcWriteRequest.getRequestItems(), empty());
+ assertThat("Expected request items to be zero", plcWriteRequest.getNumberOfItems(), equalTo(0));
}
@Test
@@ -170,10 +177,10 @@ public void plcWriteRequestEmpty() {
public void plcWriteRequestObject() {
MockAddress address = new MockAddress("mock:/DATA");
PlcWriteRequest plcWriteRequest = new TypeSafePlcWriteRequest<>(Byte.class, address, (byte) 0x33);
- assertThat(plcWriteRequest.getRequestItems()).hasSize(1).withFailMessage("Expected no request item");
- assertThat(plcWriteRequest.getNumberOfItems()).isEqualTo(1).withFailMessage("Expected one request item");
+ assertThat("Expected one request item", plcWriteRequest.getRequestItems(), hasSize(1));
+ assertThat("Expected one request item", plcWriteRequest.getNumberOfItems(), equalTo(1));
List values = plcWriteRequest.getRequestItems().get(0).getValues();
- assertThat((byte) values.get(0)).isEqualTo((byte) 0x33).withFailMessage("Expected value 0x33");
+ assertThat((byte) values.get(0), equalTo((byte) 0x33));
}
@Test
@@ -182,11 +189,11 @@ public void plcWriteRequestObjects() {
MockAddress address = new MockAddress("mock:/DATA");
Byte[] data = {(byte) 0x22, (byte) 0x66};
PlcWriteRequest plcWriteRequest = new TypeSafePlcWriteRequest<>(Byte.class, address, data);
- assertThat(plcWriteRequest.getRequestItems()).hasSize(1).withFailMessage("Expected one request item");
- assertThat(plcWriteRequest.getNumberOfItems()).isEqualTo(1).withFailMessage("Expected one request item");
+ assertThat("Expected one request item", plcWriteRequest.getRequestItems(), hasSize(1));
+ assertThat("Expected one request item", plcWriteRequest.getNumberOfItems(), equalTo(1));
List values = plcWriteRequest.getRequestItems().get(0).getValues();
- assertThat((Byte) values.get(0)).isEqualTo((byte) 0x22).withFailMessage("Expected value 0x22");
- assertThat((Byte) values.get(1)).isEqualTo((byte) 0x66).withFailMessage("Expected value 0x66");
+ assertThat(values.get(0), equalTo((byte) 0x22));
+ assertThat(values.get(1), equalTo((byte) 0x66));
}
@Test
@@ -199,10 +206,10 @@ public void plcWriteResponse() {
WriteResponseItem<Byte> writeResponseItem = new WriteResponseItem<>(writeRequestItem, ResponseCode.OK);
responseItems.add(writeResponseItem);
PlcWriteResponse plcReadResponse = new PlcWriteResponse(plcWriteRequest, responseItems);
- assertThat(plcReadResponse.getRequest().getNumberOfItems()).isEqualTo(0).withFailMessage("Unexpected number of response items");
- assertThat(plcReadResponse.getRequest()).isEqualTo(plcWriteRequest).withFailMessage("Unexpected read request");
- assertThat(plcReadResponse.getResponseItems()).hasSize(1).withFailMessage("Unexpected number of response items");
- assertThat(plcReadResponse.getResponseItems()).containsAll(responseItems).withFailMessage("Unexpected items in response items");
+ assertThat("Unexpected number of response items", plcReadResponse.getRequest().getNumberOfItems(), equalTo(0));
+ assertThat("Unexpected read request", plcReadResponse.getRequest(), equalTo(plcWriteRequest));
+ assertThat("Unexpected number of response items", plcReadResponse.getResponseItems(), hasSize(1));
+ assertThat("Unexpected items in response items", plcReadResponse.getResponseItems(), contains(writeResponseItem));
}
@Test
@@ -220,8 +227,8 @@ public void bulkPlcWriteResponseGetValue() {
PlcWriteResponse plcWriteResponse = new PlcWriteResponse(plcWriteRequest, responseItems);
Optional<WriteResponseItem<Byte>> responseValue1 = plcWriteResponse.getValue(writeRequestItem1);
Optional<WriteResponseItem<Byte>> responseValue2 = plcWriteResponse.getValue(writeRequestItem2);
- assertThat(responseValue1).isEqualTo(Optional.of(writeResponseItem1)).withFailMessage("Unexpected items in response items");
- assertThat(responseValue2).isEqualTo(Optional.of(writeResponseItem2)).withFailMessage("Unexpected items in response items");
+ assertThat("Unexpected items in response items", responseValue1, equalTo(Optional.of(writeResponseItem1)));
+ assertThat("Unexpected items in response items", responseValue2, equalTo(Optional.of(writeResponseItem2)));
}
@Test
@@ -233,7 +240,7 @@ public void nonExistingItemPlcWriteResponseGetValue() {
WriteRequestItem<Byte> nonExistingWriteRequestItem = new WriteRequestItem<>(Byte.class, address, (byte) 1);
PlcWriteResponse plcWriteResponse = new PlcWriteResponse(plcWriteRequest, responseItems);
Optional<WriteResponseItem<Byte>> responseValue1 = plcWriteResponse.getValue(nonExistingWriteRequestItem);
- assertThat(responseValue1).isEqualTo(Optional.empty()).withFailMessage("Unexpected items in response items");
+ assertThat("Unexpected items in response items", responseValue1, equalTo(Optional.empty()));
}
@Test
@@ -251,8 +258,8 @@ public void bulkPlcReadResponseGetValue() {
PlcReadResponse plcReadResponse = new PlcReadResponse(plcReadRequest, responseItems);
Optional<ReadResponseItem<Byte>> responseValue1 = plcReadResponse.getValue(readRequestItem1);
Optional<ReadResponseItem<Byte>> responseValue2 = plcReadResponse.getValue(readRequestItem2);
- assertThat(responseValue1).isEqualTo(Optional.of(readResponseItem1)).withFailMessage("Unexpected items in response items");
- assertThat(responseValue2).isEqualTo(Optional.of(readResponseItem2)).withFailMessage("Unexpected items in response items");
+ assertThat("Unexpected items in response items", responseValue1, equalTo(Optional.of(readResponseItem1)));
+ assertThat("Unexpected items in response items", responseValue2, equalTo(Optional.of(readResponseItem2)));
}
@Test
@@ -264,7 +271,7 @@ public void nonExistingItemPlcReadResponseGetValue() {
ReadRequestItem<Byte> nonExistingReadRequestItem = new ReadRequestItem<>(Byte.class, address, 1);
PlcReadResponse plcReadResponse = new PlcReadResponse(plcReadRequest, responseItems);
Optional<ReadResponseItem<Byte>> responseValue1 = plcReadResponse.getValue(nonExistingReadRequestItem);
- assertThat(responseValue1).isEqualTo(Optional.empty()).withFailMessage("Unexpected items in response items");
+ assertThat("Unexpected items in response items", responseValue1, equalTo(Optional.empty()));
}
}
diff --git a/plc4j/api/src/test/java/org/apache/plc4x/java/api/messages/PlcReadRequestTest.java b/plc4j/api/src/test/java/org/apache/plc4x/java/api/messages/PlcReadRequestTest.java
index 228df377..4ce45b91 100644
--- a/plc4j/api/src/test/java/org/apache/plc4x/java/api/messages/PlcReadRequestTest.java
+++ b/plc4j/api/src/test/java/org/apache/plc4x/java/api/messages/PlcReadRequestTest.java
@@ -25,7 +25,7 @@ Licensed to the Apache Software Foundation (ASF) under one
import java.util.Collections;
-import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.junit.Assert.fail;
import static org.mockito.Mockito.mock;
public class PlcReadRequestTest {
@@ -49,9 +49,12 @@ public void constuctor() {
@Test
public void builder() {
{ // empty
- assertThatThrownBy(() ->
- PlcReadRequest.builder().build())
- .isInstanceOf(IllegalStateException.class);
+ try {
+ PlcReadRequest.builder().build();
+ fail("An empty builder should not be allowed to build a request");
+ } catch (IllegalStateException e) {
+ // expected
+ }
}
{ // one item
PlcReadRequest.builder()
@@ -75,20 +78,26 @@ public void builder() {
.build();
}
{ // two different item typeSafe
- assertThatThrownBy(() ->
+ try {
PlcReadRequest.builder()
.addItem(String.class, dummyAddress)
.addItem(Byte.class, dummyAddress)
- .build(String.class))
- .isInstanceOf(IllegalStateException.class);
+ .build(String.class);
+ fail("Should not succeed in building with mixed types.");
+ } catch (IllegalStateException e) {
+ // expected
+ }
}
{ // two different item typeSafe
- assertThatThrownBy(() ->
+ try {
PlcReadRequest.builder()
.addItem(String.class, dummyAddress)
.addItem(Byte.class, dummyAddress)
- .build(Byte.class))
- .isInstanceOf(ClassCastException.class);
+ .build(Byte.class);
+ fail("Should not succeed in building with mismatch of types.");
+ } catch (ClassCastException e) {
+ // expected
+ }
}
{ // two equal item typeSafe
PlcReadRequest.builder()
diff --git a/plc4j/api/src/test/java/org/apache/plc4x/java/api/messages/PlcRequestTest.java b/plc4j/api/src/test/java/org/apache/plc4x/java/api/messages/PlcRequestTest.java
index 59789e98..84d760f1 100644
--- a/plc4j/api/src/test/java/org/apache/plc4x/java/api/messages/PlcRequestTest.java
+++ b/plc4j/api/src/test/java/org/apache/plc4x/java/api/messages/PlcRequestTest.java
@@ -18,8 +18,6 @@ Licensed to the Apache Software Foundation (ASF) under one
*/
package org.apache.plc4x.java.api.messages;
-import static org.assertj.core.api.Assertions.assertThat;
-
import org.apache.plc4x.java.api.messages.items.RequestItem;
import org.junit.Before;
import org.junit.Test;
@@ -28,14 +26,18 @@ Licensed to the Apache Software Foundation (ASF) under one
import java.util.List;
import java.util.Optional;
-import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.hamcrest.collection.IsEmptyCollection.empty;
+import static org.hamcrest.core.Is.is;
+import static org.hamcrest.core.IsEqual.equalTo;
+import static org.junit.Assert.assertThat;
+import static org.junit.Assert.fail;
import static org.mockito.Mockito.mock;
public class PlcRequestTest {
private List<RequestItem> requestItems;
- private PlcRequest SUT;
+ private PlcRequest<RequestItem> SUT;
@Before
public void setUp() {
@@ -51,38 +53,47 @@ public void addItem() {
@Test
public void getRequestItems() {
- assertThat(SUT.getRequestItems()).isEmpty();
+ assertThat(SUT.getRequestItems(), empty());
}
@Test
public void getRequestItem() {
- assertThat(SUT.getRequestItem()).isEqualTo(Optional.empty());
+ assertThat(SUT.getRequestItem(), equalTo(Optional.empty()));
requestItems.add(mock(RequestItem.class));
- assertThat(SUT.getRequestItem().isPresent()).isTrue();
+ assertThat(SUT.getRequestItem().isPresent(), is(true));
requestItems.add(mock(RequestItem.class));
- assertThatThrownBy(() -> SUT.getRequestItem()).isInstanceOf(IllegalStateException.class);
+ try {
+ SUT.getRequestItem();
+ fail("Too many items in PlcRequest should have failed.");
+ } catch (IllegalStateException e) {
+ // expected
+ }
}
@Test
public void setRequestItem() {
SUT.setRequestItem(mock(RequestItem.class));
requestItems.add(mock(RequestItem.class));
- assertThatThrownBy(() -> SUT.setRequestItem(mock(RequestItem.class))).isInstanceOf(IllegalStateException.class);
+ try {
+ SUT.setRequestItem(mock(RequestItem.class));
+ } catch (IllegalStateException e) {
+ // expected
+ }
}
@Test
public void getNumberOfItems() {
- assertThat(SUT.getNumberOfItems()).isEqualTo(0);
+ assertThat(SUT.getNumberOfItems(), equalTo(0));
}
@Test
public void isMultiValue() {
- assertThat(SUT.isMultiValue()).isFalse();
+ assertThat(SUT.isMultiValue(), is(false));
}
@Test
public void isEmpty() {
- assertThat(SUT.isEmpty()).isTrue();
+ assertThat(SUT.isEmpty(), is(true));
}
}
\ No newline at end of file
diff --git a/plc4j/api/src/test/java/org/apache/plc4x/java/api/messages/PlcResponseTest.java b/plc4j/api/src/test/java/org/apache/plc4x/java/api/messages/PlcResponseTest.java
index fe563c59..22bab30b 100644
--- a/plc4j/api/src/test/java/org/apache/plc4x/java/api/messages/PlcResponseTest.java
+++ b/plc4j/api/src/test/java/org/apache/plc4x/java/api/messages/PlcResponseTest.java
@@ -18,8 +18,6 @@ Licensed to the Apache Software Foundation (ASF) under one
*/
package org.apache.plc4x.java.api.messages;
-import static org.assertj.core.api.Assertions.assertThat;
-
import org.apache.plc4x.java.api.messages.items.RequestItem;
import org.apache.plc4x.java.api.messages.items.ResponseItem;
import org.junit.Before;
@@ -29,14 +27,20 @@ Licensed to the Apache Software Foundation (ASF) under one
import java.util.List;
import java.util.Optional;
-import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.hamcrest.collection.IsEmptyCollection.empty;
+import static org.hamcrest.core.Is.is;
+import static org.hamcrest.core.IsEqual.equalTo;
+import static org.hamcrest.core.IsNull.notNullValue;
+import static org.junit.Assert.assertThat;
+import static org.junit.Assert.fail;
+import static org.mockito.ArgumentMatchers.isNotNull;
import static org.mockito.Mockito.mock;
public class PlcResponseTest {
private List<ResponseItem> responseItems;
- private PlcResponse SUT;
+ private PlcResponse<PlcRequest, ResponseItem, RequestItem> SUT;
@Before
public void setUp() {
@@ -47,43 +51,45 @@ public void setUp() {
@Test
public void getRequest() {
- assertThat(SUT.getRequest()).isNotNull();
+ assertThat(SUT.getRequest(), notNullValue());
}
@Test
public void getResponseItems() {
- assertThat(SUT.getResponseItems()).isEmpty();
+ assertThat(SUT.getResponseItems(), empty());
}
@Test
public void getResponseItem() {
- assertThat(SUT.getResponseItem()).isEqualTo(Optional.empty());
+ assertThat(SUT.getResponseItem(), equalTo(Optional.empty()));
responseItems.add(mock(ResponseItem.class));
- assertThat(SUT.getResponseItem().isPresent()).isTrue();
+ assertThat(SUT.getResponseItem().isPresent(), is(true));
responseItems.add(mock(ResponseItem.class));
- assertThatThrownBy(() ->
- SUT.getResponseItem()).
- isInstanceOf(IllegalStateException.class);
+ try {
+ SUT.getResponseItem();
+ fail("PlcResponse.getResponseItem() should fail if contains multiple items.");
+ } catch (IllegalStateException e) {
+ // expected
+ }
}
@Test
public void getNumberOfItems() {
- assertThat(SUT.getNumberOfItems()).isEqualTo(0);
+ assertThat(SUT.getNumberOfItems(), equalTo(0));
}
@Test
public void isMultiValue() {
- assertThat(SUT.isMultiValue()).isFalse();
+ assertThat(SUT.isMultiValue(), is(false));
}
@Test
public void isEmpty() {
- assertThat(SUT.isEmpty()).isTrue();
+ assertThat(SUT.isEmpty(), is(true));
}
@Test
public void getValue() {
- assertThat(SUT.getValue(null)).isEqualTo(Optional.empty());
+ assertThat(SUT.getValue(null), equalTo(Optional.empty()));
}
-
}
\ No newline at end of file
diff --git a/plc4j/api/src/test/java/org/apache/plc4x/java/api/messages/PlcWriteRequestTest.java b/plc4j/api/src/test/java/org/apache/plc4x/java/api/messages/PlcWriteRequestTest.java
index c8989740..4680858a 100644
--- a/plc4j/api/src/test/java/org/apache/plc4x/java/api/messages/PlcWriteRequestTest.java
+++ b/plc4j/api/src/test/java/org/apache/plc4x/java/api/messages/PlcWriteRequestTest.java
@@ -25,7 +25,7 @@ Licensed to the Apache Software Foundation (ASF) under one
import java.util.Collections;
-import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.junit.Assert.fail;
import static org.mockito.Mockito.mock;
public class PlcWriteRequestTest {
@@ -38,7 +38,7 @@ public void setUp() {
}
@Test
- public void constuctor() {
+ public void constructor() {
new PlcWriteRequest();
new PlcWriteRequest(new WriteRequestItem<>(String.class, dummyAddress, ""));
new PlcWriteRequest(String.class, dummyAddress);
@@ -48,9 +48,12 @@ public void constuctor() {
@Test
public void builder() {
{ // empty
- assertThatThrownBy(() ->
- PlcWriteRequest.builder().build())
- .isInstanceOf(IllegalStateException.class);
+ try {
+ PlcWriteRequest.builder().build();
+ fail("An empty build should fail.");
+ } catch (IllegalStateException e) {
+ // expected
+ }
}
{ // one item implicit type
PlcWriteRequest.builder()
@@ -74,20 +77,26 @@ public void builder() {
.build();
}
{ // two different item typeSafe
- assertThatThrownBy(() ->
+ try {
PlcWriteRequest.builder()
.addItem(String.class, dummyAddress)
.addItem(Byte.class, dummyAddress)
- .build(String.class))
- .isInstanceOf(IllegalStateException.class);
+ .build(String.class);
+ fail("Mixed types build should fail.");
+ } catch (IllegalStateException e) {
+ // expected
+ }
}
{ // two different item typeSafe
- assertThatThrownBy(() ->
+ try {
PlcWriteRequest.builder()
.addItem(String.class, dummyAddress)
.addItem(Byte.class, dummyAddress)
- .build(Byte.class))
- .isInstanceOf(ClassCastException.class);
+ .build(Byte.class);
+ fail("Mismatch of types should have failed.");
+ } catch (ClassCastException e) {
+ // expected
+ }
}
{ // two equal item typeSafe
PlcWriteRequest.builder()
diff --git a/plc4j/api/src/test/java/org/apache/plc4x/java/api/messages/specific/TypeSafePlcReadRequestTest.java b/plc4j/api/src/test/java/org/apache/plc4x/java/api/messages/specific/TypeSafePlcReadRequestTest.java
index 9b39e7c3..03cf66b6 100644
--- a/plc4j/api/src/test/java/org/apache/plc4x/java/api/messages/specific/TypeSafePlcReadRequestTest.java
+++ b/plc4j/api/src/test/java/org/apache/plc4x/java/api/messages/specific/TypeSafePlcReadRequestTest.java
@@ -18,8 +18,6 @@ Licensed to the Apache Software Foundation (ASF) under one
*/
package org.apache.plc4x.java.api.messages.specific;
-import static org.assertj.core.api.Assertions.assertThat;
-
import org.apache.plc4x.java.api.messages.PlcReadRequest;
import org.apache.plc4x.java.api.messages.items.ReadRequestItem;
import org.apache.plc4x.java.api.model.Address;
@@ -28,7 +26,8 @@ Licensed to the Apache Software Foundation (ASF) under one
import java.util.Collections;
-import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.hamcrest.core.IsEqual.equalTo;
+import static org.junit.Assert.assertThat;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
@@ -41,7 +40,7 @@ public void setUp() {
readRequestItemString = new ReadRequestItem<>(String.class, mock(Address.class));
}
- @Test
+ @Test(expected = IllegalArgumentException.class)
public void constuctor() {
new TypeSafePlcReadRequest<>(String.class);
new TypeSafePlcReadRequest<>(String.class, mock(PlcReadRequest.class));
@@ -51,9 +50,9 @@ public void constuctor() {
new TypeSafePlcReadRequest<>(String.class, mock(Address.class));
new TypeSafePlcReadRequest<>(String.class, mock(Address.class), 3);
new TypeSafePlcReadRequest<>(String.class, readRequestItemString);
- assertThatThrownBy(() ->
- new TypeSafePlcReadRequest<>(Byte.class, request))
- .isInstanceOf(IllegalArgumentException.class);
+
+ // expected to fail
+ new TypeSafePlcReadRequest<>(Byte.class, request);
}
@Test
@@ -73,7 +72,7 @@ public void getRequestItem() {
@Test
public void getDataType() {
- assertThat(new TypeSafePlcReadRequest<>(String.class).getDataType()).isEqualTo(String.class);
+ assertThat(new TypeSafePlcReadRequest<>(String.class).getDataType(), equalTo(String.class));
}
}
\ No newline at end of file
diff --git a/plc4j/api/src/test/java/org/apache/plc4x/java/api/messages/specific/TypeSafePlcReadResponseTest.java b/plc4j/api/src/test/java/org/apache/plc4x/java/api/messages/specific/TypeSafePlcReadResponseTest.java
index c72a59d9..ce43b9b8 100644
--- a/plc4j/api/src/test/java/org/apache/plc4x/java/api/messages/specific/TypeSafePlcReadResponseTest.java
+++ b/plc4j/api/src/test/java/org/apache/plc4x/java/api/messages/specific/TypeSafePlcReadResponseTest.java
@@ -29,7 +29,6 @@ Licensed to the Apache Software Foundation (ASF) under one
import java.util.Collections;
import java.util.List;
-import static org.assertj.core.api.Assertions.assertThatThrownBy;
import static org.mockito.Mockito.*;
public class TypeSafePlcReadResponseTest {
@@ -41,16 +40,16 @@ public void setUp() {
readResponseItemString = new ReadResponseItem<>(mock(ReadRequestItem.class), ResponseCode.OK, Arrays.asList("", ""));
}
- @Test
+ @Test(expected = IllegalArgumentException.class)
public void constuctor() {
TypeSafePlcReadRequest mock = mock(TypeSafePlcReadRequest.class);
when(mock.getDataType()).thenReturn(String.class);
new TypeSafePlcReadResponse<>(mock, readResponseItemString);
new TypeSafePlcReadResponse<>(mock, Collections.singletonList(readResponseItemString));
- assertThatThrownBy(() -> {
- when(mock.getDataType()).thenReturn(Byte.class);
- new TypeSafePlcReadResponse<>(mock, readResponseItemString);
- }).isInstanceOf(IllegalArgumentException.class);
+ when(mock.getDataType()).thenReturn(Byte.class);
+
+ // expects an exception
+ new TypeSafePlcReadResponse<>(mock, readResponseItemString);
}
@Test
diff --git a/plc4j/api/src/test/java/org/apache/plc4x/java/api/messages/specific/TypeSafePlcWriteRequestTest.java b/plc4j/api/src/test/java/org/apache/plc4x/java/api/messages/specific/TypeSafePlcWriteRequestTest.java
index 759102fa..8d85b516 100644
--- a/plc4j/api/src/test/java/org/apache/plc4x/java/api/messages/specific/TypeSafePlcWriteRequestTest.java
+++ b/plc4j/api/src/test/java/org/apache/plc4x/java/api/messages/specific/TypeSafePlcWriteRequestTest.java
@@ -18,8 +18,6 @@ Licensed to the Apache Software Foundation (ASF) under one
*/
package org.apache.plc4x.java.api.messages.specific;
-import static org.assertj.core.api.Assertions.assertThat;
-
import org.apache.plc4x.java.api.messages.PlcWriteRequest;
import org.apache.plc4x.java.api.messages.items.WriteRequestItem;
import org.apache.plc4x.java.api.model.Address;
@@ -28,7 +26,8 @@ Licensed to the Apache Software Foundation (ASF) under one
import java.util.Collections;
-import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.hamcrest.core.IsEqual.equalTo;
+import static org.junit.Assert.assertThat;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
@@ -41,7 +40,7 @@ public void setUp() {
writeRequestItemString = new WriteRequestItem<>(String.class, mock(Address.class));
}
- @Test
+ @Test(expected = IllegalArgumentException.class)
public void constuctor() {
new TypeSafePlcWriteRequest<>(String.class);
new TypeSafePlcWriteRequest<>(String.class, mock(PlcWriteRequest.class));
@@ -51,7 +50,9 @@ public void constuctor() {
new TypeSafePlcWriteRequest<>(String.class, mock(Address.class));
new TypeSafePlcWriteRequest<>(String.class, mock(Address.class), "");
new TypeSafePlcWriteRequest<>(String.class, writeRequestItemString);
- assertThatThrownBy(() -> new TypeSafePlcWriteRequest<>(Byte.class, request)).isInstanceOf(IllegalArgumentException.class);
+
+ // expects an exception
+ new TypeSafePlcWriteRequest<>(Byte.class, request);
}
@Test
@@ -71,7 +72,7 @@ public void getRequestItem() {
@Test
public void getDataType() {
- assertThat(new TypeSafePlcWriteRequest<>(String.class).getDataType()).isEqualTo(String.class);
+ assertThat(new TypeSafePlcWriteRequest<>(String.class).getDataType(), equalTo(String.class));
}
}
\ No newline at end of file
diff --git a/plc4j/core/src/test/java/org/apache/plc4x/java/PlcDriverManagerTest.java b/plc4j/core/src/test/java/org/apache/plc4x/java/PlcDriverManagerTest.java
index b2764c43..7897b76f 100644
--- a/plc4j/core/src/test/java/org/apache/plc4x/java/PlcDriverManagerTest.java
+++ b/plc4j/core/src/test/java/org/apache/plc4x/java/PlcDriverManagerTest.java
@@ -23,7 +23,6 @@ Licensed to the Apache Software Foundation (ASF) under one
import org.apache.plc4x.java.api.exceptions.PlcException;
import org.apache.plc4x.java.mock.MockConnection;
import org.apache.plc4x.test.FastTests;
-import org.assertj.core.api.SoftAssertions;
import org.junit.Test;
import org.junit.experimental.categories.Category;
@@ -32,7 +31,11 @@ Licensed to the Apache Software Foundation (ASF) under one
import java.net.URL;
import java.net.URLClassLoader;
-import static org.assertj.core.api.Assertions.*;
+import static org.hamcrest.core.Is.is;
+import static org.hamcrest.core.IsInstanceOf.instanceOf;
+import static org.hamcrest.core.IsNull.notNullValue;
+import static org.hamcrest.core.IsNull.nullValue;
+import static org.junit.Assert.assertThat;
public class PlcDriverManagerTest {
@@ -43,17 +46,9 @@ Licensed to the Apache Software Foundation (ASF) under one
@Category(FastTests.class)
public void getExistingDriverTest() throws PlcException {
MockConnection mockConnection = (MockConnection) new PlcDriverManager().getConnection("mock://some-cool-url");
- SoftAssertions softAssertions = new SoftAssertions();
- softAssertions.assertThat(mockConnection.getAuthentication())
- .as("check authentication object")
- .isNull();
- softAssertions.assertThat(mockConnection.isConnected())
- .as("check connection state")
- .isTrue();
- softAssertions.assertThat(mockConnection.isClosed())
- .as("check closed state")
- .isFalse();
- softAssertions.assertAll();
+ assertThat(mockConnection.getAuthentication(), nullValue());
+ assertThat(mockConnection.isConnected(), is(true));
+ assertThat(mockConnection.isClosed(), is(false));
}
/**
@@ -66,42 +61,28 @@ public void getExistingDriverWithAuthenticationTest() throws PlcException {
new PlcUsernamePasswordAuthentication("user", "pass");
MockConnection mockConnection = (MockConnection) new PlcDriverManager().getConnection("mock://some-cool-url", authentication);
- SoftAssertions softAssertions = new SoftAssertions();
- softAssertions.assertThat(mockConnection.getAuthentication())
- .as("check authentication object")
- .isNotNull();
- softAssertions.assertThat(mockConnection.getAuthentication())
- .as("check authentication object type")
- .isInstanceOf(PlcUsernamePasswordAuthentication.class);
- softAssertions.assertThat(mockConnection.isConnected())
- .as("check connection state")
- .isTrue();
- softAssertions.assertThat(mockConnection.isClosed())
- .as("check closed state")
- .isFalse();
- softAssertions.assertAll();
+ assertThat(mockConnection.getAuthentication(), notNullValue());
+ assertThat(mockConnection.getAuthentication(), instanceOf(PlcUsernamePasswordAuthentication.class));
+ assertThat(mockConnection.isConnected(), is(true));
+ assertThat(mockConnection.isClosed(), is(false));
}
/**
* In this test case a driver is requested which is not registered with the {@link PlcDriverManager}.
*/
- @Test
+ @Test(expected = PlcConnectionException.class)
@Category(FastTests.class)
- public void getNotExistingDriverTest() {
- assertThatThrownBy(() -> new PlcDriverManager().getConnection("non-existing-protocol://some-cool-url"))
- .as("check rejection of invalid protocol")
- .isInstanceOf(PlcConnectionException.class);
+ public void getNotExistingDriverTest() throws PlcConnectionException {
+ new PlcDriverManager().getConnection("non-existing-protocol://some-cool-url");
}
/**
* In this test case a driver is requested which is not registered with the {@link PlcDriverManager}.
*/
- @Test
+ @Test(expected = PlcConnectionException.class)
@Category(FastTests.class)
- public void getInvalidUriTest() {
- assertThatThrownBy(() -> new PlcDriverManager().getConnection("The quick brown fox jumps over the lazy dog"))
- .as("check rejection of invalid uri")
- .isInstanceOf(PlcConnectionException.class);
+ public void getInvalidUriTest() throws PlcConnectionException {
+ new PlcDriverManager().getConnection("The quick brown fox jumps over the lazy dog");
}
/**
@@ -109,9 +90,9 @@ public void getInvalidUriTest() {
* contains multiple implementation instances of the same protocol. This should result in
* an error.
*/
- @Test
+ @Test(expected = IllegalStateException.class)
@Category(FastTests.class)
- public void getDuplicateDriver() throws MalformedURLException {
+ public void getDuplicateDriver() throws MalformedURLException, PlcConnectionException {
// Save and replace the context classloader as we need to force the ServiceLoader to
// use a different service file.
ClassLoader originalClassloader = Thread.currentThread().getContextClassLoader();
@@ -119,9 +100,8 @@ public void getDuplicateDriver() throws MalformedURLException {
urls[0] = new File("src/test/resources/test").toURI().toURL();
ClassLoader fakeClassLoader = new URLClassLoader(urls, originalClassloader);
- assertThatThrownBy(() -> new PlcDriverManager(fakeClassLoader).getConnection("mock://some-cool-url"))
- .as("check detection of duplicated driver detection")
- .isInstanceOf(IllegalStateException.class);
+ // expect exception
+ new PlcDriverManager(fakeClassLoader).getConnection("mock://some-cool-url");
}
}
diff --git a/plc4j/protocols/s7/src/test/java/org/apache/plc4x/java/isoontcp/netty/IsoOnTcpProtocolTest.java b/plc4j/protocols/s7/src/test/java/org/apache/plc4x/java/isoontcp/netty/IsoOnTcpProtocolTest.java
index dfeae727..3d7380d8 100644
--- a/plc4j/protocols/s7/src/test/java/org/apache/plc4x/java/isoontcp/netty/IsoOnTcpProtocolTest.java
+++ b/plc4j/protocols/s7/src/test/java/org/apache/plc4x/java/isoontcp/netty/IsoOnTcpProtocolTest.java
@@ -18,9 +18,6 @@ Licensed to the Apache Software Foundation (ASF) under one
*/
package org.apache.plc4x.java.isoontcp.netty;
-import static org.assertj.core.api.Assertions.*;
-import static org.mockito.Mockito.*;
-
import ch.qos.logback.classic.Level;
import ch.qos.logback.classic.Logger;
import ch.qos.logback.classic.spi.LoggingEvent;
@@ -32,10 +29,19 @@ Licensed to the Apache Software Foundation (ASF) under one
import org.apache.plc4x.java.isoontcp.netty.model.IsoOnTcpMessage;
import org.apache.plc4x.java.netty.NettyTestBase;
import org.apache.plc4x.test.FastTests;
+import org.hamcrest.core.StringContains;
import org.junit.Test;
import org.junit.experimental.categories.Category;
import org.slf4j.LoggerFactory;
+import static org.hamcrest.Matchers.equalTo;
+import static org.hamcrest.core.IsInstanceOf.instanceOf;
+import static org.hamcrest.core.IsNull.notNullValue;
+import static org.hamcrest.core.IsNull.nullValue;
+import static org.hamcrest.core.StringContains.containsString;
+import static org.junit.Assert.assertThat;
+import static org.mockito.Mockito.*;
+
public class IsoOnTcpProtocolTest extends NettyTestBase {
@@ -43,16 +49,16 @@ Licensed to the Apache Software Foundation (ASF) under one
@Category(FastTests.class)
public void encode() {
IsoOnTcpMessage isoOnTcpMessage = new IsoOnTcpMessage(
- Unpooled.wrappedBuffer(new byte[]{(byte)0x01,(byte)0x02,(byte)0x03}));
+ Unpooled.wrappedBuffer(new byte[]{(byte) 0x01, (byte) 0x02, (byte) 0x03}));
EmbeddedChannel channel = new EmbeddedChannel(new IsoOnTcpProtocol());
channel.writeOutbound(isoOnTcpMessage);
channel.checkException();
Object obj = channel.readOutbound();
- assertThat(obj).isInstanceOf(ByteBuf.class);
+ assertThat(obj, instanceOf(ByteBuf.class));
ByteBuf byteBuf = (ByteBuf) obj;
- assertThat(byteBuf.readableBytes()).isEqualTo(4 + 3).withFailMessage("The TCP on ISO Header should add 4 bytes to the data sent");
- assertThat(byteBuf.getByte(0)).isEqualTo(IsoOnTcpProtocol.ISO_ON_TCP_MAGIC_NUMBER);
- assertThat(byteBuf.getShort(2)).isEqualTo((short) (4 + 3)).withFailMessage("The length value in the packet should reflect the size of the entire data being sent");
+ assertThat("The TCP on ISO Header should add 4 bytes to the data sent", byteBuf.readableBytes(), equalTo(4 + 3));
+ assertThat(byteBuf.getByte(0), equalTo(IsoOnTcpProtocol.ISO_ON_TCP_MAGIC_NUMBER) );
+ assertThat("The length value in the packet should reflect the size of the entire data being sent", byteBuf.getShort(2), equalTo((short) (4 + 3)) );
}
/**
@@ -63,14 +69,14 @@ public void encode() {
public void decode() {
EmbeddedChannel channel = new EmbeddedChannel(new IsoOnTcpProtocol());
channel.writeInbound(Unpooled.wrappedBuffer(new byte[]{IsoOnTcpProtocol.ISO_ON_TCP_MAGIC_NUMBER,
- (byte)0x00,(byte)0x00,(byte)0x0D,
- (byte)0x01,(byte)0x02,(byte)0x03,(byte)0x04,(byte)0x05,(byte)0x06,(byte)0x07,(byte)0x08,(byte)0x09}));
+ (byte) 0x00, (byte) 0x00, (byte) 0x0D,
+ (byte) 0x01, (byte) 0x02, (byte) 0x03, (byte) 0x04, (byte) 0x05, (byte) 0x06, (byte) 0x07, (byte) 0x08, (byte) 0x09}));
channel.checkException();
Object obj = channel.readInbound();
- assertThat(obj).isInstanceOf(IsoOnTcpMessage.class);
+ assertThat(obj, instanceOf(IsoOnTcpMessage.class));
IsoOnTcpMessage isoOnTcpMessage = (IsoOnTcpMessage) obj;
- assertThat(isoOnTcpMessage.getUserData()).isNotNull();
- assertThat(isoOnTcpMessage.getUserData().readableBytes()).isEqualTo(9);
+ assertThat(isoOnTcpMessage.getUserData(), notNullValue());
+ assertThat(isoOnTcpMessage.getUserData().readableBytes(), equalTo(9) );
}
/**
@@ -80,13 +86,18 @@ public void decode() {
@Test
@Category(FastTests.class)
public void decodeWrongMagicByte() {
- EmbeddedChannel channel = new EmbeddedChannel(new IsoOnTcpProtocol());
- // TODO: Check this is done the same way as in the rest of the project
- Throwable throwable = catchThrowable(() -> channel.writeInbound(Unpooled.wrappedBuffer(new byte[]{0x12,
- (byte)0x00,(byte)0x00,(byte)0x0D,
- (byte)0x01,(byte)0x02,(byte)0x03,(byte)0x04,(byte)0x05,(byte)0x06,(byte)0x07,(byte)0x08,(byte)0x09})));
- assertThat(throwable).isInstanceOf(PlcProtocolException.class);
- assertThat(throwable.getMessage()).contains("ISO on TCP magic number");
+ try {
+ EmbeddedChannel channel = new EmbeddedChannel(new IsoOnTcpProtocol());
+ // TODO: Check this is done the same way as in the rest of the project
+
+ channel.writeInbound(Unpooled.wrappedBuffer(new byte[]{0x12,
+ (byte) 0x00, (byte) 0x00, (byte) 0x0D,
+ (byte) 0x01, (byte) 0x02, (byte) 0x03, (byte) 0x04, (byte) 0x05, (byte) 0x06, (byte) 0x07, (byte) 0x08, (byte) 0x09}));
+ } catch( Throwable throwable )
+ {
+ assertThat(throwable.getMessage(), containsString("ISO on TCP magic number") );
+ assertThat(throwable, instanceOf(PlcProtocolException.class) );
+ }
}
/**
@@ -98,10 +109,10 @@ public void decodeWrongMagicByte() {
public void decodeWayTooShort() {
EmbeddedChannel channel = new EmbeddedChannel(new IsoOnTcpProtocol());
channel.writeInbound(Unpooled.wrappedBuffer(new byte[]{IsoOnTcpProtocol.ISO_ON_TCP_MAGIC_NUMBER,
- (byte)0x00,(byte)0x00,(byte)0x0D}));
+ (byte) 0x00, (byte) 0x00, (byte) 0x0D}));
channel.checkException();
Object obj = channel.readInbound();
- assertThat(obj).isNull();
+ assertThat(obj, nullValue() );
}
/**
@@ -113,11 +124,11 @@ public void decodeWayTooShort() {
public void decodeTooShort() {
EmbeddedChannel channel = new EmbeddedChannel(new IsoOnTcpProtocol());
channel.writeInbound(Unpooled.wrappedBuffer(new byte[]{IsoOnTcpProtocol.ISO_ON_TCP_MAGIC_NUMBER,
- (byte)0x00,(byte)0x00,(byte)0x0D,
- (byte)0x01,(byte)0x02,(byte)0x03,(byte)0x04,(byte)0x05,(byte)0x06,(byte)0x07,(byte)0x08}));
+ (byte) 0x00, (byte) 0x00, (byte) 0x0D,
+ (byte) 0x01, (byte) 0x02, (byte) 0x03, (byte) 0x04, (byte) 0x05, (byte) 0x06, (byte) 0x07, (byte) 0x08}));
channel.checkException();
Object obj = channel.readInbound();
- assertThat(obj).isNull();
+ assertThat(obj, nullValue() );
}
/**
@@ -145,7 +156,7 @@ public void decodeLogPacketIfTraceLogging() {
(byte) 0x01, (byte) 0x02, (byte) 0x03, (byte) 0x04, (byte) 0x05, (byte) 0x06, (byte) 0x07, (byte) 0x08, (byte) 0x09}));
channel.checkException();
Object obj = channel.readInbound();
- assertThat(obj).isNotNull();
+ assertThat(obj, notNullValue());
// Check that the packet dump was logged.
verify(mockAppender).doAppend(argThat(argument ->
diff --git a/plc4j/protocols/s7/src/test/java/org/apache/plc4x/java/isotp/netty/IsoTPProtocolTest.java b/plc4j/protocols/s7/src/test/java/org/apache/plc4x/java/isotp/netty/IsoTPProtocolTest.java
index 26a6ce97..16b26fc6 100644
--- a/plc4j/protocols/s7/src/test/java/org/apache/plc4x/java/isotp/netty/IsoTPProtocolTest.java
+++ b/plc4j/protocols/s7/src/test/java/org/apache/plc4x/java/isotp/netty/IsoTPProtocolTest.java
@@ -18,8 +18,6 @@ Licensed to the Apache Software Foundation (ASF) under one
*/
package org.apache.plc4x.java.isotp.netty;
-import static org.assertj.core.api.Assertions.assertThat;
-
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelHandlerContext;
@@ -37,6 +35,11 @@ Licensed to the Apache Software Foundation (ASF) under one
import java.util.ArrayList;
import java.util.Collections;
+import static org.hamcrest.collection.IsCollectionWithSize.hasSize;
+import static org.hamcrest.collection.IsEmptyCollection.empty;
+import static org.hamcrest.core.Is.is;
+import static org.hamcrest.core.IsEqual.equalTo;
+import static org.junit.Assert.assertThat;
import static org.mockito.Mockito.RETURNS_DEEP_STUBS;
import static org.mockito.Mockito.mock;
@@ -71,16 +74,16 @@ public void encodeConnectionRequest() throws Exception {
isoTPProtocol.encode(ctx, tpdu, out);
- assertThat(out).hasSize(1).overridingErrorMessage("Message not decoded");
+ assertThat("Message not decoded", out, hasSize(1));
ByteBuf userData = ((IsoOnTcpMessage) out.get(0)).getUserData();
- assertThat(userData.writerIndex()).isEqualTo(7);
- assertThat(userData.readByte()).isEqualTo((byte) 0x6);
- assertThat(userData.readByte()).isEqualTo(TpduCode.CONNECTION_REQUEST.getCode());
- assertThat(userData.readShort()).isEqualTo((short) 0x1);
- assertThat(userData.readShort()).isEqualTo((short) 0x2);
- assertThat(userData.readByte()).isEqualTo(ProtocolClass.CLASS_0.getCode());
+ assertThat(userData.writerIndex(), equalTo(7));
+ assertThat(userData.readByte(), equalTo((byte) 0x6));
+ assertThat(userData.readByte(), equalTo(TpduCode.CONNECTION_REQUEST.getCode()));
+ assertThat(userData.readShort(), equalTo((short) 0x1));
+ assertThat(userData.readShort(), equalTo((short) 0x2));
+ assertThat(userData.readByte(), equalTo(ProtocolClass.CLASS_0.getCode()));
}
@Test
@@ -95,15 +98,15 @@ public void decodeConnectionRequest() throws Exception {
isoTPProtocol.decode(ctx, in, out);
- assertThat(out).hasSize(1).overridingErrorMessage("Message not decoded");
+ assertThat("Message not decoded", out, hasSize(1));
ConnectionRequestTpdu requestTpdu = (ConnectionRequestTpdu) ((IsoTPMessage) out.get(0)).getTpdu();
- assertThat(requestTpdu.getTpduCode()).isEqualTo(TpduCode.CONNECTION_REQUEST);
- assertThat(requestTpdu.getDestinationReference()).isEqualTo((short) 0x1);
- assertThat(requestTpdu.getSourceReference()).isEqualTo((short) 0x2);
- assertThat(requestTpdu.getProtocolClass()).isEqualTo(ProtocolClass.CLASS_0);
- assertThat(requestTpdu.getParameters()).isEmpty();
+ assertThat(requestTpdu.getTpduCode(), equalTo(TpduCode.CONNECTION_REQUEST));
+ assertThat(requestTpdu.getDestinationReference(), equalTo((short) 0x1));
+ assertThat(requestTpdu.getSourceReference(), equalTo((short) 0x2));
+ assertThat(requestTpdu.getProtocolClass(), equalTo(ProtocolClass.CLASS_0));
+ assertThat(requestTpdu.getParameters(), empty());
}
@Test
@@ -113,15 +116,15 @@ public void encodeDisconnectionRequest() throws Exception {
isoTPProtocol.encode(ctx, tpdu, out);
- assertThat(out).hasSize(1).overridingErrorMessage("Message not decoded");
+ assertThat("Message not decoded", out, hasSize(1));
ByteBuf userData = ((IsoOnTcpMessage) out.get(0)).getUserData();
- assertThat(userData.writerIndex()).isEqualTo(7);
- assertThat(userData.readByte()).isEqualTo((byte) 0x6);
- assertThat(userData.readByte()).isEqualTo(TpduCode.DISCONNECT_REQUEST.getCode());
- assertThat(userData.readShort()).isEqualTo((short) 0x1);
- assertThat(userData.readShort()).isEqualTo((short) 0x2);
- assertThat(userData.readByte()).isEqualTo(DisconnectReason.NORMAL.getCode());
+ assertThat(userData.writerIndex(), equalTo(7));
+ assertThat(userData.readByte(), equalTo((byte) 0x6));
+ assertThat(userData.readByte(), equalTo(TpduCode.DISCONNECT_REQUEST.getCode()));
+ assertThat(userData.readShort(), equalTo((short) 0x1));
+ assertThat(userData.readShort(), equalTo((short) 0x2));
+ assertThat(userData.readByte(), equalTo(DisconnectReason.NORMAL.getCode()));
}
@Test
@@ -136,15 +139,15 @@ public void decodeDisconnectionRequest() throws Exception {
isoTPProtocol.decode(ctx, in, out);
- assertThat(out).hasSize(1).overridingErrorMessage("Message not decoded");
+ assertThat("Message not decoded", out, hasSize(1));
DisconnectRequestTpdu requestTpdu = (DisconnectRequestTpdu) ((IsoTPMessage) out.get(0)).getTpdu();
- assertThat(requestTpdu.getTpduCode()).isEqualTo(TpduCode.DISCONNECT_REQUEST);
- assertThat(requestTpdu.getDestinationReference()).isEqualTo((short) 0x1);
- assertThat(requestTpdu.getSourceReference()).isEqualTo((short) 0x2);
- assertThat(requestTpdu.getDisconnectReason()).isEqualTo(DisconnectReason.NORMAL);
- assertThat(requestTpdu.getParameters()).isEmpty();
+ assertThat(requestTpdu.getTpduCode(), equalTo(TpduCode.DISCONNECT_REQUEST));
+ assertThat(requestTpdu.getDestinationReference(), equalTo((short) 0x1));
+ assertThat(requestTpdu.getSourceReference(), equalTo((short) 0x2));
+ assertThat(requestTpdu.getDisconnectReason(), equalTo(DisconnectReason.NORMAL));
+ assertThat(requestTpdu.getParameters(), empty());
}
@Test
@@ -154,14 +157,14 @@ public void encodeData() throws Exception {
isoTPProtocol.encode(ctx, tpdu, out);
- assertThat(out).hasSize(1).overridingErrorMessage("Message not decoded");
+ assertThat("Message not decoded", out, hasSize(1));
ByteBuf userData = ((IsoOnTcpMessage) out.get(0)).getUserData();
- assertThat(userData.writerIndex()).isEqualTo(3);
- assertThat(userData.readByte()).isEqualTo((byte) 0x2);
- assertThat(userData.readByte()).isEqualTo(TpduCode.DATA.getCode());
- assertThat(userData.readByte()).isEqualTo((byte) 0x87);
+ assertThat(userData.writerIndex(), equalTo(3));
+ assertThat(userData.readByte(), equalTo((byte) 0x2));
+ assertThat(userData.readByte(), equalTo(TpduCode.DATA.getCode()));
+ assertThat(userData.readByte(), equalTo((byte) 0x87));
}
@Test
@@ -174,14 +177,14 @@ public void decodeDataEOT() throws Exception {
isoTPProtocol.decode(ctx, in, out);
- assertThat(out).hasSize(1).overridingErrorMessage("Message not decoded");
+ assertThat("Message not decoded", out, hasSize(1));
DataTpdu requestTpdu = (DataTpdu) ((IsoTPMessage) out.get(0)).getTpdu();
- assertThat(requestTpdu.getTpduCode()).isEqualTo(TpduCode.DATA);
- assertThat(requestTpdu.getTpduRef()).isEqualTo((byte) 0x1);
- assertThat(requestTpdu.isEot()).isTrue();
- assertThat(requestTpdu.getParameters()).isEmpty();
+ assertThat(requestTpdu.getTpduCode(), equalTo(TpduCode.DATA));
+ assertThat(requestTpdu.getTpduRef(), equalTo((byte) 0x1));
+ assertThat(requestTpdu.isEot(), is(true));
+ assertThat(requestTpdu.getParameters(), empty());
}
@Test
@@ -194,14 +197,14 @@ public void decodeData() throws Exception {
isoTPProtocol.decode(ctx, in, out);
- assertThat(out).hasSize(1).overridingErrorMessage("Message not decoded");
+ assertThat("Message not decoded", out, hasSize(1));
DataTpdu requestTpdu = (DataTpdu) ((IsoTPMessage) out.get(0)).getTpdu();
- assertThat(requestTpdu.getTpduCode()).isEqualTo(TpduCode.DATA);
- assertThat(requestTpdu.getTpduRef()).isEqualTo((byte) 0x1);
- assertThat(!requestTpdu.isEot()).isTrue();
- assertThat(requestTpdu.getParameters()).isEmpty();
+ assertThat(requestTpdu.getTpduCode(), equalTo(TpduCode.DATA));
+ assertThat(requestTpdu.getTpduRef(), equalTo((byte) 0x1));
+ assertThat(!requestTpdu.isEot(), is(true));
+ assertThat(requestTpdu.getParameters(), empty());
}
@Test
@@ -211,16 +214,16 @@ public void encodeConnectionConfirm() throws Exception {
isoTPProtocol.encode(ctx, tpdu, out);
- assertThat(out).hasSize(1).overridingErrorMessage("Message not decoded");
+ assertThat("Message not decoded", out, hasSize(1));
ByteBuf userData = ((IsoOnTcpMessage) out.get(0)).getUserData();
- assertThat(userData.writerIndex()).isEqualTo(7);
- assertThat(userData.readByte()).isEqualTo((byte) 0x6);
- assertThat(userData.readByte()).isEqualTo(TpduCode.CONNECTION_CONFIRM.getCode());
- assertThat(userData.readShort()).isEqualTo((short) 0x1);
- assertThat(userData.readShort()).isEqualTo((short) 0x2);
- assertThat(userData.readByte()).isEqualTo(ProtocolClass.CLASS_1.getCode());
+ assertThat(userData.writerIndex(), equalTo(7));
+ assertThat(userData.readByte(), equalTo((byte) 0x6));
+ assertThat(userData.readByte(), equalTo(TpduCode.CONNECTION_CONFIRM.getCode()));
+ assertThat(userData.readShort(), equalTo((short) 0x1));
+ assertThat(userData.readShort(), equalTo((short) 0x2));
+ assertThat(userData.readByte(), equalTo(ProtocolClass.CLASS_1.getCode()));
}
@Test
@@ -235,15 +238,15 @@ public void decodeConnectionConfirm() throws Exception {
isoTPProtocol.decode(ctx, in, out);
- assertThat(out).hasSize(1).overridingErrorMessage("Message not decoded");
+ assertThat("Message not decoded", out, hasSize(1));
ConnectionConfirmTpdu requestTpdu = (ConnectionConfirmTpdu) ((IsoTPMessage) out.get(0)).getTpdu();
- assertThat(requestTpdu.getTpduCode()).isEqualTo(TpduCode.CONNECTION_CONFIRM);
- assertThat(requestTpdu.getDestinationReference()).isEqualTo((short) 0x1);
- assertThat(requestTpdu.getSourceReference()).isEqualTo((short) 0x2);
- assertThat(requestTpdu.getProtocolClass()).isEqualTo(ProtocolClass.CLASS_0);
- assertThat(requestTpdu.getParameters()).isEmpty();
+ assertThat(requestTpdu.getTpduCode(), equalTo(TpduCode.CONNECTION_CONFIRM));
+ assertThat(requestTpdu.getDestinationReference(), equalTo((short) 0x1));
+ assertThat(requestTpdu.getSourceReference(), equalTo((short) 0x2));
+ assertThat(requestTpdu.getProtocolClass(), equalTo(ProtocolClass.CLASS_0));
+ assertThat(requestTpdu.getParameters(), empty());
}
@Test
@@ -253,15 +256,15 @@ public void encodeDisconnectionConfirm() throws Exception {
isoTPProtocol.encode(ctx, tpdu, out);
- assertThat(out).hasSize(1).overridingErrorMessage("Message not decoded");
+ assertThat("Message not decoded", out, hasSize(1));
ByteBuf userData = ((IsoOnTcpMessage) out.get(0)).getUserData();
- assertThat(userData.writerIndex()).isEqualTo(6);
- assertThat(userData.readByte()).isEqualTo((byte) 0x5);
- assertThat(userData.readByte()).isEqualTo(TpduCode.DISCONNECT_CONFIRM.getCode());
- assertThat(userData.readShort()).isEqualTo((short) 0x1);
- assertThat(userData.readShort()).isEqualTo((short) 0x2);
+ assertThat(userData.writerIndex(), equalTo(6));
+ assertThat(userData.readByte(), equalTo((byte) 0x5));
+ assertThat(userData.readByte(), equalTo(TpduCode.DISCONNECT_CONFIRM.getCode()));
+ assertThat(userData.readShort(), equalTo((short) 0x1));
+ assertThat(userData.readShort(), equalTo((short) 0x2));
}
@Test
@@ -276,14 +279,14 @@ public void decodeDisconnectionConfirm() throws Exception {
isoTPProtocol.decode(ctx, in, out);
- assertThat(out).hasSize(1).overridingErrorMessage("Message not decoded");
+ assertThat("Message not decoded", out, hasSize(1));
DisconnectConfirmTpdu requestTpdu = (DisconnectConfirmTpdu) ((IsoTPMessage) out.get(0)).getTpdu();
- assertThat(requestTpdu.getTpduCode()).isEqualTo(TpduCode.DISCONNECT_CONFIRM);
- assertThat(requestTpdu.getDestinationReference()).isEqualTo((short) 0x1);
- assertThat(requestTpdu.getSourceReference()).isEqualTo((short) 0x2);
- assertThat(requestTpdu.getParameters()).isEmpty();
+ assertThat(requestTpdu.getTpduCode(), equalTo(TpduCode.DISCONNECT_CONFIRM));
+ assertThat(requestTpdu.getDestinationReference(), equalTo((short) 0x1));
+ assertThat(requestTpdu.getSourceReference(), equalTo((short) 0x2));
+ assertThat(requestTpdu.getParameters(), empty());
}
@Test
@@ -293,15 +296,15 @@ public void encodeError() throws Exception {
isoTPProtocol.encode(ctx, tpdu, out);
- assertThat(out).hasSize(1).overridingErrorMessage("Message not decoded");
+ assertThat("Message not decoded", out, hasSize(1));
ByteBuf userData = ((IsoOnTcpMessage) out.get(0)).getUserData();
- assertThat(userData.writerIndex()).isEqualTo(5);
- assertThat(userData.readByte()).isEqualTo((byte) 0x4);
- assertThat(userData.readByte()).isEqualTo(TpduCode.TPDU_ERROR.getCode());
- assertThat(userData.readShort()).isEqualTo((short) 0x1);
- assertThat(userData.readByte()).isEqualTo(RejectCause.REASON_NOT_SPECIFIED.getCode());
+ assertThat(userData.writerIndex(), equalTo(5));
+ assertThat(userData.readByte(), equalTo((byte) 0x4));
+ assertThat(userData.readByte(), equalTo(TpduCode.TPDU_ERROR.getCode()));
+ assertThat(userData.readShort(), equalTo((short) 0x1));
+ assertThat(userData.readByte(), equalTo(RejectCause.REASON_NOT_SPECIFIED.getCode()));
}
@Test
@@ -314,21 +317,21 @@ public void encodeCallingParameter() throws Exception {
isoTPProtocol.encode(ctx, tpdu, out);
- assertThat(out).hasSize(1).overridingErrorMessage("Message not decoded");
+ assertThat("Message not decoded", out, hasSize(1));
ByteBuf userData = ((IsoOnTcpMessage) out.get(0)).getUserData();
- assertThat(userData.writerIndex()).isEqualTo(9);
- assertThat(userData.readByte()).isEqualTo((byte) 0x8);
- assertThat(userData.readByte()).isEqualTo(TpduCode.TPDU_ERROR.getCode());
- assertThat(userData.readShort()).isEqualTo((short) 0x1);
- assertThat(userData.readByte()).isEqualTo(RejectCause.REASON_NOT_SPECIFIED.getCode());
- assertThat(userData.readByte()).isEqualTo(ParameterCode.CALLING_TSAP.getCode());
- assertThat(userData.readByte()).isEqualTo((byte) 0x2);
- assertThat(userData.readByte()).isEqualTo(DeviceGroup.PG_OR_PC.getCode());
+ assertThat(userData.writerIndex(), equalTo(9));
+ assertThat(userData.readByte(), equalTo((byte) 0x8));
+ assertThat(userData.readByte(), equalTo(TpduCode.TPDU_ERROR.getCode()));
+ assertThat(userData.readShort(), equalTo((short) 0x1));
+ assertThat(userData.readByte(), equalTo(RejectCause.REASON_NOT_SPECIFIED.getCode()));
+ assertThat(userData.readByte(), equalTo(ParameterCode.CALLING_TSAP.getCode()));
+ assertThat(userData.readByte(), equalTo((byte) 0x2));
+ assertThat(userData.readByte(), equalTo(DeviceGroup.PG_OR_PC.getCode()));
byte rackAndSlot = userData.readByte();
- assertThat((rackAndSlot & 0xf0) >> 4).isEqualTo(0x7);
- assertThat((rackAndSlot & 0x0f)).isEqualTo(0xe1 & 0x0f);
+ assertThat((rackAndSlot & 0xf0) >> 4, equalTo(0x7));
+ assertThat((rackAndSlot & 0x0f), equalTo(0xe1 & 0x0f));
}
@Test
@@ -341,18 +344,18 @@ public void encodeChecksumParameter() throws Exception {
isoTPProtocol.encode(ctx, tpdu, out);
- assertThat(out).hasSize(1).overridingErrorMessage("Message not decoded");
+ assertThat("Message not decoded", out, hasSize(1));
ByteBuf userData = ((IsoOnTcpMessage) out.get(0)).getUserData();
- assertThat(userData.writerIndex()).isEqualTo(8);
- assertThat(userData.readByte()).isEqualTo((byte) 0x7);
- assertThat(userData.readByte()).isEqualTo(TpduCode.TPDU_ERROR.getCode());
- assertThat(userData.readShort()).isEqualTo((short) 0x1);
- assertThat(userData.readByte()).isEqualTo(RejectCause.REASON_NOT_SPECIFIED.getCode());
- assertThat(userData.readByte()).isEqualTo(ParameterCode.CHECKSUM.getCode());
- assertThat(userData.readByte()).isEqualTo((byte) 0x1);
- assertThat(userData.readByte()).isEqualTo((byte) 0x77);
+ assertThat(userData.writerIndex(), equalTo(8));
+ assertThat(userData.readByte(), equalTo((byte) 0x7));
+ assertThat(userData.readByte(), equalTo(TpduCode.TPDU_ERROR.getCode()));
+ assertThat(userData.readShort(), equalTo((short) 0x1));
+ assertThat(userData.readByte(), equalTo(RejectCause.REASON_NOT_SPECIFIED.getCode()));
+ assertThat(userData.readByte(), equalTo(ParameterCode.CHECKSUM.getCode()));
+ assertThat(userData.readByte(), equalTo((byte) 0x1));
+ assertThat(userData.readByte(), equalTo((byte) 0x77));
}
@Test
@@ -366,21 +369,21 @@ public void encodeAditionalInformationParameter() throws Exception {
isoTPProtocol.encode(ctx, tpdu, out);
- assertThat(out).hasSize(1).overridingErrorMessage("Message not decoded");
+ assertThat("Message not decoded", out, hasSize(1));
ByteBuf userData = ((IsoOnTcpMessage) out.get(0)).getUserData();
- assertThat(userData.writerIndex()).isEqualTo(11);
- assertThat(userData.readByte()).isEqualTo((byte) 0xA);
- assertThat(userData.readByte()).isEqualTo(TpduCode.TPDU_ERROR.getCode());
- assertThat(userData.readShort()).isEqualTo((short) 0x1);
- assertThat(userData.readByte()).isEqualTo(RejectCause.REASON_NOT_SPECIFIED.getCode());
- assertThat(userData.readByte()).isEqualTo(ParameterCode.DISCONNECT_ADDITIONAL_INFORMATION.getCode());
- assertThat(userData.readByte()).isEqualTo((byte) 0x4);
- assertThat(userData.readByte()).isEqualTo((byte) 'O');
- assertThat(userData.readByte()).isEqualTo((byte) 'p');
- assertThat(userData.readByte()).isEqualTo((byte) 'p');
- assertThat(userData.readByte()).isEqualTo((byte) 's');
+ assertThat(userData.writerIndex(), equalTo(11));
+ assertThat(userData.readByte(), equalTo((byte) 0xA));
+ assertThat(userData.readByte(), equalTo(TpduCode.TPDU_ERROR.getCode()));
+ assertThat(userData.readShort(), equalTo((short) 0x1));
+ assertThat(userData.readByte(), equalTo(RejectCause.REASON_NOT_SPECIFIED.getCode()));
+ assertThat(userData.readByte(), equalTo(ParameterCode.DISCONNECT_ADDITIONAL_INFORMATION.getCode()));
+ assertThat(userData.readByte(), equalTo((byte) 0x4));
+ assertThat(userData.readByte(), equalTo((byte) 'O'));
+ assertThat(userData.readByte(), equalTo((byte) 'p'));
+ assertThat(userData.readByte(), equalTo((byte) 'p'));
+ assertThat(userData.readByte(), equalTo((byte) 's'));
}
@Test
@@ -393,18 +396,18 @@ public void encodeSizeParameter() throws Exception {
isoTPProtocol.encode(ctx, tpdu, out);
- assertThat(out).hasSize(1).overridingErrorMessage("Message not decoded");
+ assertThat("Message not decoded", out, hasSize(1));
ByteBuf userData = ((IsoOnTcpMessage) out.get(0)).getUserData();
- assertThat(userData.writerIndex()).isEqualTo(8);
- assertThat(userData.readByte()).isEqualTo((byte) 0x7);
- assertThat(userData.readByte()).isEqualTo(TpduCode.TPDU_ERROR.getCode());
- assertThat(userData.readShort()).isEqualTo((short) 0x1);
- assertThat(userData.readByte()).isEqualTo(RejectCause.REASON_NOT_SPECIFIED.getCode());
- assertThat(userData.readByte()).isEqualTo(ParameterCode.TPDU_SIZE.getCode());
- assertThat(userData.readByte()).isEqualTo((byte) 0x1);
- assertThat(userData.readByte()).isEqualTo(TpduSize.SIZE_512.getCode());
+ assertThat(userData.writerIndex(), equalTo(8));
+ assertThat(userData.readByte(), equalTo((byte) 0x7));
+ assertThat(userData.readByte(), equalTo(TpduCode.TPDU_ERROR.getCode()));
+ assertThat(userData.readShort(), equalTo((short) 0x1));
+ assertThat(userData.readByte(), equalTo(RejectCause.REASON_NOT_SPECIFIED.getCode()));
+ assertThat(userData.readByte(), equalTo(ParameterCode.TPDU_SIZE.getCode()));
+ assertThat(userData.readByte(), equalTo((byte) 0x1));
+ assertThat(userData.readByte(), equalTo(TpduSize.SIZE_512.getCode()));
}
@Test
@@ -418,14 +421,14 @@ public void decodeError() throws Exception {
isoTPProtocol.decode(ctx, in, out);
- assertThat(out).hasSize(1).overridingErrorMessage("Message not decoded");
+ assertThat("Message not decoded", out, hasSize(1));
ErrorTpdu errorTpdu = (ErrorTpdu) ((IsoTPMessage) out.get(0)).getTpdu();
- assertThat(errorTpdu.getTpduCode()).isEqualTo(TpduCode.TPDU_ERROR);
- assertThat(errorTpdu.getDestinationReference()).isEqualTo((short) 0x1);
- assertThat(errorTpdu.getRejectCause()).isEqualTo(RejectCause.REASON_NOT_SPECIFIED);
- assertThat(errorTpdu.getParameters()).isEmpty();
+ assertThat(errorTpdu.getTpduCode(), equalTo(TpduCode.TPDU_ERROR));
+ assertThat(errorTpdu.getDestinationReference(), equalTo((short) 0x1));
+ assertThat(errorTpdu.getRejectCause(), equalTo(RejectCause.REASON_NOT_SPECIFIED));
+ assertThat(errorTpdu.getParameters(), empty());
}
@Test
@@ -434,10 +437,10 @@ public void encodeNullRequest() throws Exception {
ConnectionRequestTpdu tpdu = null;
isoTPProtocol.encode(ctx, tpdu, out);
- assertThat(out).isEmpty();
+ assertThat("Message not decoded", out, empty());
isoTPProtocol.encode(ctx, null, out);
- assertThat(out).isEmpty();
+ assertThat("Message not decoded", out, empty());
}
@@ -447,21 +450,21 @@ public void decodeNull() throws Exception {
IsoOnTcpMessage in = new IsoOnTcpMessage(buf);
isoTPProtocol.decode(ctx, in, out);
- assertThat(out).isEmpty();
+ assertThat("Message not decoded", out, empty());
isoTPProtocol.decode(ctx, null, out);
- assertThat(out).isEmpty();
+ assertThat("Message not decoded", out, empty());
}
@Test
@Category(FastTests.class)
public void encodeUnsupported() throws Exception {
ArrayList<Parameter> parmameters = new ArrayList<>();
- CustomTpdu tpdu = new CustomTpdu((byte)0x7F, parmameters, buf);
+ CustomTpdu tpdu = new CustomTpdu((byte) 0x7F, parmameters, buf);
isoTPProtocol.encode(ctx, tpdu, out);
- assertThat(out).isEmpty();
- }
+ assertThat("Message not decoded", out, empty());
+ }
@Test
@@ -472,7 +475,7 @@ public void decodeUnsupported() throws Exception {
.writeByte(0x7F)
.writeShort(0x01); // destination reference
isoTPProtocol.decode(ctx, in, out);
- assertThat(out).isEmpty();
+ assertThat("Message not decoded", out, empty());
}
@Test
@@ -490,19 +493,19 @@ public void decodeCallingParameter() throws Exception {
isoTPProtocol.decode(ctx, in, out);
- assertThat(out).hasSize(1).overridingErrorMessage("Message not decoded");
+ assertThat("Message not decoded", out, hasSize(1));
ErrorTpdu errorTpdu = (ErrorTpdu) ((IsoTPMessage) out.get(0)).getTpdu();
- assertThat(errorTpdu.getTpduCode()).isEqualTo(TpduCode.TPDU_ERROR);
- assertThat(errorTpdu.getDestinationReference()).isEqualTo((short) 0x1);
- assertThat(errorTpdu.getRejectCause()).isEqualTo(RejectCause.REASON_NOT_SPECIFIED);
- assertThat(errorTpdu.getParameters()).hasSize(1);
+ assertThat(errorTpdu.getTpduCode(), equalTo(TpduCode.TPDU_ERROR));
+ assertThat(errorTpdu.getDestinationReference(), equalTo((short) 0x1));
+ assertThat(errorTpdu.getRejectCause(), equalTo(RejectCause.REASON_NOT_SPECIFIED));
+ assertThat(errorTpdu.getParameters(), hasSize(1));
CallingTsapParameter parameter = (CallingTsapParameter) errorTpdu.getParameters().get(0);
- assertThat(parameter.getType()).isEqualTo(ParameterCode.CALLING_TSAP);
- assertThat(parameter.getDeviceGroup()).isEqualTo(DeviceGroup.PG_OR_PC);
- assertThat(parameter.getRackNumber()).isEqualTo((byte) 0x1);
- assertThat(parameter.getSlotNumber()).isEqualTo((byte) 0x7);
+ assertThat(parameter.getType(), equalTo(ParameterCode.CALLING_TSAP));
+ assertThat(parameter.getDeviceGroup(), equalTo(DeviceGroup.PG_OR_PC));
+ assertThat(parameter.getRackNumber(), equalTo((byte) 0x1));
+ assertThat(parameter.getSlotNumber(), equalTo((byte) 0x7));
}
@Test
@@ -520,19 +523,19 @@ public void decodeCalledParameter() throws Exception {
isoTPProtocol.decode(ctx, in, out);
- assertThat(out).hasSize(1).overridingErrorMessage("Message not decoded");
+ assertThat("Message not decoded", out, hasSize(1));
ErrorTpdu errorTpdu = (ErrorTpdu) ((IsoTPMessage) out.get(0)).getTpdu();
- assertThat(errorTpdu.getTpduCode()).isEqualTo(TpduCode.TPDU_ERROR);
- assertThat(errorTpdu.getDestinationReference()).isEqualTo((short) 0x1);
- assertThat(errorTpdu.getRejectCause()).isEqualTo(RejectCause.REASON_NOT_SPECIFIED);
- assertThat(errorTpdu.getParameters()).hasSize(1);
+ assertThat(errorTpdu.getTpduCode(), equalTo(TpduCode.TPDU_ERROR));
+ assertThat(errorTpdu.getDestinationReference(), equalTo((short) 0x1));
+ assertThat(errorTpdu.getRejectCause(), equalTo(RejectCause.REASON_NOT_SPECIFIED));
+ assertThat(errorTpdu.getParameters(), hasSize(1));
CalledTsapParameter parameter = (CalledTsapParameter) errorTpdu.getParameters().get(0);
- assertThat(parameter.getType()).isEqualTo(ParameterCode.CALLED_TSAP);
- assertThat(parameter.getDeviceGroup()).isEqualTo(DeviceGroup.PG_OR_PC);
- assertThat(parameter.getRackNumber()).isEqualTo((byte) 0x2);
- assertThat(parameter.getSlotNumber()).isEqualTo((byte) 0x3);
+ assertThat(parameter.getType(), equalTo(ParameterCode.CALLED_TSAP));
+ assertThat(parameter.getDeviceGroup(), equalTo(DeviceGroup.PG_OR_PC));
+ assertThat(parameter.getRackNumber(), equalTo((byte) 0x2));
+ assertThat(parameter.getSlotNumber(), equalTo((byte) 0x3));
}
@Test
@@ -549,17 +552,17 @@ public void decodeChecksumParameter() throws Exception {
isoTPProtocol.decode(ctx, in, out);
- assertThat(out).hasSize(1).overridingErrorMessage("Message not decoded");
+ assertThat("Message not decoded", out, hasSize(1));
ErrorTpdu errorTpdu = (ErrorTpdu) ((IsoTPMessage) out.get(0)).getTpdu();
- assertThat(errorTpdu.getTpduCode()).isEqualTo(TpduCode.TPDU_ERROR);
- assertThat(errorTpdu.getDestinationReference()).isEqualTo((short) 0x1);
- assertThat(errorTpdu.getRejectCause()).isEqualTo(RejectCause.REASON_NOT_SPECIFIED);
- assertThat(errorTpdu.getParameters()).hasSize(1);
+ assertThat(errorTpdu.getTpduCode(), equalTo(TpduCode.TPDU_ERROR));
+ assertThat(errorTpdu.getDestinationReference(), equalTo((short) 0x1));
+ assertThat(errorTpdu.getRejectCause(), equalTo(RejectCause.REASON_NOT_SPECIFIED));
+ assertThat(errorTpdu.getParameters(), hasSize(1));
ChecksumParameter parameter = (ChecksumParameter) errorTpdu.getParameters().get(0);
- assertThat(parameter.getType()).isEqualTo(ParameterCode.CHECKSUM);
- assertThat(parameter.getChecksum()).isEqualTo((byte) 0x33);
+ assertThat(parameter.getType(), equalTo(ParameterCode.CHECKSUM));
+ assertThat(parameter.getChecksum(), equalTo((byte) 0x33));
}
@Test
@@ -576,17 +579,17 @@ public void decodeSizeParameter() throws Exception {
isoTPProtocol.decode(ctx, in, out);
- assertThat(out).hasSize(1).overridingErrorMessage("Message not decoded");
+ assertThat("Message not decoded", out, hasSize(1));
ErrorTpdu errorTpdu = (ErrorTpdu) ((IsoTPMessage) out.get(0)).getTpdu();
- assertThat(errorTpdu.getTpduCode()).isEqualTo(TpduCode.TPDU_ERROR);
- assertThat(errorTpdu.getDestinationReference()).isEqualTo((short) 0x1);
- assertThat(errorTpdu.getRejectCause()).isEqualTo(RejectCause.REASON_NOT_SPECIFIED);
- assertThat(errorTpdu.getParameters()).hasSize(1);
+ assertThat(errorTpdu.getTpduCode(), equalTo(TpduCode.TPDU_ERROR));
+ assertThat(errorTpdu.getDestinationReference(), equalTo((short) 0x1));
+ assertThat(errorTpdu.getRejectCause(), equalTo(RejectCause.REASON_NOT_SPECIFIED));
+ assertThat(errorTpdu.getParameters(), hasSize(1));
TpduSizeParameter parameter = (TpduSizeParameter) errorTpdu.getParameters().get(0);
- assertThat(parameter.getType()).isEqualTo(ParameterCode.TPDU_SIZE);
- assertThat(parameter.getTpduSize()).isEqualTo(TpduSize.SIZE_256);
+ assertThat(parameter.getType(), equalTo(ParameterCode.TPDU_SIZE));
+ assertThat(parameter.getTpduSize(), equalTo(TpduSize.SIZE_256));
}
@Test
@@ -607,22 +610,22 @@ public void decodeAdditionalInformationParameter() throws Exception {
isoTPProtocol.decode(ctx, in, out);
- assertThat(out).hasSize(1).overridingErrorMessage("Message not decoded");
+ assertThat("Message not decoded", out, hasSize(1));
ErrorTpdu errorTpdu = (ErrorTpdu) ((IsoTPMessage) out.get(0)).getTpdu();
- assertThat(errorTpdu.getTpduCode()).isEqualTo(TpduCode.TPDU_ERROR);
- assertThat(errorTpdu.getDestinationReference()).isEqualTo((short) 0x1);
- assertThat(errorTpdu.getRejectCause()).isEqualTo(RejectCause.REASON_NOT_SPECIFIED);
- assertThat(errorTpdu.getParameters()).hasSize(1);
+ assertThat(errorTpdu.getTpduCode(), equalTo(TpduCode.TPDU_ERROR));
+ assertThat(errorTpdu.getDestinationReference(), equalTo((short) 0x1));
+ assertThat(errorTpdu.getRejectCause(), equalTo(RejectCause.REASON_NOT_SPECIFIED));
+ assertThat(errorTpdu.getParameters(), hasSize(1));
DisconnectAdditionalInformationParameter parameter = (DisconnectAdditionalInformationParameter) errorTpdu.getParameters().get(0);
- assertThat(parameter.getType()).isEqualTo(ParameterCode.DISCONNECT_ADDITIONAL_INFORMATION);
+ assertThat(parameter.getType(), equalTo(ParameterCode.DISCONNECT_ADDITIONAL_INFORMATION));
byte[] data = parameter.getData();
- assertThat(data[0]).isEqualTo((byte) 'E');
- assertThat(data[1]).isEqualTo((byte) 'r');
- assertThat(data[2]).isEqualTo((byte) 'r');
- assertThat(data[3]).isEqualTo((byte) 'o');
- assertThat(data[4]).isEqualTo((byte) 'r');
+ assertThat(data[0], equalTo((byte) 'E'));
+ assertThat(data[1], equalTo((byte) 'r'));
+ assertThat(data[2], equalTo((byte) 'r'));
+ assertThat(data[3], equalTo((byte) 'o'));
+ assertThat(data[4], equalTo((byte) 'r'));
}
}
diff --git a/plc4j/protocols/s7/src/test/java/org/apache/plc4x/java/isotp/netty/model/IsoTPMessageTests.java b/plc4j/protocols/s7/src/test/java/org/apache/plc4x/java/isotp/netty/model/IsoTPMessageTests.java
index 8f73a5bb..f3702397 100644
--- a/plc4j/protocols/s7/src/test/java/org/apache/plc4x/java/isotp/netty/model/IsoTPMessageTests.java
+++ b/plc4j/protocols/s7/src/test/java/org/apache/plc4x/java/isotp/netty/model/IsoTPMessageTests.java
@@ -19,8 +19,6 @@ Licensed to the Apache Software Foundation (ASF) under one
package org.apache.plc4x.java.isotp.netty.model;
-import static org.assertj.core.api.Assertions.assertThat;
-
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import org.apache.plc4x.java.isotp.netty.model.params.Parameter;
@@ -34,6 +32,9 @@ Licensed to the Apache Software Foundation (ASF) under one
import java.util.Collections;
import java.util.List;
+import static org.hamcrest.core.IsEqual.equalTo;
+import static org.junit.Assert.assertThat;
+
public class IsoTPMessageTests {
@Test
@@ -50,10 +51,10 @@ public void isoTPMessage() {
errorData.writeByte(0x72);
userData.writeByte(0x32);
- assertThat(isoTpMessage.getTpdu().getTpduCode()).isEqualTo(TpduCode.TPDU_ERROR);
+ assertThat(isoTpMessage.getTpdu().getTpduCode(), equalTo(TpduCode.TPDU_ERROR));
// Question: do we need two user data fields?
- assertThat(tpdu.getUserData().readByte()).isEqualTo((byte) 0x72);
- assertThat(isoTpMessage.getUserData().readByte()).isEqualTo((byte) 0x32);
+ assertThat(tpdu.getUserData().readByte(), equalTo((byte) 0x72));
+ assertThat(isoTpMessage.getUserData().readByte(), equalTo((byte) 0x32));
}
diff --git a/plc4j/protocols/s7/src/test/java/org/apache/plc4x/java/isotp/netty/model/params/ParameterTests.java b/plc4j/protocols/s7/src/test/java/org/apache/plc4x/java/isotp/netty/model/params/ParameterTests.java
index 0a534572..ff6dcc53 100644
--- a/plc4j/protocols/s7/src/test/java/org/apache/plc4x/java/isotp/netty/model/params/ParameterTests.java
+++ b/plc4j/protocols/s7/src/test/java/org/apache/plc4x/java/isotp/netty/model/params/ParameterTests.java
@@ -19,34 +19,35 @@ Licensed to the Apache Software Foundation (ASF) under one
package org.apache.plc4x.java.isotp.netty.model.params;
-import static org.assertj.core.api.Assertions.assertThat;
-
import org.apache.plc4x.java.isotp.netty.model.types.ParameterCode;
import org.apache.plc4x.java.isotp.netty.model.types.TpduSize;
import org.apache.plc4x.test.FastTests;
import org.junit.Test;
import org.junit.experimental.categories.Category;
+import static org.hamcrest.core.IsEqual.equalTo;
+import static org.junit.Assert.assertThat;
+
public class ParameterTests {
@Test
@Category(FastTests.class)
public void checksumPartameter() {
- ChecksumParameter checksumParameter = new ChecksumParameter((byte)1);
+ ChecksumParameter checksumParameter = new ChecksumParameter((byte) 1);
- assertThat(checksumParameter.getChecksum()).isEqualTo((byte)1).withFailMessage("Checksum incorrect");
- assertThat(checksumParameter.getType()).isEqualTo(ParameterCode.CHECKSUM);
+ assertThat("Checksum incorrect", checksumParameter.getChecksum(), equalTo((byte) 1));
+ assertThat(checksumParameter.getType(), equalTo(ParameterCode.CHECKSUM));
}
@Test
@Category(FastTests.class)
public void disconnectAdditionalInformationParameter() {
- byte[] data = {(byte)1, (byte)2};
+ byte[] data = {(byte) 1, (byte) 2};
DisconnectAdditionalInformationParameter disconnectParameter = new DisconnectAdditionalInformationParameter(data);
- assertThat(disconnectParameter.getData()[0]).isEqualTo((byte)1).withFailMessage("Return parameter incorrect");
- assertThat(disconnectParameter.getData()[1]).isEqualTo((byte)2).withFailMessage("Return parameter incorrect");
- assertThat(disconnectParameter.getType()).isEqualTo(ParameterCode.DISCONNECT_ADDITIONAL_INFORMATION);
+ assertThat(disconnectParameter.getData()[0], equalTo((byte) 1));
+ assertThat(disconnectParameter.getData()[1], equalTo((byte) 2));
+ assertThat(disconnectParameter.getType(), equalTo(ParameterCode.DISCONNECT_ADDITIONAL_INFORMATION));
}
@Test
@@ -54,8 +55,8 @@ public void disconnectAdditionalInformationParameter() {
public void tpduSizeParameter() {
TpduSizeParameter tpduSizeParameter = new TpduSizeParameter(TpduSize.SIZE_512);
- assertThat(tpduSizeParameter.getTpduSize()).isEqualTo(TpduSize.SIZE_512).withFailMessage("Tpdu size incorrect");
- assertThat(tpduSizeParameter.getType()).isEqualTo(ParameterCode.TPDU_SIZE);
+ assertThat("Tpdu size incorrect", tpduSizeParameter.getTpduSize(), equalTo(TpduSize.SIZE_512));
+ assertThat(tpduSizeParameter.getType(), equalTo(ParameterCode.TPDU_SIZE));
}
}
\ No newline at end of file
diff --git a/plc4j/protocols/s7/src/test/java/org/apache/plc4x/java/isotp/netty/model/params/TsapParameterTests.java b/plc4j/protocols/s7/src/test/java/org/apache/plc4x/java/isotp/netty/model/params/TsapParameterTests.java
index f2287179..0fb651c1 100644
--- a/plc4j/protocols/s7/src/test/java/org/apache/plc4x/java/isotp/netty/model/params/TsapParameterTests.java
+++ b/plc4j/protocols/s7/src/test/java/org/apache/plc4x/java/isotp/netty/model/params/TsapParameterTests.java
@@ -19,8 +19,6 @@ Licensed to the Apache Software Foundation (ASF) under one
package org.apache.plc4x.java.isotp.netty.model.params;
-import static org.assertj.core.api.Assertions.assertThat;
-
import org.apache.plc4x.java.isotp.netty.model.types.DeviceGroup;
import org.apache.plc4x.java.isotp.netty.model.types.ParameterCode;
import org.apache.plc4x.test.FastTests;
@@ -28,6 +26,9 @@ Licensed to the Apache Software Foundation (ASF) under one
import org.junit.Test;
import org.junit.experimental.categories.Category;
+import static org.hamcrest.core.IsEqual.equalTo;
+import static org.junit.Assert.assertThat;
+
public class TsapParameterTests {
private TsapParameter tsapParameter;
@@ -43,10 +44,10 @@ public void calledPartameter() {
DeviceGroup deviceGroup = DeviceGroup.valueOf((byte)0);
tsapParameter = new CalledTsapParameter(deviceGroup, (byte)1, (byte)4);
- assertThat(tsapParameter.getDeviceGroup()).isEqualTo(DeviceGroup.valueOf((byte)0)).withFailMessage("Device group incorrect");
- assertThat(tsapParameter.getRackNumber()).isEqualTo((byte)1).withFailMessage("Rack number not correct");
- assertThat(tsapParameter.getSlotNumber()).isEqualTo((byte)4).withFailMessage("Slot number not coorect");
- assertThat(tsapParameter.getType()).isEqualTo(ParameterCode.CALLED_TSAP);
+ assertThat("Device group incorrect", tsapParameter.getDeviceGroup(), equalTo(DeviceGroup.valueOf((byte)0)));
+ assertThat("Rack number not correct", tsapParameter.getRackNumber(), equalTo((byte)1));
+ assertThat("Slot number not coorect", tsapParameter.getSlotNumber(), equalTo((byte)4));
+ assertThat(tsapParameter.getType(), equalTo(ParameterCode.CALLED_TSAP));
}
@Test
@@ -55,10 +56,10 @@ public void callingPartameter() {
DeviceGroup deviceGroup = DeviceGroup.valueOf((byte)0);
tsapParameter = new CallingTsapParameter(deviceGroup, (byte)2, (byte)5);
- assertThat(tsapParameter.getDeviceGroup()).isEqualTo(DeviceGroup.valueOf((byte)0)).withFailMessage("Device group incorrect");
- assertThat(tsapParameter.getRackNumber()).isEqualTo((byte)2).withFailMessage("Rack number not correct");
- assertThat(tsapParameter.getSlotNumber()).isEqualTo((byte)5).withFailMessage("Slot number not coorect");
- assertThat(tsapParameter.getType()).isEqualTo(ParameterCode.CALLING_TSAP);
+ assertThat("Device group incorrect", tsapParameter.getDeviceGroup(), equalTo(DeviceGroup.valueOf((byte)0)));
+ assertThat("Rack number not correct", tsapParameter.getRackNumber(), equalTo((byte)2));
+ assertThat("Slot number not coorect", tsapParameter.getSlotNumber(), equalTo((byte)5));
+ assertThat(tsapParameter.getType(), equalTo(ParameterCode.CALLING_TSAP));
}
}
\ No newline at end of file
diff --git a/plc4j/protocols/s7/src/test/java/org/apache/plc4x/java/isotp/netty/model/tpdus/IsotpModelTests.java b/plc4j/protocols/s7/src/test/java/org/apache/plc4x/java/isotp/netty/model/tpdus/IsotpModelTests.java
index 78aa79c2..c4a62f45 100644
--- a/plc4j/protocols/s7/src/test/java/org/apache/plc4x/java/isotp/netty/model/tpdus/IsotpModelTests.java
+++ b/plc4j/protocols/s7/src/test/java/org/apache/plc4x/java/isotp/netty/model/tpdus/IsotpModelTests.java
@@ -19,8 +19,6 @@ Licensed to the Apache Software Foundation (ASF) under one
package org.apache.plc4x.java.isotp.netty.model.tpdus;
-import static org.assertj.core.api.Assertions.assertThat;
-
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import org.apache.plc4x.java.isotp.netty.model.params.CallingTsapParameter;
@@ -36,6 +34,14 @@ Licensed to the Apache Software Foundation (ASF) under one
import java.util.Collections;
import java.util.List;
+import static org.hamcrest.collection.IsCollectionWithSize.hasSize;
+import static org.hamcrest.collection.IsEmptyCollection.empty;
+import static org.hamcrest.collection.IsIterableContainingInOrder.contains;
+import static org.hamcrest.core.Is.is;
+import static org.hamcrest.core.IsEqual.equalTo;
+import static org.hamcrest.core.IsNot.not;
+import static org.junit.Assert.assertThat;
+
public class IsotpModelTests {
@Test
@@ -50,11 +56,11 @@ public void errorTpdu() {
ErrorTpdu tpdu = new ErrorTpdu(destinationReference, rejectCause, parameters, userData);
- assertThat(tpdu.getTpduCode()).isEqualTo(TpduCode.TPDU_ERROR);
- assertThat(tpdu.getDestinationReference()).isEqualTo((short) 0x1).withFailMessage("Unexpected destination reference");
- assertThat(tpdu.getRejectCause()).isEqualTo(RejectCause.REASON_NOT_SPECIFIED);
- assertThat(tpdu.getParameters()).isEmpty();
- assertThat(tpdu.getUserData().readByte()).isEqualTo((byte) 0x7F).withFailMessage("Unexpected user data");
+ assertThat(tpdu.getTpduCode(), equalTo(TpduCode.TPDU_ERROR));
+ assertThat("Unexpected destination reference", tpdu.getDestinationReference(), equalTo((short) 0x1));
+ assertThat(tpdu.getRejectCause(), equalTo(RejectCause.REASON_NOT_SPECIFIED));
+ assertThat(tpdu.getParameters(), empty() );
+ assertThat("Unexpected user data", tpdu.getUserData().readByte(), equalTo((byte) 0x7F));
}
@Test
@@ -72,10 +78,10 @@ public void errorTpduParameter() {
parameters.add(new TpduSizeParameter(TpduSize.SIZE_1024));
parameters.add(new ChecksumParameter((byte) 0xFF));
- assertThat(tpdu.getParameters()).hasSize(2).withFailMessage("Unexpected number of parameters");
- assertThat(tpdu.getParameters()).containsAll(parameters).withFailMessage("Unexpected parameter");
- assertThat(tpdu.getParameter(ChecksumParameter.class).isPresent()).isTrue().withFailMessage("Checksum parameter should exist");
- assertThat(!tpdu.getParameter(CallingTsapParameter.class).isPresent()).isTrue().withFailMessage("CallingTsapParameter parameter should not exist");
+ assertThat("Unexpected number of parameters", tpdu.getParameters(), hasSize(2));
+ assertThat("Unexpected parameter", tpdu.getParameters(), contains(parameters.toArray()));
+ assertThat("Checksum parameter should exist", tpdu.getParameter(ChecksumParameter.class).isPresent(), is(true));
+ assertThat("CallingTsapParameter parameter should not exist", !tpdu.getParameter(CallingTsapParameter.class).isPresent(), is(true));
}
@Test
@@ -88,11 +94,11 @@ public void dataTpdu() {
DataTpdu tpdu = new DataTpdu(true, (byte) 0x7F, parameters, userData);
- assertThat(tpdu.getTpduCode()).isEqualTo(TpduCode.DATA);
- assertThat(tpdu.isEot()).isTrue().withFailMessage("Unexpected eot reference");
- assertThat(tpdu.getTpduRef()).isEqualTo((byte) 0x7F);
- assertThat(tpdu.getParameters().isEmpty()).isTrue().withFailMessage("Unexpected parameters");
- assertThat(tpdu.getUserData().readByte()).isEqualTo((byte) 0x66).withFailMessage("Unexpected user data");
+ assertThat(tpdu.getTpduCode(), equalTo(TpduCode.DATA));
+ assertThat("Unexpected eot reference", tpdu.isEot(), is(true));
+ assertThat(tpdu.getTpduRef(), equalTo((byte) 0x7F));
+ assertThat("Unexpected parameters", tpdu.getParameters().isEmpty(), is(true));
+ assertThat("Unexpected user data", tpdu.getUserData().readByte(), equalTo((byte) 0x66));
}
@Test
@@ -108,12 +114,12 @@ public void connectionRequestTpdu() {
ConnectionRequestTpdu tpdu = new ConnectionRequestTpdu(destinationReference, sourceReference, protocolClass, parameters, userData);
- assertThat(tpdu.getTpduCode()).isEqualTo(TpduCode.CONNECTION_REQUEST);
- assertThat(tpdu.getDestinationReference()).isEqualTo((short) 0x1).withFailMessage("Unexpected destination reference");
- assertThat(tpdu.getSourceReference()).isEqualTo((short) 0x2).withFailMessage("Unexpected source reference");
- assertThat(tpdu.getProtocolClass()).isEqualTo(ProtocolClass.CLASS_0);
- assertThat(tpdu.getParameters().isEmpty()).isTrue().withFailMessage("Unexpected parameters");
- assertThat(tpdu.getUserData().readByte()).isEqualTo((byte) 0x33).withFailMessage("Unexpected user data");
+ assertThat(tpdu.getTpduCode(), equalTo(TpduCode.CONNECTION_REQUEST));
+ assertThat("Unexpected destination reference", tpdu.getDestinationReference(), equalTo((short) 0x1));
+ assertThat("Unexpected source reference", tpdu.getSourceReference(), equalTo((short) 0x2));
+ assertThat(tpdu.getProtocolClass(), equalTo(ProtocolClass.CLASS_0));
+ assertThat("Unexpected parameters", tpdu.getParameters().isEmpty(), is(true));
+ assertThat("Unexpected user data", tpdu.getUserData().readByte(), equalTo((byte) 0x33));
}
@Test
@@ -129,12 +135,12 @@ public void connectionConfirmTpdu() {
ConnectionConfirmTpdu tpdu = new ConnectionConfirmTpdu(destinationReference, sourceReference, protocolClass, parameters, userData);
- assertThat(tpdu.getTpduCode()).isEqualTo(TpduCode.CONNECTION_CONFIRM);
- assertThat(tpdu.getDestinationReference()).isEqualTo((short) 0x3).withFailMessage("Unexpected destination reference");
- assertThat(tpdu.getSourceReference()).isEqualTo((short) 0x4).withFailMessage("Unexpected source reference");
- assertThat(tpdu.getProtocolClass()).isEqualTo(ProtocolClass.CLASS_1);
- assertThat(tpdu.getParameters().isEmpty()).isTrue().withFailMessage("Unexpected parameters");
- assertThat(tpdu.getUserData().readByte()).isEqualTo((byte) 0x44).withFailMessage("Unexpected user data");
+ assertThat(tpdu.getTpduCode(), equalTo(TpduCode.CONNECTION_CONFIRM));
+ assertThat("Unexpected destination reference", tpdu.getDestinationReference(), equalTo((short) 0x3));
+ assertThat("Unexpected source reference", tpdu.getSourceReference(), equalTo((short) 0x4));
+ assertThat(tpdu.getProtocolClass(), equalTo(ProtocolClass.CLASS_1));
+ assertThat("Unexpected parameters", tpdu.getParameters().isEmpty(), is(true));
+ assertThat("Unexpected user data", tpdu.getUserData().readByte(), equalTo((byte) 0x44));
}
@Test
@@ -150,12 +156,12 @@ public void disconnectionRequestTpdu() {
DisconnectRequestTpdu tpdu = new DisconnectRequestTpdu(destinationReference, sourceReference, disconnectReason, parameters, userData);
- assertThat(tpdu.getTpduCode()).isEqualTo(TpduCode.DISCONNECT_REQUEST);
- assertThat(tpdu.getDestinationReference()).isEqualTo((short) 0x1).withFailMessage("Unexpected destination reference");
- assertThat(tpdu.getSourceReference()).isEqualTo((short) 0x2).withFailMessage("Unexpected source reference");
- assertThat(tpdu.getDisconnectReason()).isEqualTo(DisconnectReason.ADDRESS_UNKNOWN);
- assertThat(tpdu.getParameters().isEmpty()).isTrue().withFailMessage("Unexpected parameters");
- assertThat(tpdu.getUserData().readByte()).isEqualTo((byte) 0x22).withFailMessage("Unexpected user data");
+ assertThat(tpdu.getTpduCode(), equalTo(TpduCode.DISCONNECT_REQUEST));
+ assertThat("Unexpected destination reference", tpdu.getDestinationReference(), equalTo((short) 0x1));
+ assertThat("Unexpected source reference", tpdu.getSourceReference(), equalTo((short) 0x2));
+ assertThat(tpdu.getDisconnectReason(), equalTo(DisconnectReason.ADDRESS_UNKNOWN));
+ assertThat("Unexpected parameters", tpdu.getParameters(), empty());
+ assertThat("Unexpected user data", tpdu.getUserData().readByte(), equalTo((byte) 0x22));
}
@Test
@@ -170,11 +176,11 @@ public void disconnectionConfirmTpdu() {
DisconnectConfirmTpdu tpdu = new DisconnectConfirmTpdu(destinationReference, sourceReference, parameters, userData);
- assertThat(tpdu.getTpduCode()).isEqualTo(TpduCode.DISCONNECT_CONFIRM);
- assertThat(tpdu.getDestinationReference()).isEqualTo((short) 0x3).withFailMessage("Unexpected destination reference");
- assertThat(tpdu.getSourceReference()).isEqualTo((short) 0x4).withFailMessage("Unexpected source reference");
- assertThat(tpdu.getParameters().isEmpty()).isTrue().withFailMessage("Unexpected parameters");
- assertThat(tpdu.getUserData().readByte()).isEqualTo((byte) 0x11).withFailMessage("Unexpected user data");
+ assertThat(tpdu.getTpduCode(), equalTo(TpduCode.DISCONNECT_CONFIRM));
+ assertThat("Unexpected destination reference", tpdu.getDestinationReference(), equalTo((short) 0x3));
+ assertThat("Unexpected source reference", tpdu.getSourceReference(), equalTo((short) 0x4));
+ assertThat("Unexpected parameters", tpdu.getParameters().isEmpty(), is(true));
+ assertThat("Unexpected user data", tpdu.getUserData().readByte(), equalTo((byte) 0x11));
}
}
\ No newline at end of file
diff --git a/plc4j/protocols/s7/src/test/java/org/apache/plc4x/java/isotp/netty/model/types/IsotpTypeTests.java b/plc4j/protocols/s7/src/test/java/org/apache/plc4x/java/isotp/netty/model/types/IsotpTypeTests.java
index 7df9684e..d2fe7f09 100644
--- a/plc4j/protocols/s7/src/test/java/org/apache/plc4x/java/isotp/netty/model/types/IsotpTypeTests.java
+++ b/plc4j/protocols/s7/src/test/java/org/apache/plc4x/java/isotp/netty/model/types/IsotpTypeTests.java
@@ -19,13 +19,15 @@ Licensed to the Apache Software Foundation (ASF) under one
package org.apache.plc4x.java.isotp.netty.model.types;
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.assertj.core.api.Assertions.assertThatThrownBy;
-
import org.apache.plc4x.test.FastTests;
import org.junit.Test;
import org.junit.experimental.categories.Category;
+import static org.hamcrest.core.IsEqual.equalTo;
+import static org.hamcrest.core.IsNot.not;
+import static org.hamcrest.core.IsNull.nullValue;
+import static org.junit.Assert.assertThat;
+
public class IsotpTypeTests {
@Test
@@ -34,21 +36,21 @@ public void deviceGroup() {
DeviceGroup deviceGroup;
deviceGroup = DeviceGroup.PG_OR_PC;
- assertThat(deviceGroup.getCode()).isEqualTo((byte)1);
+ assertThat(deviceGroup.getCode(), equalTo((byte) 1));
deviceGroup = DeviceGroup.OS;
- assertThat(deviceGroup.getCode()).isEqualTo((byte)2);
+ assertThat(deviceGroup.getCode(), equalTo((byte) 2));
deviceGroup = DeviceGroup.OTHERS;
- assertThat(deviceGroup.getCode()).isEqualTo((byte)3);
+ assertThat(deviceGroup.getCode(), equalTo((byte) 3));
}
@Test
@Category(FastTests.class)
public void deviceGroupUnknown() {
- DeviceGroup deviceGroup = DeviceGroup.valueOf((byte)0x40);
+ DeviceGroup deviceGroup = DeviceGroup.valueOf((byte) 0x40);
- assertThat(deviceGroup).isNull();
+ assertThat(deviceGroup, nullValue());
}
@@ -57,16 +59,16 @@ public void deviceGroupUnknown() {
public void disconnectReason() {
DisconnectReason disconnectReason = DisconnectReason.ADDRESS_UNKNOWN;
- assertThat(DisconnectReason.valueOf((byte)3)).isEqualTo(DisconnectReason.ADDRESS_UNKNOWN).withFailMessage("3 incorrectly mapped");
- assertThat(disconnectReason.getCode()).isEqualTo((byte)3);
+ assertThat("3 incorrectly mapped", DisconnectReason.valueOf((byte) 3), equalTo(DisconnectReason.ADDRESS_UNKNOWN));
+ assertThat(disconnectReason.getCode(), equalTo((byte) 3));
}
@Test
@Category(FastTests.class)
public void diosconectReasonUnknown() {
- DisconnectReason disconnectReason = DisconnectReason.valueOf((byte)4);
+ DisconnectReason disconnectReason = DisconnectReason.valueOf((byte) 4);
- assertThat(disconnectReason).isNull();
+ assertThat(disconnectReason, nullValue());
}
@Test
@@ -74,16 +76,16 @@ public void diosconectReasonUnknown() {
public void parameterCode() {
ParameterCode parameterCode = ParameterCode.CALLING_TSAP;
- assertThat(ParameterCode.valueOf((byte)0xC1)).isEqualTo(ParameterCode.CALLING_TSAP);
- assertThat(parameterCode.getCode()).isEqualTo((byte)0xC1);
+ assertThat(ParameterCode.valueOf((byte) 0xC1), equalTo(ParameterCode.CALLING_TSAP));
+ assertThat(parameterCode.getCode(), equalTo((byte) 0xC1));
}
@Test
@Category(FastTests.class)
public void parameterCodeUnknown() {
- ParameterCode parameterCode = ParameterCode.valueOf((byte)0x90);
+ ParameterCode parameterCode = ParameterCode.valueOf((byte) 0x90);
- assertThat(parameterCode).isNull();
+ assertThat(parameterCode, nullValue());
}
@Test
@@ -92,24 +94,24 @@ public void protocolClass() {
ProtocolClass protocolClass;
protocolClass = ProtocolClass.CLASS_1;
- assertThat(protocolClass.getCode()).isEqualTo((byte)0x10);
+ assertThat(protocolClass.getCode(), equalTo((byte) 0x10));
protocolClass = ProtocolClass.CLASS_2;
- assertThat(protocolClass.getCode()).isEqualTo((byte)0x20);
+ assertThat(protocolClass.getCode(), equalTo((byte) 0x20));
protocolClass = ProtocolClass.CLASS_3;
- assertThat(protocolClass.getCode()).isEqualTo((byte)0x30);
+ assertThat(protocolClass.getCode(), equalTo((byte) 0x30));
protocolClass = ProtocolClass.CLASS_4;
- assertThat(protocolClass.getCode()).isEqualTo((byte)0x40);
+ assertThat(protocolClass.getCode(), equalTo((byte) 0x40));
}
@Test
@Category(FastTests.class)
public void protocolClassUnknown() {
- ProtocolClass protocolClass = ProtocolClass.valueOf((byte)0x50);
+ ProtocolClass protocolClass = ProtocolClass.valueOf((byte) 0x50);
- assertThat(protocolClass).isNull();
+ assertThat(protocolClass, nullValue());
}
@Test
@@ -117,16 +119,16 @@ public void protocolClassUnknown() {
public void rejectCause() {
RejectCause rejectCause = RejectCause.INVALID_PARAMETER_TYPE;
- assertThat(RejectCause.valueOf((byte)0x03)).isEqualTo(RejectCause.INVALID_PARAMETER_TYPE);
- assertThat(rejectCause.getCode()).isEqualTo((byte)0x03);
+ assertThat(RejectCause.valueOf((byte) 0x03), equalTo(RejectCause.INVALID_PARAMETER_TYPE));
+ assertThat(rejectCause.getCode(), equalTo((byte) 0x03));
}
@Test
@Category(FastTests.class)
public void rejectClauseUnknown() {
- RejectCause rejectCause = RejectCause.valueOf((byte)0x90);
+ RejectCause rejectCause = RejectCause.valueOf((byte) 0x90);
- assertThat(rejectCause).isNull();
+ assertThat(rejectCause, nullValue());
}
@Test
@@ -134,35 +136,35 @@ public void rejectClauseUnknown() {
public void tpduCode() {
TpduCode tpduCode = TpduCode.DATA;
- assertThat(TpduCode.valueOf((byte)0xF0)).isEqualTo(TpduCode.DATA);
- assertThat(tpduCode.getCode()).isEqualTo((byte)0xF0);
+ assertThat(TpduCode.valueOf((byte) 0xF0), equalTo(TpduCode.DATA));
+ assertThat(tpduCode.getCode(), equalTo((byte) 0xF0));
}
@Test
@Category(FastTests.class)
public void tpduCodeUnknown() {
- TpduCode tpduCode = TpduCode.valueOf((byte)0x01);
+ TpduCode tpduCode = TpduCode.valueOf((byte) 0x01);
- assertThat(TpduCode.valueOf((byte)0xFF)).isEqualTo(TpduCode.TPDU_UNKNOWN);
- assertThat(tpduCode.getCode()).isEqualTo((byte)0xFF);
+ assertThat(TpduCode.valueOf((byte) 0xFF), equalTo(TpduCode.TPDU_UNKNOWN));
+ assertThat(tpduCode.getCode(), equalTo((byte) 0xFF));
}
-
+
@Test
@Category(FastTests.class)
public void typduSize() {
TpduSize tpduSize = TpduSize.SIZE_128;
- assertThat(TpduSize.valueOf((byte)0x07)).isEqualTo(TpduSize.SIZE_128);
- assertThat(tpduSize.getCode()).isEqualTo((byte)0x07);
- assertThat(tpduSize.getValue()).isEqualTo(128);
+ assertThat(TpduSize.valueOf((byte) 0x07), equalTo(TpduSize.SIZE_128));
+ assertThat(tpduSize.getCode(), equalTo((byte) 0x07));
+ assertThat(tpduSize.getValue(), equalTo(128));
}
@Test
@Category(FastTests.class)
public void tpduSizeUnknown() {
- TpduSize tpduSize = TpduSize.valueOf((byte)0x06);
+ TpduSize tpduSize = TpduSize.valueOf((byte) 0x06);
- assertThat(tpduSize).isNull();
+ assertThat(tpduSize, nullValue());
}
/**
@@ -174,7 +176,7 @@ public void tpduSizeUnknown() {
public void tpduValueForGivenExactFit() {
TpduSize tpduSize = TpduSize.valueForGivenSize(256);
- assertThat(tpduSize).isEqualTo(TpduSize.SIZE_256);
+ assertThat(tpduSize, equalTo(TpduSize.SIZE_256));
}
/**
@@ -186,21 +188,18 @@ public void tpduValueForGivenExactFit() {
public void tpduValueForGivenIntermediateSize() {
TpduSize tpduSize = TpduSize.valueForGivenSize(222);
- assertThat(tpduSize).isEqualTo(TpduSize.SIZE_256);
- assertThat(tpduSize.getValue()).isNotEqualTo(222);
+ assertThat(tpduSize, equalTo(TpduSize.SIZE_256));
+ assertThat(tpduSize.getValue(), not(equalTo(222)));
}
/**
* This test should cause an exception as the tpdu size has to be greater
* than 0 in any case.
*/
- @Test
+ @Test(expected = IllegalArgumentException.class)
@Category(FastTests.class)
public void tpduValueForGivenTooSmallSize() {
- assertThatThrownBy(() ->
- TpduSize.valueForGivenSize(-1))
- .isInstanceOf(IllegalArgumentException.class);
-
+ TpduSize.valueForGivenSize(-1);
}
/**
@@ -211,8 +210,7 @@ public void tpduValueForGivenTooSmallSize() {
@Category(FastTests.class)
public void tpduValueForGivenTooGreatSize() {
TpduSize tpduSize = TpduSize.valueForGivenSize(10000);
-
- assertThat(tpduSize).isEqualTo(TpduSize.SIZE_8192);
+ assertThat(tpduSize, equalTo(TpduSize.SIZE_8192));
}
}
\ No newline at end of file
diff --git a/plc4j/protocols/s7/src/test/java/org/apache/plc4x/java/netty/events/S7StateTests.java b/plc4j/protocols/s7/src/test/java/org/apache/plc4x/java/netty/events/S7StateTests.java
index a798cf22..1599515f 100644
--- a/plc4j/protocols/s7/src/test/java/org/apache/plc4x/java/netty/events/S7StateTests.java
+++ b/plc4j/protocols/s7/src/test/java/org/apache/plc4x/java/netty/events/S7StateTests.java
@@ -19,12 +19,13 @@ Licensed to the Apache Software Foundation (ASF) under one
package org.apache.plc4x.java.netty.events;
-import static org.assertj.core.api.Assertions.assertThat;
-
import org.apache.plc4x.test.FastTests;
import org.junit.Test;
import org.junit.experimental.categories.Category;
+import static org.hamcrest.core.IsEqual.equalTo;
+import static org.junit.Assert.assertThat;
+
public class S7StateTests {
@Test
@@ -32,7 +33,7 @@ Licensed to the Apache Software Foundation (ASF) under one
public void testInitialS7ConnectionEvent() {
S7ConnectionEvent s7event = new S7ConnectionEvent();
- assertThat(s7event.getState()).isEqualTo(S7ConnectionState.INITIAL);
+ assertThat(s7event.getState(), equalTo(S7ConnectionState.INITIAL));
}
@Test
@@ -40,7 +41,7 @@ public void testInitialS7ConnectionEvent() {
public void testS7ConnectionEvent() {
S7ConnectionEvent s7event = new S7ConnectionEvent(S7ConnectionState.SETUP_COMPLETE);
- assertThat(s7event.getState()).isEqualTo(S7ConnectionState.SETUP_COMPLETE);
+ assertThat(s7event.getState(), equalTo(S7ConnectionState.SETUP_COMPLETE) );
}
}
\ No newline at end of file
diff --git a/plc4j/protocols/s7/src/test/java/org/apache/plc4x/java/s7/S7PlcDriverTest.java b/plc4j/protocols/s7/src/test/java/org/apache/plc4x/java/s7/S7PlcDriverTest.java
index 89424303..abf56c3e 100644
--- a/plc4j/protocols/s7/src/test/java/org/apache/plc4x/java/s7/S7PlcDriverTest.java
+++ b/plc4j/protocols/s7/src/test/java/org/apache/plc4x/java/s7/S7PlcDriverTest.java
@@ -18,9 +18,6 @@ Licensed to the Apache Software Foundation (ASF) under one
*/
package org.apache.plc4x.java.s7;
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.assertj.core.api.Assertions.assertThatThrownBy;
-
import org.apache.plc4x.java.PlcDriverManager;
import org.apache.plc4x.java.api.authentication.PlcUsernamePasswordAuthentication;
import org.apache.plc4x.java.api.exceptions.PlcConnectionException;
@@ -31,6 +28,9 @@ Licensed to the Apache Software Foundation (ASF) under one
import org.junit.Test;
import org.junit.experimental.categories.Category;
+import static org.hamcrest.core.IsEqual.equalTo;
+import static org.junit.Assert.assertThat;
+
public class S7PlcDriverTest {
@Ignore("We first have to find/build some tool to help test these connections.")
@@ -39,32 +39,28 @@ Licensed to the Apache Software Foundation (ASF) under one
public void getConnection() throws PlcException {
S7PlcConnection s7Connection = (S7PlcConnection)
new PlcDriverManager().getConnection("s7://localhost/1/2");
- assertThat(s7Connection.getRack()).isEqualTo(1);
- assertThat(s7Connection.getSlot()).isEqualTo(2);
+ assertThat(s7Connection.getRack(), equalTo(1));
+ assertThat(s7Connection.getSlot(), equalTo(2));
}
/**
* In this test case the 's7' driver should report an invalid url format.
*/
- @Test
+ @Test(expected = PlcConnectionException.class)
@Category(FastTests.class)
- public void getConnectionInvalidUrl() {
- assertThatThrownBy(() ->
- new PlcDriverManager().getConnection("s7://localhost/hurz/2"))
- .isInstanceOf(PlcConnectionException.class);
+ public void getConnectionInvalidUrl() throws PlcConnectionException {
+ new PlcDriverManager().getConnection("s7://localhost/hurz/2");
}
/**
* In this test case the 's7' driver should report an error as this protocol
* doesn't support authentication.
*/
- @Test
+ @Test(expected = PlcConnectionException.class)
@Category(FastTests.class)
- public void getConnectionWithAuthentication() {
- assertThatThrownBy(() ->
- new PlcDriverManager().getConnection("s7://localhost/1/2",
- new PlcUsernamePasswordAuthentication("user", "pass")))
- .isInstanceOf(PlcConnectionException.class);
+ public void getConnectionWithAuthentication() throws PlcConnectionException {
+ new PlcDriverManager().getConnection("s7://localhost/1/2",
+ new PlcUsernamePasswordAuthentication("user", "pass"));
}
}
diff --git a/plc4j/protocols/s7/src/test/java/org/apache/plc4x/java/s7/connection/S7PlcConnectionIT.java b/plc4j/protocols/s7/src/test/java/org/apache/plc4x/java/s7/connection/S7PlcConnectionIT.java
index 63cd03a5..6cbfd165 100644
--- a/plc4j/protocols/s7/src/test/java/org/apache/plc4x/java/s7/connection/S7PlcConnectionIT.java
+++ b/plc4j/protocols/s7/src/test/java/org/apache/plc4x/java/s7/connection/S7PlcConnectionIT.java
@@ -20,7 +20,6 @@ Licensed to the Apache Software Foundation (ASF) under one
import io.netty.channel.Channel;
import org.apache.plc4x.java.api.exceptions.PlcConnectionException;
-import org.assertj.core.api.Assertions;
import org.junit.After;
import org.junit.Before;
import org.junit.Rule;
@@ -29,7 +28,10 @@ Licensed to the Apache Software Foundation (ASF) under one
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import static org.assertj.core.api.Assertions.assertThat;
+import static org.hamcrest.core.Is.is;
+import static org.hamcrest.core.IsNull.notNullValue;
+import static org.junit.Assert.assertThat;
+import static org.junit.Assert.fail;
public class S7PlcConnectionIT {
@@ -49,7 +51,7 @@ public void setUp() {
channel = s7PlcConnection.getChannel();
} catch (PlcConnectionException e) {
logger.error("Error initializing connection", e);
- Assertions.fail("Error initializing connection");
+ fail("Error initializing connection");
}
}
@@ -64,9 +66,8 @@ public void tearDown() {
@Test
public void connect() {
- assertThat(s7PlcConnection).isNotNull();
- assertThat(s7PlcConnection.isConnected()).isTrue()
- .withFailMessage("The connection should be 'connected'");
+ assertThat(s7PlcConnection, notNullValue());
+ assertThat("The connection should be 'connected'", s7PlcConnection.isConnected(), is( true) );
}
// TODO more tests for connect, close, read and write
diff --git a/plc4j/protocols/s7/src/test/java/org/apache/plc4x/java/s7/connection/S7PlcConnectionTests.java b/plc4j/protocols/s7/src/test/java/org/apache/plc4x/java/s7/connection/S7PlcConnectionTests.java
index 22a7164f..75a43573 100644
--- a/plc4j/protocols/s7/src/test/java/org/apache/plc4x/java/s7/connection/S7PlcConnectionTests.java
+++ b/plc4j/protocols/s7/src/test/java/org/apache/plc4x/java/s7/connection/S7PlcConnectionTests.java
@@ -19,9 +19,6 @@ Licensed to the Apache Software Foundation (ASF) under one
package org.apache.plc4x.java.s7.connection;
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.assertj.core.api.Assertions.fail;
-
import org.apache.plc4x.java.api.exceptions.PlcException;
import org.apache.plc4x.java.isotp.netty.model.types.TpduSize;
import org.apache.plc4x.java.s7.model.S7Address;
@@ -34,6 +31,11 @@ Licensed to the Apache Software Foundation (ASF) under one
import java.net.InetAddress;
+import static org.hamcrest.core.IsEqual.equalTo;
+import static org.hamcrest.core.StringStartsWith.startsWith;
+import static org.junit.Assert.assertThat;
+import static org.junit.Assert.fail;
+
public class S7PlcConnectionTests {
private S7PlcConnection s7PlcConnection;
@@ -51,16 +53,11 @@ public void tearDown() {
@Test
public void initialState() {
- assertThat(s7PlcConnection.getRack()).isEqualTo(1)
- .withFailMessage("Rack is incorrect");
- assertThat(s7PlcConnection.getSlot()).isEqualTo(2)
- .withFailMessage("Slot is incorrect");
- assertThat(s7PlcConnection.getParamPduSize()).isEqualTo(TpduSize.SIZE_1024)
- .withFailMessage("Pdu size is incorrect");
- assertThat(s7PlcConnection.getParamMaxAmqCaller()).isEqualTo(8)
- .withFailMessage("Max AMQ Caller size is incorrect");
- assertThat(s7PlcConnection.getParamMaxAmqCallee()).isEqualTo(8)
- .withFailMessage("Max AMQ Callee size is incorrect");
+ assertThat("Rack is incorrect", s7PlcConnection.getRack(), equalTo(1) );
+ assertThat("Slot is incorrect", s7PlcConnection.getSlot(), equalTo(2) );
+ assertThat("Pdu size is incorrect", s7PlcConnection.getParamPduSize(), equalTo(TpduSize.SIZE_1024));
+ assertThat("Max AMQ Caller size is incorrect", s7PlcConnection.getParamMaxAmqCaller(), equalTo(8) );
+ assertThat("Max AMQ Callee size is incorrect", s7PlcConnection.getParamMaxAmqCallee(), equalTo(8) );
}
@Test
@@ -69,7 +66,7 @@ public void emptyParseAddress() {
s7PlcConnection.parseAddress("");
}
catch (PlcException exception) {
- assertThat(exception.getMessage()).startsWith("Address string doesn't match");
+ assertThat(exception.getMessage(), startsWith("Address string doesn't match") );
}
}
@@ -79,10 +76,8 @@ public void parseDatablockAddress() {
S7DataBlockAddress address = (S7DataBlockAddress)
s7PlcConnection.parseAddress("DATA_BLOCKS/20/100");
- assertThat(address.getDataBlockNumber()).isEqualTo((short) 20)
- .withFailMessage("unexpected data block");
- assertThat(address.getByteOffset()).isEqualTo((short) 100)
- .withFailMessage("unexpected byte offset");
+ assertThat("unexpected data block", address.getDataBlockNumber(), equalTo((short) 20) );
+ assertThat("unexpected byte offset", address.getByteOffset(), equalTo((short) 100) );
}
catch (PlcException exception) {
fail("valid data block address");
@@ -94,10 +89,8 @@ public void parseAddressAddress() {
try {
S7Address address = (S7Address) s7PlcConnection.parseAddress("TIMERS/10");
- assertThat(address.getMemoryArea()).isEqualTo(MemoryArea.TIMERS)
- .withFailMessage("unexpected memory area");
- assertThat(address.getByteOffset()).isEqualTo((short) 10)
- .withFailMessage("unexpected byte offset");
+ assertThat("unexpected memory area", address.getMemoryArea(), equalTo(MemoryArea.TIMERS) );
+ assertThat("unexpected byte offset", address.getByteOffset(), equalTo((short) 10) );
}
catch (PlcException exception) {
fail("valid timer block address");
@@ -109,12 +102,9 @@ public void parseAddressBitAddress() {
try {
S7BitAddress address = (S7BitAddress) s7PlcConnection.parseAddress("TIMERS/10/4");
- assertThat(address.getMemoryArea()).isEqualTo(MemoryArea.TIMERS)
- .withFailMessage("unexpected memory area");
- assertThat(address.getByteOffset()).isEqualTo((short) 10)
- .withFailMessage("unexpected byte offset");
- assertThat(address.getBitOffset()).isEqualTo((byte) 4)
- .withFailMessage("unexpected but offset");
+ assertThat("unexpected memory area", address.getMemoryArea(), equalTo(MemoryArea.TIMERS) );
+ assertThat("unexpected byte offset", address.getByteOffset(), equalTo((short) 10) );
+ assertThat("unexpected but offset", address.getBitOffset(), equalTo((byte) 4) );
}
catch (PlcException exception) {
fail("valid timer block bit address");
diff --git a/plc4j/protocols/s7/src/test/java/org/apache/plc4x/java/s7/model/S7AddressTests.java b/plc4j/protocols/s7/src/test/java/org/apache/plc4x/java/s7/model/S7AddressTests.java
index 87291c2e..c3b9ad3b 100644
--- a/plc4j/protocols/s7/src/test/java/org/apache/plc4x/java/s7/model/S7AddressTests.java
+++ b/plc4j/protocols/s7/src/test/java/org/apache/plc4x/java/s7/model/S7AddressTests.java
@@ -19,13 +19,14 @@ Licensed to the Apache Software Foundation (ASF) under one
package org.apache.plc4x.java.s7.model;
-import static org.assertj.core.api.Assertions.assertThat;
-
import org.apache.plc4x.java.s7.netty.model.types.MemoryArea;
import org.apache.plc4x.test.FastTests;
import org.junit.Test;
import org.junit.experimental.categories.Category;
+import static org.hamcrest.core.IsEqual.equalTo;
+import static org.junit.Assert.assertThat;
+
public class S7AddressTests {
@Test
@@ -34,8 +35,8 @@ public void testS7Address() {
MemoryArea memoryArea = MemoryArea.DATA_BLOCKS;
S7Address s7Address = new S7Address(memoryArea, (short) 0x100);
- assertThat(s7Address.getMemoryArea()).isEqualTo(MemoryArea.DATA_BLOCKS);
- assertThat(s7Address.getByteOffset()).isEqualTo((short) 0x100);
+ assertThat(s7Address.getMemoryArea(), equalTo(MemoryArea.DATA_BLOCKS));
+ assertThat(s7Address.getByteOffset(), equalTo((short) 0x100));
}
@Test
@@ -44,9 +45,9 @@ public void testS7BitAddress() {
MemoryArea memoryArea = MemoryArea.DATA_BLOCKS;
S7BitAddress s7Address = new S7BitAddress(memoryArea, (short) 0x50, (byte) 0x4);
- assertThat(s7Address.getMemoryArea()).isEqualTo(MemoryArea.DATA_BLOCKS);
- assertThat(s7Address.getByteOffset()).isEqualTo((short) 0x50);
- assertThat(s7Address.getBitOffset()).isEqualTo((byte) 0x4);
+ assertThat(s7Address.getMemoryArea(), equalTo(MemoryArea.DATA_BLOCKS));
+ assertThat(s7Address.getByteOffset(), equalTo((short) 0x50));
+ assertThat(s7Address.getBitOffset(), equalTo((byte) 0x4));
}
@Test
@@ -54,9 +55,9 @@ public void testS7BitAddress() {
public void testS7DatBlockAddress() {
S7DataBlockAddress s7Address = new S7DataBlockAddress((short) 1, (short) 0x50);
- assertThat(s7Address.getMemoryArea()).isEqualTo(MemoryArea.DATA_BLOCKS);
- assertThat(s7Address.getDataBlockNumber()).isEqualTo((short) 1);
- assertThat(s7Address.getByteOffset()).isEqualTo((short) 0x50);
+ assertThat(s7Address.getMemoryArea(), equalTo(MemoryArea.DATA_BLOCKS));
+ assertThat(s7Address.getDataBlockNumber(), equalTo((short) 1));
+ assertThat(s7Address.getByteOffset(), equalTo((short) 0x50));
}
}
\ No newline at end of file
diff --git a/plc4j/protocols/s7/src/test/java/org/apache/plc4x/java/s7/netty/Plc4XS7ProtocolTest.java b/plc4j/protocols/s7/src/test/java/org/apache/plc4x/java/s7/netty/Plc4XS7ProtocolTest.java
index 2a40eb58..57cd106b 100644
--- a/plc4j/protocols/s7/src/test/java/org/apache/plc4x/java/s7/netty/Plc4XS7ProtocolTest.java
+++ b/plc4j/protocols/s7/src/test/java/org/apache/plc4x/java/s7/netty/Plc4XS7ProtocolTest.java
@@ -18,7 +18,10 @@ Licensed to the Apache Software Foundation (ASF) under one
*/
package org.apache.plc4x.java.s7.netty;
-import org.apache.plc4x.java.api.messages.*;
+import org.apache.plc4x.java.api.messages.PlcReadRequest;
+import org.apache.plc4x.java.api.messages.PlcRequest;
+import org.apache.plc4x.java.api.messages.PlcRequestContainer;
+import org.apache.plc4x.java.api.messages.PlcWriteRequest;
import org.apache.plc4x.java.api.messages.specific.TypeSafePlcReadRequest;
import org.apache.plc4x.java.api.messages.specific.TypeSafePlcWriteRequest;
import org.apache.plc4x.java.netty.NettyTestBase;
@@ -45,7 +48,8 @@ Licensed to the Apache Software Foundation (ASF) under one
import java.util.function.Consumer;
import static java.util.Collections.singletonList;
-import static org.assertj.core.api.Assertions.assertThat;
+import static org.hamcrest.collection.IsCollectionWithSize.hasSize;
+import static org.junit.Assert.assertThat;
import static org.mockito.Mockito.*;
@SuppressWarnings("unchecked")
@@ -99,14 +103,14 @@ public void encode() throws Exception {
LinkedList<Object> out = new LinkedList<>();
SUT.encode(null, createMockedContainer(new TypeSafePlcReadRequest(type, address)), out);
// TODO: finish the asserts
- assertThat(out).hasSize(1);
+ assertThat(out, hasSize(1));
}
// Write Request Tests
{
LinkedList<Object> out = new LinkedList<>();
SUT.encode(null, createMockedContainer(new TypeSafePlcWriteRequest(type, address, fakeValueFor(type))), out);
// TODO: finish the asserts
- assertThat(out).hasSize(1);
+ assertThat(out, hasSize(1));
}
}
@@ -133,7 +137,7 @@ public void decode() throws Exception {
LinkedList<Object> out = new LinkedList<>();
SUT.decode(null, msg, out);
// TODO: finish the asserts
- assertThat(out).hasSize(0);
+ assertThat(out, hasSize(0));
}
// Write Test
{
@@ -155,7 +159,7 @@ public void decode() throws Exception {
LinkedList<Object> out = new LinkedList<>();
SUT.decode(null, msg, out);
// TODO: finish the asserts
- assertThat(out).hasSize(0);
+ assertThat(out, hasSize(0));
}
}
@@ -204,7 +208,7 @@ private VarPayloadItem varPayloadItemFor(Class type) {
data = new byte[]{(byte) 0b0000_0000, (byte) 0b0000_0000, (byte) 0b0000_0000, (byte) 0b0000_0000};
} else if (type == String.class) {
size = DataTransportSize.BYTE_WORD_DWORD;
- data = new byte[]{(byte) 'S', (byte) 't', (byte) 'r', (byte) 'i' ,(byte) 'n', (byte) 'g', (byte) 0x0};
+ data = new byte[]{(byte) 'S', (byte) 't', (byte) 'r', (byte) 'i', (byte) 'n', (byte) 'g', (byte) 0x0};
} else {
throw new IllegalArgumentException("Type t not supported " + type);
}
diff --git a/plc4j/protocols/s7/src/test/java/org/apache/plc4x/java/s7/netty/S7ProtocolTest.java b/plc4j/protocols/s7/src/test/java/org/apache/plc4x/java/s7/netty/S7ProtocolTest.java
index 8bcddcc0..45c28c72 100644
--- a/plc4j/protocols/s7/src/test/java/org/apache/plc4x/java/s7/netty/S7ProtocolTest.java
+++ b/plc4j/protocols/s7/src/test/java/org/apache/plc4x/java/s7/netty/S7ProtocolTest.java
@@ -37,7 +37,8 @@ Licensed to the Apache Software Foundation (ASF) under one
import java.util.LinkedList;
import static java.util.Collections.singletonList;
-import static org.assertj.core.api.Assertions.assertThat;
+import static org.hamcrest.collection.IsCollectionWithSize.hasSize;
+import static org.junit.Assert.assertThat;
import static org.mockito.Mockito.mock;
public class S7ProtocolTest extends NettyTestBase {
@@ -67,7 +68,7 @@ public void encode() throws Exception {
DataTransportSize.BYTE_WORD_DWORD, new byte[]{0})
))
)), out);
- assertThat(out).hasSize(1);
+ assertThat(out, hasSize(1));
}
@Test
@@ -88,7 +89,7 @@ public void decode() throws Exception {
// userDataLength
buffer.writeShort(0x0000);
SUT.decode(null, new IsoTPMessage(mock(Tpdu.class), buffer), out);
- assertThat(out).hasSize(1);
+ assertThat(out, hasSize(1));
}
}
diff --git a/plc4j/protocols/s7/src/test/java/org/apache/plc4x/java/s7/netty/model/messages/S7MessageTests.java b/plc4j/protocols/s7/src/test/java/org/apache/plc4x/java/s7/netty/model/messages/S7MessageTests.java
index a395f00c..2431df0b 100644
--- a/plc4j/protocols/s7/src/test/java/org/apache/plc4x/java/s7/netty/model/messages/S7MessageTests.java
+++ b/plc4j/protocols/s7/src/test/java/org/apache/plc4x/java/s7/netty/model/messages/S7MessageTests.java
@@ -19,8 +19,6 @@ Licensed to the Apache Software Foundation (ASF) under one
package org.apache.plc4x.java.s7.netty.model.messages;
-import static org.assertj.core.api.Assertions.assertThat;
-
import org.apache.plc4x.java.s7.netty.model.params.CpuServicesParameter;
import org.apache.plc4x.java.s7.netty.model.params.S7Parameter;
import org.apache.plc4x.java.s7.netty.model.params.VarParameter;
@@ -36,6 +34,14 @@ Licensed to the Apache Software Foundation (ASF) under one
import java.util.ArrayList;
+import static org.hamcrest.collection.IsCollectionWithSize.hasSize;
+import static org.hamcrest.collection.IsEmptyCollection.empty;
+import static org.hamcrest.collection.IsIterableContainingInOrder.contains;
+import static org.hamcrest.core.Is.is;
+import static org.hamcrest.core.IsEqual.equalTo;
+import static org.hamcrest.core.IsNull.nullValue;
+import static org.junit.Assert.assertThat;
+
public class S7MessageTests {
@Test
@@ -48,8 +54,8 @@ public void setupCommunictionsRequestMessage() {
SetupCommunicationRequestMessage setupMessage = new SetupCommunicationRequestMessage(tpduReference, maxAmqCaller, maxAmqCallee, pduLength);
- assertThat(setupMessage.getTpduReference()).isEqualTo(tpduReference).withFailMessage("Unexpected tpdu value");
- assertThat(setupMessage.getMessageType()).isEqualTo(MessageType.JOB).withFailMessage("Unexpected message type");
+ assertThat("Unexpected tpdu value", setupMessage.getTpduReference(), equalTo(tpduReference));
+ assertThat("Unexpected message type", setupMessage.getMessageType(), equalTo(MessageType.JOB));
}
@Test
@@ -62,10 +68,10 @@ public void s7RequestMessage() {
S7RequestMessage message = new S7RequestMessage(messageType, tpduReference, s7Parameters, s7Payloads);
- assertThat(message.getTpduReference()).isEqualTo(tpduReference).withFailMessage("Unexpected tpdu value");
- assertThat(message.getMessageType()).isEqualTo(MessageType.USER_DATA).withFailMessage("Unexpected message type");
- assertThat(message.getPayloads()).isNull();
- assertThat(message.getParameters()).isNull();
+ assertThat("Unexpected tpdu value", message.getTpduReference(), equalTo(tpduReference));
+ assertThat("Unexpected message type", message.getMessageType(), equalTo(MessageType.USER_DATA));
+ assertThat(message.getPayloads(), nullValue());
+ assertThat(message.getParameters(), nullValue());
}
@Test
@@ -80,12 +86,12 @@ public void s7ResponseMessage() {
S7ResponseMessage message = new S7ResponseMessage(messageType, tpduReference, s7Parameters, s7Payloads, errorClass, errorCode);
- assertThat(message.getTpduReference()).isEqualTo(tpduReference).withFailMessage("Unexpected tpdu value");
- assertThat(message.getMessageType()).isEqualTo(MessageType.USER_DATA).withFailMessage("Unexpected message type");
- assertThat(message.getErrorClass()).isEqualTo((byte) 0x1).withFailMessage("Unexpected error class");
- assertThat(message.getErrorCode()).isEqualTo((byte) 0x23).withFailMessage("Unexpected error code");
- assertThat(message.getPayloads()).isNull();
- assertThat(message.getParameters()).isNull();
+ assertThat("Unexpected tpdu value", message.getTpduReference(), equalTo(tpduReference));
+ assertThat("Unexpected message type", message.getMessageType(), equalTo(MessageType.USER_DATA));
+ assertThat("Unexpected error class", message.getErrorClass(), equalTo((byte) 0x1));
+ assertThat("Unexpected error code", message.getErrorCode(), equalTo((byte) 0x23));
+ assertThat(message.getPayloads(), nullValue());
+ assertThat(message.getParameters(), nullValue());
}
@Test
@@ -113,13 +119,14 @@ public void s7MessageParameters() {
S7RequestMessage message = new S7RequestMessage(messageType, tpduReference, s7Parameters, s7Payloads);
- assertThat(message.getTpduReference()).isEqualTo(tpduReference).withFailMessage("Unexpected tpdu value");
- assertThat(message.getMessageType()).isEqualTo(MessageType.USER_DATA).withFailMessage("Unexpected message type");
- assertThat(message.getParameters()).hasSize(1).withFailMessage("Unexpected number of parameters");
- assertThat(message.getParameters()).containsAll(s7Parameters).withFailMessage("Unexpected parameters");
- assertThat(message.getParameter(VarParameter.class).get()).isEqualTo(varParameter).withFailMessage("Parameter missing");
- assertThat(message.getParameter(CpuServicesParameter.class).isPresent()).isFalse().withFailMessage("Contains unexpected parameter");
- assertThat(message.getPayloads()).isEmpty();
+ assertThat("Unexpected tpdu value", message.getTpduReference(), equalTo(tpduReference));
+ assertThat("Unexpected message type", message.getMessageType(), equalTo(MessageType.USER_DATA));
+ assertThat("Unexpected number of parameters", message.getParameters(), hasSize(1));
+ assertThat("Unexpected parameters", message.getParameters(), contains(varParameter));
+ assertThat("Parameter missing", message.getParameter(VarParameter.class).isPresent(), is(true));
+ assertThat("Parameter missing", message.getParameter(VarParameter.class).get(), equalTo(varParameter));
+ assertThat("Contains unexpected parameter", message.getParameter(CpuServicesParameter.class).isPresent(), is(false));
+ assertThat(message.getPayloads(), empty());
}
@Test
@@ -131,7 +138,7 @@ public void s7MessagePayload() {
ArrayList<S7Payload> s7Payloads = new ArrayList<>();
ParameterType parameterType = ParameterType.WRITE_VAR;
ArrayList<VarPayloadItem> payloadItems = new ArrayList<>();
- byte[] data = {(byte)0x79};
+ byte[] data = {(byte) 0x79};
VarPayload varPayload;
payloadItems.add(new VarPayloadItem(DataTransportErrorCode.OK, DataTransportSize.BIT, data));
@@ -140,13 +147,13 @@ public void s7MessagePayload() {
S7RequestMessage message = new S7RequestMessage(messageType, tpduReference, s7Parameters, s7Payloads);
- assertThat(message.getTpduReference()).isEqualTo(tpduReference).withFailMessage("Unexpected tpdu value");
- assertThat(message.getMessageType()).isEqualTo(MessageType.USER_DATA).withFailMessage("Unexpected message type");
- assertThat(message.getPayloads()).hasSize(1).withFailMessage("Unexpected number of payloads");
- assertThat(message.getPayloads()).containsAll(s7Payloads).withFailMessage("Unexpected payloads");
- assertThat(message.getPayload(VarPayload.class).get()).isEqualTo(varPayload).withFailMessage("Payload missing");
- assertThat(message.getPayload(VarParameter.class).isPresent()).isFalse().withFailMessage("Contains unexpected payload"); // No other parameter classes
- assertThat(message.getParameters()).isEmpty();
+ assertThat("Unexpected tpdu value", message.getTpduReference(), equalTo(tpduReference));
+ assertThat("Unexpected message type", message.getMessageType(), equalTo(MessageType.USER_DATA));
+ assertThat("Unexpected number of payloads", message.getPayloads(), hasSize(1));
+ assertThat("Unexpected payloads", message.getPayloads(), contains(varPayload));
+ assertThat("Payload missing", message.getPayload(VarPayload.class).get(), equalTo(varPayload));
+ assertThat("Contains unexpected payload", message.getPayload(VarParameter.class).isPresent(), is(false)); // No other parameter classes
+ assertThat(message.getParameters(), empty());
}
@Test
@@ -168,14 +175,14 @@ public void s7AnyVarParameterItem() {
S7AnyVarParameterItem parameterItem = new S7AnyVarParameterItem(specificationType, memoryArea, transportSize, numElements, dataBlock, byteOffset, bitOffset);
- assertThat(parameterItem.getSpecificationType()).isEqualTo(specificationType).withFailMessage("Unexpected specification type");
- assertThat(parameterItem.getMemoryArea()).isEqualTo(MemoryArea.DATA_BLOCKS).withFailMessage("Unexpected memory area");
- assertThat(parameterItem.getTransportSize()).isEqualTo(transportSize).withFailMessage("Unexpected transport size");
- assertThat(parameterItem.getNumElements()).isEqualTo(numElements).withFailMessage("Unexpected number elements");
- assertThat(parameterItem.getDataBlockNumber()).isEqualTo(dataBlock).withFailMessage("Unexpected data block");
- assertThat(parameterItem.getByteOffset()).isEqualTo(byteOffset).withFailMessage("Unexpected byte offset");
- assertThat(parameterItem.getBitOffset()).isEqualTo(bitOffset).withFailMessage("Unexpected bit offset");
- assertThat(parameterItem.getAddressingMode()).isEqualTo(VariableAddressingMode.S7ANY).withFailMessage("Unexpected adressing mode");
+ assertThat("Unexpected specification type", parameterItem.getSpecificationType(), equalTo(specificationType));
+ assertThat("Unexpected memory area", parameterItem.getMemoryArea(), equalTo(MemoryArea.DATA_BLOCKS));
+ assertThat("Unexpected transport size", parameterItem.getTransportSize(), equalTo(transportSize));
+ assertThat("Unexpected number elements", parameterItem.getNumElements(), equalTo(numElements));
+ assertThat("Unexpected data block", parameterItem.getDataBlockNumber(), equalTo((short) dataBlock));
+ assertThat("Unexpected byte offset", parameterItem.getByteOffset(), equalTo((short) byteOffset));
+ assertThat("Unexpected bit offset", parameterItem.getBitOffset(), equalTo(bitOffset));
+ assertThat("Unexpected adressing mode", parameterItem.getAddressingMode(), equalTo(VariableAddressingMode.S7ANY));
}
}
\ No newline at end of file
diff --git a/plc4j/protocols/s7/src/test/java/org/apache/plc4x/java/s7/netty/model/params/S7ParameterTests.java b/plc4j/protocols/s7/src/test/java/org/apache/plc4x/java/s7/netty/model/params/S7ParameterTests.java
index 1e1b78d1..faaf6273 100644
--- a/plc4j/protocols/s7/src/test/java/org/apache/plc4x/java/s7/netty/model/params/S7ParameterTests.java
+++ b/plc4j/protocols/s7/src/test/java/org/apache/plc4x/java/s7/netty/model/params/S7ParameterTests.java
@@ -19,8 +19,6 @@ Licensed to the Apache Software Foundation (ASF) under one
package org.apache.plc4x.java.s7.netty.model.params;
-import static org.assertj.core.api.Assertions.assertThat;
-
import org.apache.plc4x.java.s7.netty.model.params.items.S7AnyVarParameterItem;
import org.apache.plc4x.java.s7.netty.model.params.items.VarParameterItem;
import org.apache.plc4x.java.s7.netty.model.types.MemoryArea;
@@ -33,6 +31,10 @@ Licensed to the Apache Software Foundation (ASF) under one
import java.util.ArrayList;
+import static org.hamcrest.collection.IsIterableContainingInOrder.contains;
+import static org.hamcrest.core.IsEqual.equalTo;
+import static org.junit.Assert.assertThat;
+
public class S7ParameterTests {
@Test
@@ -51,15 +53,15 @@ public void varParameter() {
parameterItems.add(new S7AnyVarParameterItem(specificationType, memoryArea, transportSize, numElements, dataBlock, byteOffset, bitOffset));
VarParameter varParameter = new VarParameter(parameterType, parameterItems);
- assertThat(varParameter.getType()).isEqualTo(ParameterType.READ_VAR).withFailMessage("Unexpected parameter type");
- assertThat(varParameter.getItems()).containsAll(parameterItems).withFailMessage("Unexpected paramater items");
+ assertThat("Unexpected parameter type", varParameter.getType(), equalTo(ParameterType.READ_VAR));
+ assertThat("Unexpected paramater items", varParameter.getItems(), contains(parameterItems.toArray()));
}
@Test
@Category(FastTests.class)
public void cpuServicesParameter() {
CpuServicesParameter cpuParameter = new CpuServicesParameter();
- assertThat(cpuParameter.getType()).isEqualTo(ParameterType.CPU_SERVICES).withFailMessage("Unexpected parameter type");
+ assertThat("Unexpected parameter type", cpuParameter.getType(), equalTo(ParameterType.CPU_SERVICES));
}
@Test
@@ -70,10 +72,10 @@ public void setupCommunicationsParameter() {
short pduLength = 512;
SetupCommunicationParameter setupParameter = new SetupCommunicationParameter(maxAmqCaller, maxAmqCallee, pduLength);
- assertThat(setupParameter.getType()).isEqualTo(ParameterType.SETUP_COMMUNICATION).withFailMessage("Unexpected parameter type");
- assertThat(setupParameter.getMaxAmqCallee()).isEqualTo(maxAmqCallee).withFailMessage("Unexpected value for maxAmqCallee");
- assertThat(setupParameter.getMaxAmqCaller()).isEqualTo(maxAmqCaller).withFailMessage("Unexpected value for maxAmqCaller");
- assertThat(setupParameter.getPduLength()).isEqualTo(pduLength).withFailMessage("Unexpected value for pduLength");
+ assertThat("Unexpected parameter type", setupParameter.getType(), equalTo(ParameterType.SETUP_COMMUNICATION));
+ assertThat("Unexpected value for maxAmqCallee", setupParameter.getMaxAmqCallee(), equalTo(maxAmqCallee));
+ assertThat("Unexpected value for maxAmqCaller", setupParameter.getMaxAmqCaller(), equalTo(maxAmqCaller));
+ assertThat("Unexpected value for pduLength", setupParameter.getPduLength(), equalTo(pduLength));
}
}
\ No newline at end of file
diff --git a/plc4j/protocols/s7/src/test/java/org/apache/plc4x/java/s7/netty/model/payloads/S7PayloadTests.java b/plc4j/protocols/s7/src/test/java/org/apache/plc4x/java/s7/netty/model/payloads/S7PayloadTests.java
index c62583d2..e7ab710f 100644
--- a/plc4j/protocols/s7/src/test/java/org/apache/plc4x/java/s7/netty/model/payloads/S7PayloadTests.java
+++ b/plc4j/protocols/s7/src/test/java/org/apache/plc4x/java/s7/netty/model/payloads/S7PayloadTests.java
@@ -19,8 +19,6 @@ Licensed to the Apache Software Foundation (ASF) under one
package org.apache.plc4x.java.s7.netty.model.payloads;
-import static org.assertj.core.api.Assertions.assertThat;
-
import org.apache.plc4x.java.s7.netty.model.payloads.items.VarPayloadItem;
import org.apache.plc4x.java.s7.netty.model.types.DataTransportErrorCode;
import org.apache.plc4x.java.s7.netty.model.types.DataTransportSize;
@@ -31,6 +29,10 @@ Licensed to the Apache Software Foundation (ASF) under one
import java.util.ArrayList;
+import static org.hamcrest.collection.IsIterableContainingInOrder.contains;
+import static org.hamcrest.core.IsEqual.equalTo;
+import static org.junit.Assert.assertThat;
+
public class S7PayloadTests {
@Test
@@ -41,9 +43,9 @@ public void varPayloadItem() {
byte[] data = {(byte)0xFF};
VarPayloadItem varPayloadItem = new VarPayloadItem(returnCode, dataTransportSize, data);
- assertThat(varPayloadItem.getReturnCode()).isEqualTo(DataTransportErrorCode.NOT_FOUND).withFailMessage("Unexpected data transport error code");
- assertThat(varPayloadItem.getDataTransportSize()).isEqualTo(DataTransportSize.INTEGER).withFailMessage("Unexpected data transport size");
- assertThat(varPayloadItem.getData()[0]).isEqualTo((byte) 0xFF).withFailMessage("Unexpected user data");
+ assertThat("Unexpected data transport error code", varPayloadItem.getReturnCode(), equalTo(DataTransportErrorCode.NOT_FOUND));
+ assertThat("Unexpected data transport size", varPayloadItem.getDataTransportSize(), equalTo(DataTransportSize.INTEGER));
+ assertThat("Unexpected user data", varPayloadItem.getData()[0], equalTo((byte) 0xFF));
}
@Test
@@ -56,8 +58,8 @@ public void varPayload() {
payloadItems.add(new VarPayloadItem(DataTransportErrorCode.OK, DataTransportSize.BIT, data));
VarPayload varPayload = new VarPayload(parameterType, payloadItems);
- assertThat(varPayload.getType()).isEqualTo(ParameterType.DOWNLOAD_ENDED).withFailMessage("Unexpected parameter type");
- assertThat(varPayload.getPayloadItems()).containsAll(payloadItems).withFailMessage("Unexpected pay load items");
+ assertThat("Unexpected parameter type", varPayload.getType(), equalTo(ParameterType.DOWNLOAD_ENDED));
+ assertThat("Unexpected pay load items", varPayload.getPayloadItems(), contains(payloadItems.toArray()));
}
}
\ No newline at end of file
diff --git a/plc4j/protocols/s7/src/test/java/org/apache/plc4x/java/s7/netty/model/types/S7TypeTests.java b/plc4j/protocols/s7/src/test/java/org/apache/plc4x/java/s7/netty/model/types/S7TypeTests.java
index 0cb88865..fcb6e630 100644
--- a/plc4j/protocols/s7/src/test/java/org/apache/plc4x/java/s7/netty/model/types/S7TypeTests.java
+++ b/plc4j/protocols/s7/src/test/java/org/apache/plc4x/java/s7/netty/model/types/S7TypeTests.java
@@ -19,12 +19,15 @@ Licensed to the Apache Software Foundation (ASF) under one
package org.apache.plc4x.java.s7.netty.model.types;
-import static org.assertj.core.api.Assertions.assertThat;
-
import org.apache.plc4x.test.FastTests;
import org.junit.Test;
import org.junit.experimental.categories.Category;
+import static org.hamcrest.core.Is.is;
+import static org.hamcrest.core.IsEqual.equalTo;
+import static org.hamcrest.core.IsNull.nullValue;
+import static org.junit.Assert.assertThat;
+
public class S7TypeTests {
@Test
@@ -32,13 +35,16 @@ Licensed to the Apache Software Foundation (ASF) under one
public void dataTransportErrorCode() {
DataTransportErrorCode dataTransportErrorCode = DataTransportErrorCode.INVALID_ADDRESS;
- assertThat(DataTransportErrorCode.valueOf((byte)5)).isEqualTo(DataTransportErrorCode.INVALID_ADDRESS).withFailMessage("5 incorrectly mapped");
- assertThat(dataTransportErrorCode.getCode()).isEqualTo((byte)5).withFailMessage("code is not 5");
+ assertThat("5 incorrectly mapped", DataTransportErrorCode.valueOf((byte) 5), equalTo(DataTransportErrorCode.INVALID_ADDRESS));
+ assertThat("code is not 5", dataTransportErrorCode.getCode(), equalTo((byte) 5));
}
@Test
@Category(FastTests.class)
public void unknownDataTransportErrorCode() {
+ DataTransportErrorCode dataTransportErrorCode = DataTransportErrorCode.INVALID_ADDRESS;
+
+ assertThat(DataTransportErrorCode.valueOf((byte) 0xFE), nullValue());
assertThat(DataTransportErrorCode.valueOf((byte)0xFE)).isNull();
DataTransportErrorCode dataTransportErrorCode = DataTransportErrorCode.INVALID_ADDRESS;
@@ -50,9 +56,9 @@ public void unknownDataTransportErrorCode() {
public void dataTransportSize() {
DataTransportSize dataTransportSize = DataTransportSize.DINTEGER;
- assertThat(DataTransportSize.valueOf((byte)6)).isEqualTo(DataTransportSize.DINTEGER).withFailMessage("6 incorrectly mapped");
- assertThat(dataTransportSize.getCode()).isEqualTo((byte)6).withFailMessage("code is not 6");
- assertThat(dataTransportSize.isSizeInBits()).isFalse().withFailMessage("Unexpected return from bit size");
+ assertThat("6 incorrectly mapped", DataTransportSize.valueOf((byte) 6), equalTo(DataTransportSize.DINTEGER));
+ assertThat(dataTransportSize.getCode(), equalTo((byte) 6));
+ assertThat("Unexpected return from bit size", dataTransportSize.isSizeInBits(), is(false));
}
@Test
@@ -67,6 +73,10 @@ public void headerErrorClass() {
@Test
@Category(FastTests.class)
public void messageType() {
+ MessageType messageType = MessageType.ACK;
+
+ assertThat("2 incorrectly mapped", MessageType.valueOf((byte) 2), equalTo(MessageType.ACK));
+ assertThat("code is not 2", messageType.getCode(), equalTo((byte) 2));
assertThat(MessageType.valueOf((byte)2)).isEqualTo(MessageType.ACK).withFailMessage("2 incorrectly mapped");
MessageType messageType = MessageType.ACK;
@@ -87,8 +97,8 @@ public void parameterError() {
public void parameterType() {
ParameterType parameterType = ParameterType.UPLOAD;
- assertThat(ParameterType.valueOf((byte)0x1E)).isEqualTo(ParameterType.UPLOAD).withFailMessage("0x1E incorrectly mapped");
- assertThat(parameterType.getCode()).isEqualTo((byte)0x1E).withFailMessage("code is not 0x1E");
+ assertThat("0x1E incorrectly mapped", ParameterType.valueOf((byte) 0x1E), equalTo(ParameterType.UPLOAD));
+ assertThat("code is not 0x1E", parameterType.getCode(), equalTo((byte) 0x1E));
}
@Test
@@ -96,7 +106,8 @@ public void parameterType() {
public void unknownParameterType() {
ParameterType parameterType = ParameterType.UPLOAD;
- assertThat(ParameterType.valueOf((byte)0xFF)).isNull();;
+ assertThat(ParameterType.valueOf((byte) 0xFF), nullValue());
+ ;
}
@Test
@@ -104,8 +115,8 @@ public void unknownParameterType() {
public void specificationType() {
SpecificationType specificationType = SpecificationType.VARIABLE_SPECIFICATION;
- assertThat(SpecificationType.valueOf((byte)0x12)).isEqualTo(SpecificationType.VARIABLE_SPECIFICATION).withFailMessage("0x12 incorrectly mapped");
- assertThat(specificationType.getCode()).isEqualTo((byte)0x12).withFailMessage("code is not 0x12");
+ assertThat("0x12 incorrectly mapped", SpecificationType.valueOf((byte) 0x12), equalTo(SpecificationType.VARIABLE_SPECIFICATION));
+ assertThat("code is not 0x12", specificationType.getCode(), equalTo((byte) 0x12));
}
@Test
@@ -113,8 +124,8 @@ public void specificationType() {
public void transportSize() {
TransportSize transportSize = TransportSize.TIME;
- assertThat(TransportSize.valueOf((byte)0x0B)).isEqualTo(TransportSize.TIME).withFailMessage("0x0B incorrectly mapped");
- assertThat(transportSize.getCode()).isEqualTo((byte)0x0B).withFailMessage("code is not 0x0B");
+ assertThat("0x0B incorrectly mapped", TransportSize.valueOf((byte) 0x0B), equalTo(TransportSize.TIME));
+ assertThat("code is not 0x0B", transportSize.getCode(), equalTo((byte) 0x0B));
}
@Test
@@ -122,8 +133,8 @@ public void transportSize() {
public void variableAddressingMode() {
VariableAddressingMode variableAddressingMode = VariableAddressingMode.ALARM_ACK;
- assertThat(VariableAddressingMode.valueOf((byte)0x19)).isEqualTo(VariableAddressingMode.ALARM_ACK).withFailMessage("0x19 incorrectly mapped");
- assertThat(variableAddressingMode.getCode()).isEqualTo((byte)0x19).withFailMessage("code is not 0x19");
+ assertThat("0x19 incorrectly mapped", VariableAddressingMode.valueOf((byte) 0x19), equalTo(VariableAddressingMode.ALARM_ACK));
+ assertThat("code is not 0x19", variableAddressingMode.getCode(), equalTo((byte) 0x19));
}
@Test
@@ -131,14 +142,14 @@ public void variableAddressingMode() {
public void memoryAccess() {
MemoryArea memoryArea = MemoryArea.DATA_BLOCKS;
- assertThat(MemoryArea.valueOf((byte)0x84)).isEqualTo(MemoryArea.DATA_BLOCKS).withFailMessage("0x84 incorrectly mapped");
- assertThat(memoryArea.getCode()).isEqualTo((byte)0x84).withFailMessage("code is not 0x84");
+ assertThat("0x84 incorrectly mapped", MemoryArea.valueOf((byte) 0x84), equalTo(MemoryArea.DATA_BLOCKS));
+ assertThat("code is not 0x84", memoryArea.getCode(), equalTo((byte) 0x84));
}
@Test
@Category(FastTests.class)
public void unknownMemoryAccess() {
- assertThat(MemoryArea.valueOf((byte)0xFF)).isNull();
- }
+ assertThat(MemoryArea.valueOf((byte) 0xFF), nullValue());
+ }
}
\ No newline at end of file
diff --git a/pom.xml b/pom.xml
index f742afc7..2ed26814 100644
--- a/pom.xml
+++ b/pom.xml
@@ -89,9 +89,9 @@
<!-- Exclude all generated code -->
<sonar.exclusions>**/generated-sources</sonar.exclusions>
- <assertj.version>3.8.0</assertj.version>
<commons-io.version>2.6</commons-io.version>
<commons-lang.version>2.6</commons-lang.version>
+ <hamcrest.version>1.3</hamcrest.version>
<gson.version>2.8.0</gson.version>
<junit.version>4.12</junit.version>
<logback.version>1.2.3</logback.version>
@@ -170,6 +170,16 @@
<artifactId>junit</artifactId>
<version>${junit.version}</version>
</dependency>
+ <dependency>
+ <groupId>org.hamcrest</groupId>
+ <artifactId>hamcrest-core</artifactId>
+ <version>${hamcrest.version}</version>
+ </dependency>
+ <dependency>
+ <groupId>org.hamcrest</groupId>
+ <artifactId>hamcrest-library</artifactId>
+ <version>${hamcrest.version}</version>
+ </dependency>
<dependency>
<groupId>org.mockito</groupId>
<artifactId>mockito-core</artifactId>
@@ -914,9 +924,14 @@
</dependency>
<dependency>
- <groupId>org.assertj</groupId>
- <artifactId>assertj-core</artifactId>
- <version>${assertj.version}</version>
+ <groupId>org.hamcrest</groupId>
+ <artifactId>hamcrest-core</artifactId>
+ <scope>test</scope>
+ </dependency>
+
+ <dependency>
+ <groupId>org.hamcrest</groupId>
+ <artifactId>hamcrest-library</artifactId>
<scope>test</scope>
</dependency>
@@ -955,6 +970,8 @@
<ignoredDependencies>
<ignoredDependency>org.assertj:assertj-core</ignoredDependency>
<ignoredDependency>junit:junit</ignoredDependency>
+ <ignoredDependency>org.hamcrest:hamcrest-core</ignoredDependency>
+ <ignoredDependency>org.hamcrest:hamcrest-library</ignoredDependency>
<ignoredDependency>org.mockito:mockito-core</ignoredDependency>
<ignoredDependency>org.slf4j:slf4j-api</ignoredDependency>
<ignoredDependency>ch.qos.logback:logback-classic</ignoredDependency>
----------------------------------------------------------------
This is an automated message from the Apache Git Service.
To respond to the message, please log on GitHub and use the
URL above to go to the specific comment.
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
With regards,
Apache Git Services