From a851ede71462f3e7ffe72dba5879f0d9cea53d27 Mon Sep 17 00:00:00 2001 From: Edouard DUPIN Date: Fri, 4 Jun 2021 11:33:20 +0200 Subject: [PATCH] [DEV] update esignal to support weak object ==> correct free model --- src/org/atriasoft/esignal/Connection.java | 4 + src/org/atriasoft/esignal/Signal.java | 124 ++++---- test/src/test/atriasoft/esignal/Log.java | 59 ++++ .../test/atriasoft/esignal/TestSignal.java | 301 ++++++++++++++++++ .../atriasoft/esignal/TestSignalType.java | 301 ++++++++++++++++++ test/src/test/atriasoft/ewol/Log.java | 2 +- test/src/test/atriasoft/ewol/Log2.java | 2 +- .../src/test/atriasoft/ewol/TestBasicLog.java | 2 +- 8 files changed, 736 insertions(+), 59 deletions(-) create mode 100644 test/src/test/atriasoft/esignal/Log.java create mode 100644 test/src/test/atriasoft/esignal/TestSignal.java create mode 100644 test/src/test/atriasoft/esignal/TestSignalType.java diff --git a/src/org/atriasoft/esignal/Connection.java b/src/org/atriasoft/esignal/Connection.java index 019dfdb..619d541 100644 --- a/src/org/atriasoft/esignal/Connection.java +++ b/src/org/atriasoft/esignal/Connection.java @@ -5,6 +5,10 @@ import java.lang.ref.WeakReference; public class Connection implements AutoCloseable { protected WeakReference connection; + public void connectionIsRemovedBySignal() { + connection = null; + } + public void disconnect() { close(); } diff --git a/src/org/atriasoft/esignal/Signal.java b/src/org/atriasoft/esignal/Signal.java index f637ebf..7a148e2 100644 --- a/src/org/atriasoft/esignal/Signal.java +++ b/src/org/atriasoft/esignal/Signal.java @@ -7,105 +7,115 @@ import java.util.List; import java.util.function.Consumer; class ConnectedElement { - protected final Consumer consumer; - protected final WeakReference reference; + protected final WeakReference> consumer; - public ConnectedElement(final WeakReference reference, final Consumer consumer) { - this.reference = reference; - this.consumer = consumer; + public ConnectedElement(final Consumer consumer) { + this.consumer = new WeakReference>(consumer); } public Consumer getConsumer() { - return this.consumer; - } - - public WeakReference getReference() { - return this.reference; - } - public Object getIfAlive() { - return this.reference.get(); + return this.consumer.get(); } + public boolean isCompatibleWith(final Object elem) { + /* Object out = this.reference.get(); if (out == elem) { return true; } return false; + */ + return false; + } + + public void disconnect() { + } } + class ConnectedElementDynamic extends ConnectedElement { - protected final WeakReference connection; + protected final WeakReference linkedObject; - public ConnectedElementDynamic(final WeakReference connection, final WeakReference reference, final Consumer consumer) { - super(reference, consumer); - this.connection = connection; - } - - public WeakReference getConnection() { - return this.connection; + public ConnectedElementDynamic(Object linkedObject, final Consumer consumer) { + super(consumer); + this.linkedObject = new WeakReference(linkedObject); } @Override - public Object getIfAlive() { - Object out = this.reference.get(); - if (out == null) { + public Consumer getConsumer() { + if (this.linkedObject.get() == null) { return null; } - Object outConnection = this.connection.get(); - if (outConnection == null) { - return null; - } - return out; + return this.consumer.get(); } + @Override public boolean isCompatibleWith(final Object elem) { if (super.isCompatibleWith(elem)) { return true; } - Object outConnection = this.connection.get(); - if (outConnection == elem) { + Object obj = this.linkedObject.get(); + if (obj == elem) { return true; } return false; } - + + @Override + public void disconnect() { + Object obj = this.linkedObject.get(); + if (obj == null) { + return; + } + if (obj instanceof Connection tmp) { + tmp.connectionIsRemovedBySignal(); + } + } } public class Signal implements ConnectionRemoveInterface { List> data = new ArrayList<>(); public void clear() { + List> data2 = data; synchronized(this.data) { this.data = new ArrayList<>(); } + final Iterator> iterator = this.data2.iterator(); + while (iterator.hasNext()) { + final ConnectedElement elem = iterator.next(); + elem.disconnect(); + } } - public void connect(final Object reference, final Consumer function) { + public void connect(final Consumer function) { synchronized(this.data) { - WeakReference weakRef = new WeakReference(reference); - this.data.add(new ConnectedElement(weakRef, function)); + this.data.add(new ConnectedElement(function)); } } - public void disconnect(final Object obj) { +// public void disconnect(final Consumer obj) { +// synchronized(this.data) { +// final Iterator> iterator = this.data.iterator(); +// while (iterator.hasNext()) { +// final ConnectedElement elem = iterator.next(); +// if (elem.isCompatibleWith(obj)) { +// iterator.remove(); +// } +// } +// } +// } + public Connection connectDynamic(final Consumer function) { + Connection out = new Connection(this); synchronized(this.data) { - final Iterator> iterator = this.data.iterator(); - while (iterator.hasNext()) { - final ConnectedElement elem = iterator.next(); - if (elem.isCompatibleWith(obj)) { - iterator.remove(); - } - } - } - } - public Connection connectDynamic(final Object reference, final Consumer function) { - WeakReference weakRef = new WeakReference(reference); - Connection out = new Connection(this); - WeakReference weakConnection = new WeakReference(out); - synchronized(this.data) { - this.data.add(new ConnectedElementDynamic(weakConnection, weakRef, function)); + this.data.add(new ConnectedElementDynamic(out, function)); } return out; } + public void connectAutoRemoveObject(Object reference, final Consumer function) { + synchronized(this.data) { + this.data.add(new ConnectedElementDynamic(reference, function)); + } + } @Override public void disconnect(final Connection connection) { @@ -114,13 +124,13 @@ public class Signal implements ConnectionRemoveInterface { while (iterator.hasNext()) { final ConnectedElement elem = iterator.next(); if (elem.isCompatibleWith(connection)) { + elem.disconnect(); iterator.remove(); } } } } - public void emit(final T value) { List> tmp; // clean the list: @@ -128,8 +138,9 @@ public class Signal implements ConnectionRemoveInterface { final Iterator> iterator = this.data.iterator(); while (iterator.hasNext()) { final ConnectedElement elem = iterator.next(); - Object tmpObject = elem.getIfAlive(); + Object tmpObject = elem.getConsumer(); if (tmpObject == null) { + elem.disconnect(); iterator.remove(); } } @@ -142,14 +153,14 @@ public class Signal implements ConnectionRemoveInterface { } // real call elements { - final Iterator> iterator = tmp.iterator(); + final Iterator> iterator = tmp.iterator(); while (iterator.hasNext()) { final ConnectedElement elem = iterator.next(); - Object tmpObject = elem.getIfAlive(); + Consumer tmpObject = elem.getConsumer(); if (tmpObject == null) { continue; } - elem.getConsumer().accept(value); + tmpObject.accept(value); } } } @@ -157,4 +168,5 @@ public class Signal implements ConnectionRemoveInterface { public int size() { return this.data.size(); } + } diff --git a/test/src/test/atriasoft/esignal/Log.java b/test/src/test/atriasoft/esignal/Log.java new file mode 100644 index 0000000..9d03c58 --- /dev/null +++ b/test/src/test/atriasoft/esignal/Log.java @@ -0,0 +1,59 @@ +package test.atriasoft.esignal; + +import io.scenarium.logger.LogLevel; +import io.scenarium.logger.Logger; + +public class Log { + private static final String LIB_NAME = "esignal-test"; + private static final String LIB_NAME_DRAW = Logger.getDrawableName(LIB_NAME); + private static final boolean PRINT_CRITICAL = Logger.getNeedPrint(LIB_NAME, LogLevel.CRITICAL); + private static final boolean PRINT_ERROR = Logger.getNeedPrint(LIB_NAME, LogLevel.ERROR); + private static final boolean PRINT_WARNING = Logger.getNeedPrint(LIB_NAME, LogLevel.WARNING); + private static final boolean PRINT_INFO = Logger.getNeedPrint(LIB_NAME, LogLevel.INFO); + private static final boolean PRINT_DEBUG = Logger.getNeedPrint(LIB_NAME, LogLevel.DEBUG); + private static final boolean PRINT_VERBOSE = Logger.getNeedPrint(LIB_NAME, LogLevel.VERBOSE); + private static final boolean PRINT_TODO = Logger.getNeedPrint(LIB_NAME, LogLevel.TODO); + private static final boolean PRINT_PRINT = Logger.getNeedPrint(LIB_NAME, LogLevel.PRINT); + + private Log() {} + + public static void print(String data) { + if (PRINT_PRINT) + Logger.print(LIB_NAME_DRAW, data); + } + + public static void critical(String data) { + if (PRINT_CRITICAL) + Logger.critical(LIB_NAME_DRAW, data); + } + + public static void error(String data) { + if (PRINT_ERROR) + Logger.error(LIB_NAME_DRAW, data); + } + + public static void warning(String data) { + if (PRINT_WARNING) + Logger.warning(LIB_NAME_DRAW, data); + } + + public static void info(String data) { + if (PRINT_INFO) + Logger.info(LIB_NAME_DRAW, data); + } + + public static void debug(String data) { + if (PRINT_DEBUG) + Logger.debug(LIB_NAME_DRAW, data); + } + + public static void verbose(String data) { + if (PRINT_VERBOSE) + Logger.verbose(LIB_NAME_DRAW, data); + } + + public static void todo(String data) { + if (PRINT_TODO) + Logger.todo(LIB_NAME_DRAW, data); + } +} diff --git a/test/src/test/atriasoft/esignal/TestSignal.java b/test/src/test/atriasoft/esignal/TestSignal.java new file mode 100644 index 0000000..5761657 --- /dev/null +++ b/test/src/test/atriasoft/esignal/TestSignal.java @@ -0,0 +1,301 @@ +/******************************************************************************* + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at https://mozilla.org/MPL/2.0/. + * + * Contributors: + * Edouard DUPIN - initial API and implementation + ******************************************************************************/ +package test.atriasoft.esignal; + +import static org.junit.jupiter.api.Assertions.assertEquals; + +import java.lang.ref.WeakReference; +import java.util.ArrayList; +import java.util.List; + +import io.scenarium.logger.Logger; + +import org.atriasoft.esignal.Connection; +import org.atriasoft.esignal.Signal; +import org.junit.Test; +import org.junit.jupiter.api.MethodOrderer.OrderAnnotation; +import org.junit.jupiter.api.Order; +//import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.TestMethodOrder; + +@TestMethodOrder(OrderAnnotation.class) +public class TestSignal { + + class EmiterSimple { + public Signal signalEvent = new Signal(); + public void sendEvent(String value) { + signalEvent.emit(value); + } + } + class ReceiverSimple { + private String dataReceive = null; + ReceiverSimple() { + } + public void connect1(EmiterSimple other) { + WeakReference tmpp = new WeakReference(this); + other.signalEvent.connect(data -> { + tmpp.get().onData(data); + }); + } + public void connect2(EmiterSimple other) { + // the solo lambda will not depend on the object => the remove must be done manually... + other.signalEvent.connect(data -> { + Log.error("lambda receive: " + data); + }); + } + public void connect3(EmiterSimple other) { + // we reference the local object, then the lambda is alive while the object is alive... + other.signalEvent.connect(data -> { + Log.error("lambda receive: " + data); + this.dataReceive = data; + }); + } + public void connect4(EmiterSimple other) { + other.signalEvent.connect(data -> { + onData(data); + }); + } + public void connect5(EmiterSimple other) { + other.signalEvent.connect(this::onData); + } +// Does not work at all: +// public void disconnect5(EmiterSimple other) { +// other.signalEvent.disconnect(this::onData); +// } + + public void connect6(EmiterSimple other) { + // the solo lambda will not depend on the object => the remove must be done manually... + other.signalEvent.connectAutoRemoveObject(this, data -> { + Log.error("lambda receive: " + data); + }); + } + private Connection tmpConnect = null; + + public void connect7(EmiterSimple other) { + tmpConnect = other.signalEvent.connectDynamic(this::onData); + } + + public void disconnect7(EmiterSimple other) { + other.signalEvent.disconnect(tmpConnect); + } + + public void disconnect72() { + tmpConnect.disconnect(); + } + public boolean isConnected() { + return tmpConnect.isConnected(); + } + + public void onData(String data) { + Log.error("Retrive data : " + data); + dataReceive = data; + } + public String getDataAndClean() { + String tmp = dataReceive; + dataReceive = null; + return tmp; + } + + } + + @Test + @Order(1) + public void testConnectAndTransmit1() { + Log.warning("Test 1 [BEGIN]"); + EmiterSimple sender = new EmiterSimple(); + ReceiverSimple receiver = new ReceiverSimple(); + receiver.connect1(sender); + assertEquals(1, sender.signalEvent.size()); + String testData1 = "MUST receive this data..."; + sender.sendEvent(testData1); + assertEquals(testData1, receiver.getDataAndClean()); + receiver = null; + assertEquals(1, sender.signalEvent.size()); + System.gc(); + String testData2 = "MUST NOT receive this data..."; + sender.sendEvent(testData2); + assertEquals(0, sender.signalEvent.size()); + Log.warning("Test 1 [ END ]"); + + } + @Test + @Order(2) + public void testConnectAndTransmit2() { + Log.warning("Test 2 [BEGIN]"); + EmiterSimple sender = new EmiterSimple(); + ReceiverSimple receiver = new ReceiverSimple(); + receiver.connect2(sender); + assertEquals(1, sender.signalEvent.size()); + String testData1 = "MUST receive this data..."; + sender.sendEvent(testData1); + // No data stored ... assertEquals(testData1, receiver.getDataAndClean()); + assertEquals(1, sender.signalEvent.size()); + receiver = null; + System.gc(); + String testData2 = "Solo Lambda MUST receive this data..."; + sender.sendEvent(testData2); + assertEquals(1, sender.signalEvent.size()); + Log.warning("Test 2 [ END ]"); + } + + @Test + @Order(3) + public void testConnectAndTransmit3() { + Log.warning("Test 3 [BEGIN]"); + EmiterSimple sender = new EmiterSimple(); + ReceiverSimple receiver = new ReceiverSimple(); + receiver.connect3(sender); + assertEquals(1, sender.signalEvent.size()); + String testData1 = "MUST receive this data..."; + sender.sendEvent(testData1); + assertEquals(testData1, receiver.getDataAndClean()); + assertEquals(1, sender.signalEvent.size()); + receiver = null; + System.gc(); + String testData2 = "MUST NOT receive this data..."; + sender.sendEvent(testData2); + assertEquals(0, sender.signalEvent.size()); + Log.warning("Test 3 [ END ]"); + + } + + @Test + @Order(4) + public void testConnectAndTransmit4() { + Log.warning("Test 4 [BEGIN]"); + EmiterSimple sender = new EmiterSimple(); + ReceiverSimple receiver = new ReceiverSimple(); + receiver.connect4(sender); + assertEquals(1, sender.signalEvent.size()); + String testData1 = "MUST receive this data..."; + sender.sendEvent(testData1); + assertEquals(testData1, receiver.getDataAndClean()); + assertEquals(1, sender.signalEvent.size()); + receiver = null; + System.gc(); + String testData2 = "MUST NOT receive this data..."; + sender.sendEvent(testData2); + assertEquals(0, sender.signalEvent.size()); + Log.warning("Test 4 [ END ]"); + + } + + @Test + @Order(5) + public void testConnectAndTransmit5() { + Log.warning("Test 5 [BEGIN]"); + EmiterSimple sender = new EmiterSimple(); + ReceiverSimple receiver = new ReceiverSimple(); + //connect step 1 + receiver.connect5(sender); + assertEquals(1, sender.signalEvent.size()); + String testData1 = "MUST receive this data... 111"; + sender.sendEvent(testData1); + assertEquals(testData1, receiver.getDataAndClean()); + assertEquals(1, sender.signalEvent.size()); + // remove connection +// receiver.disconnect5(sender); +// assertEquals(0, sender.signalEvent.size()); +// System.gc(); +// String testData2 = "MUST NOT receive this data... 222"; +// sender.sendEvent(testData2); +// assertEquals(null, receiver.getDataAndClean()); +// // reconnect (step 2 +// receiver.connect5(sender); +// assertEquals(1, sender.signalEvent.size()); +// String testData3 = "MUST receive this data... 333"; +// sender.sendEvent(testData3); +// assertEquals(testData3, receiver.getDataAndClean()); +// assertEquals(1, sender.signalEvent.size()); + // check auto remove... + receiver = null; + System.gc(); + String testData4 = "MUST NOT receive this data... 444"; + sender.sendEvent(testData4); + assertEquals(0, sender.signalEvent.size()); + Log.warning("Test 5 [ END ]"); + + } + @Test + @Order(6) + public void testConnectAndTransmit6() { + Log.warning("Test 6 [BEGIN]"); + EmiterSimple sender = new EmiterSimple(); + ReceiverSimple receiver = new ReceiverSimple(); + receiver.connect6(sender); + assertEquals(1, sender.signalEvent.size()); + String testData1 = "MUST receive this data..."; + sender.sendEvent(testData1); + //assertEquals(testData1, receiver.getDataAndClean()); + assertEquals(1, sender.signalEvent.size()); + receiver = null; + System.gc(); + String testData2 = "MUST NOT receive this data..."; + sender.sendEvent(testData2); + assertEquals(0, sender.signalEvent.size()); + Log.warning("Test 6 [ END ]"); + + } + + @Test + @Order(7) + public void testConnectAndTransmit7() { + Log.warning("Test 7 [BEGIN]"); + EmiterSimple sender = new EmiterSimple(); + ReceiverSimple receiver = new ReceiverSimple(); + //connect step 1 + receiver.connect7(sender); + assertEquals(1, sender.signalEvent.size()); + String testData1 = "MUST receive this data... 111"; + sender.sendEvent(testData1); + assertEquals(testData1, receiver.getDataAndClean()); + assertEquals(1, sender.signalEvent.size()); + assertEquals(true, receiver.isConnected()); + // remove connection + receiver.disconnect7(sender); + assertEquals(false, receiver.isConnected()); + System.gc(); + String testData2 = "MUST NOT receive this data... 222"; + sender.sendEvent(testData2); + assertEquals(0, sender.signalEvent.size()); + assertEquals(null, receiver.getDataAndClean()); + // reconnect (step 2 + receiver.connect7(sender); + assertEquals(1, sender.signalEvent.size()); + String testData3 = "MUST receive this data... 333"; + sender.sendEvent(testData3); + assertEquals(testData3, receiver.getDataAndClean()); + assertEquals(1, sender.signalEvent.size()); + assertEquals(true, receiver.isConnected()); + // remove connection + receiver.disconnect72(); + assertEquals(false, receiver.isConnected()); + assertEquals(0, sender.signalEvent.size()); + System.gc(); + String testData4 = "MUST NOT receive this data... 444"; + sender.sendEvent(testData4); + assertEquals(null, receiver.getDataAndClean()); + // reconnect (step 2 + receiver.connect7(sender); + assertEquals(1, sender.signalEvent.size()); + String testData5 = "MUST receive this data... 555"; + sender.sendEvent(testData5); + assertEquals(testData5, receiver.getDataAndClean()); + assertEquals(1, sender.signalEvent.size()); + // check auto remove... + receiver = null; + System.gc(); + String testData6 = "MUST NOT receive this data... 666"; + sender.sendEvent(testData6); + assertEquals(0, sender.signalEvent.size()); + Log.warning("Test 7 [ END ]"); + + } + +} diff --git a/test/src/test/atriasoft/esignal/TestSignalType.java b/test/src/test/atriasoft/esignal/TestSignalType.java new file mode 100644 index 0000000..2612572 --- /dev/null +++ b/test/src/test/atriasoft/esignal/TestSignalType.java @@ -0,0 +1,301 @@ +/******************************************************************************* + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at https://mozilla.org/MPL/2.0/. + * + * Contributors: + * Edouard DUPIN - initial API and implementation + ******************************************************************************/ +package test.atriasoft.esignal; + +import static org.junit.jupiter.api.Assertions.assertEquals; + +import java.lang.ref.WeakReference; +import java.util.ArrayList; +import java.util.List; + +import io.scenarium.logger.Logger; + +import org.atriasoft.esignal.Connection; +import org.atriasoft.esignal.Signal; +import org.junit.Test; +import org.junit.jupiter.api.MethodOrderer.OrderAnnotation; +import org.junit.jupiter.api.Order; +//import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.TestMethodOrder; + +@TestMethodOrder(OrderAnnotation.class) +public class TestSignalType { + + class EmiterSimple { + public Signal signalEvent = new Signal(); + public void sendEvent(String value) { + signalEvent.emit(value); + } + } + class ReceiverSimple { + private String dataReceive = null; + ReceiverSimple() { + } + public void connect1(EmiterSimple other) { + WeakReference tmpp = new WeakReference(this); + other.signalEvent.connect(data -> { + tmpp.get().onData(data); + }); + } + public void connect2(EmiterSimple other) { + // the solo lambda will not depend on the object => the remove must be done manually... + other.signalEvent.connect(data -> { + Log.error("lambda receive: " + data); + }); + } + public void connect3(EmiterSimple other) { + // we reference the local object, then the lambda is alive while the object is alive... + other.signalEvent.connect(data -> { + Log.error("lambda receive: " + data); + this.dataReceive = data; + }); + } + public void connect4(EmiterSimple other) { + other.signalEvent.connect(data -> { + onData(data); + }); + } + public void connect5(EmiterSimple other) { + other.signalEvent.connect(this::onData); + } +// Does not work at all: +// public void disconnect5(EmiterSimple other) { +// other.signalEvent.disconnect(this::onData); +// } + + public void connect6(EmiterSimple other) { + // the solo lambda will not depend on the object => the remove must be done manually... + other.signalEvent.connectAutoRemoveObject(this, data -> { + Log.error("lambda receive: " + data); + }); + } + private Connection tmpConnect = null; + + public void connect7(EmiterSimple other) { + tmpConnect = other.signalEvent.connectDynamic(this::onData); + } + + public void disconnect7(EmiterSimple other) { + other.signalEvent.disconnect(tmpConnect); + } + + public void disconnect72() { + tmpConnect.disconnect(); + } + public boolean isConnected() { + return tmpConnect.isConnected(); + } + + public void onData(String data) { + Log.error("Retrive data : " + data); + dataReceive = data; + } + public String getDataAndClean() { + String tmp = dataReceive; + dataReceive = null; + return tmp; + } + + } + + @Test + @Order(1) + public void testConnectAndTransmit1() { + Log.warning("Test 1 [BEGIN]"); + EmiterSimple sender = new EmiterSimple(); + ReceiverSimple receiver = new ReceiverSimple(); + receiver.connect1(sender); + assertEquals(1, sender.signalEvent.size()); + String testData1 = "MUST receive this data..."; + sender.sendEvent(testData1); + assertEquals(testData1, receiver.getDataAndClean()); + receiver = null; + assertEquals(1, sender.signalEvent.size()); + System.gc(); + String testData2 = "MUST NOT receive this data..."; + sender.sendEvent(testData2); + assertEquals(0, sender.signalEvent.size()); + Log.warning("Test 1 [ END ]"); + + } + @Test + @Order(2) + public void testConnectAndTransmit2() { + Log.warning("Test 2 [BEGIN]"); + EmiterSimple sender = new EmiterSimple(); + ReceiverSimple receiver = new ReceiverSimple(); + receiver.connect2(sender); + assertEquals(1, sender.signalEvent.size()); + String testData1 = "MUST receive this data..."; + sender.sendEvent(testData1); + // No data stored ... assertEquals(testData1, receiver.getDataAndClean()); + assertEquals(1, sender.signalEvent.size()); + receiver = null; + System.gc(); + String testData2 = "Solo Lambda MUST receive this data..."; + sender.sendEvent(testData2); + assertEquals(1, sender.signalEvent.size()); + Log.warning("Test 2 [ END ]"); + } + + @Test + @Order(3) + public void testConnectAndTransmit3() { + Log.warning("Test 3 [BEGIN]"); + EmiterSimple sender = new EmiterSimple(); + ReceiverSimple receiver = new ReceiverSimple(); + receiver.connect3(sender); + assertEquals(1, sender.signalEvent.size()); + String testData1 = "MUST receive this data..."; + sender.sendEvent(testData1); + assertEquals(testData1, receiver.getDataAndClean()); + assertEquals(1, sender.signalEvent.size()); + receiver = null; + System.gc(); + String testData2 = "MUST NOT receive this data..."; + sender.sendEvent(testData2); + assertEquals(0, sender.signalEvent.size()); + Log.warning("Test 3 [ END ]"); + + } + + @Test + @Order(4) + public void testConnectAndTransmit4() { + Log.warning("Test 4 [BEGIN]"); + EmiterSimple sender = new EmiterSimple(); + ReceiverSimple receiver = new ReceiverSimple(); + receiver.connect4(sender); + assertEquals(1, sender.signalEvent.size()); + String testData1 = "MUST receive this data..."; + sender.sendEvent(testData1); + assertEquals(testData1, receiver.getDataAndClean()); + assertEquals(1, sender.signalEvent.size()); + receiver = null; + System.gc(); + String testData2 = "MUST NOT receive this data..."; + sender.sendEvent(testData2); + assertEquals(0, sender.signalEvent.size()); + Log.warning("Test 4 [ END ]"); + + } + + @Test + @Order(5) + public void testConnectAndTransmit5() { + Log.warning("Test 5 [BEGIN]"); + EmiterSimple sender = new EmiterSimple(); + ReceiverSimple receiver = new ReceiverSimple(); + //connect step 1 + receiver.connect5(sender); + assertEquals(1, sender.signalEvent.size()); + String testData1 = "MUST receive this data... 111"; + sender.sendEvent(testData1); + assertEquals(testData1, receiver.getDataAndClean()); + assertEquals(1, sender.signalEvent.size()); + // remove connection +// receiver.disconnect5(sender); +// assertEquals(0, sender.signalEvent.size()); +// System.gc(); +// String testData2 = "MUST NOT receive this data... 222"; +// sender.sendEvent(testData2); +// assertEquals(null, receiver.getDataAndClean()); +// // reconnect (step 2 +// receiver.connect5(sender); +// assertEquals(1, sender.signalEvent.size()); +// String testData3 = "MUST receive this data... 333"; +// sender.sendEvent(testData3); +// assertEquals(testData3, receiver.getDataAndClean()); +// assertEquals(1, sender.signalEvent.size()); + // check auto remove... + receiver = null; + System.gc(); + String testData4 = "MUST NOT receive this data... 444"; + sender.sendEvent(testData4); + assertEquals(0, sender.signalEvent.size()); + Log.warning("Test 5 [ END ]"); + + } + @Test + @Order(6) + public void testConnectAndTransmit6() { + Log.warning("Test 6 [BEGIN]"); + EmiterSimple sender = new EmiterSimple(); + ReceiverSimple receiver = new ReceiverSimple(); + receiver.connect6(sender); + assertEquals(1, sender.signalEvent.size()); + String testData1 = "MUST receive this data..."; + sender.sendEvent(testData1); + //assertEquals(testData1, receiver.getDataAndClean()); + assertEquals(1, sender.signalEvent.size()); + receiver = null; + System.gc(); + String testData2 = "MUST NOT receive this data..."; + sender.sendEvent(testData2); + assertEquals(0, sender.signalEvent.size()); + Log.warning("Test 6 [ END ]"); + + } + + @Test + @Order(7) + public void testConnectAndTransmit7() { + Log.warning("Test 7 [BEGIN]"); + EmiterSimple sender = new EmiterSimple(); + ReceiverSimple receiver = new ReceiverSimple(); + //connect step 1 + receiver.connect7(sender); + assertEquals(1, sender.signalEvent.size()); + String testData1 = "MUST receive this data... 111"; + sender.sendEvent(testData1); + assertEquals(testData1, receiver.getDataAndClean()); + assertEquals(1, sender.signalEvent.size()); + assertEquals(true, receiver.isConnected()); + // remove connection + receiver.disconnect7(sender); + assertEquals(false, receiver.isConnected()); + System.gc(); + String testData2 = "MUST NOT receive this data... 222"; + sender.sendEvent(testData2); + assertEquals(0, sender.signalEvent.size()); + assertEquals(null, receiver.getDataAndClean()); + // reconnect (step 2 + receiver.connect7(sender); + assertEquals(1, sender.signalEvent.size()); + String testData3 = "MUST receive this data... 333"; + sender.sendEvent(testData3); + assertEquals(testData3, receiver.getDataAndClean()); + assertEquals(1, sender.signalEvent.size()); + assertEquals(true, receiver.isConnected()); + // remove connection + receiver.disconnect72(); + assertEquals(false, receiver.isConnected()); + assertEquals(0, sender.signalEvent.size()); + System.gc(); + String testData4 = "MUST NOT receive this data... 444"; + sender.sendEvent(testData4); + assertEquals(null, receiver.getDataAndClean()); + // reconnect (step 2 + receiver.connect7(sender); + assertEquals(1, sender.signalEvent.size()); + String testData5 = "MUST receive this data... 555"; + sender.sendEvent(testData5); + assertEquals(testData5, receiver.getDataAndClean()); + assertEquals(1, sender.signalEvent.size()); + // check auto remove... + receiver = null; + System.gc(); + String testData6 = "MUST NOT receive this data... 666"; + sender.sendEvent(testData6); + assertEquals(0, sender.signalEvent.size()); + Log.warning("Test 7 [ END ]"); + + } + +} diff --git a/test/src/test/atriasoft/ewol/Log.java b/test/src/test/atriasoft/ewol/Log.java index 5c3b329..eb452e1 100644 --- a/test/src/test/atriasoft/ewol/Log.java +++ b/test/src/test/atriasoft/ewol/Log.java @@ -1,4 +1,4 @@ -package test.atriasoft.etk; +package test.atriasoft.ewol; import io.scenarium.logger.LogLevel; import io.scenarium.logger.Logger; diff --git a/test/src/test/atriasoft/ewol/Log2.java b/test/src/test/atriasoft/ewol/Log2.java index 6b57782..4f762c8 100644 --- a/test/src/test/atriasoft/ewol/Log2.java +++ b/test/src/test/atriasoft/ewol/Log2.java @@ -1,4 +1,4 @@ -package test.atriasoft.etk; +package test.atriasoft.ewol; import io.scenarium.logger.LogLevel; import io.scenarium.logger.Logger; diff --git a/test/src/test/atriasoft/ewol/TestBasicLog.java b/test/src/test/atriasoft/ewol/TestBasicLog.java index 6106c2c..7ddceef 100644 --- a/test/src/test/atriasoft/ewol/TestBasicLog.java +++ b/test/src/test/atriasoft/ewol/TestBasicLog.java @@ -6,7 +6,7 @@ * Contributors: * Edouard DUPIN - initial API and implementation ******************************************************************************/ -package test.atriasoft.etk; +package test.atriasoft.ewol; import java.util.ArrayList; import java.util.List;