Ooops bad tag

Merge branch 'main' of github.com:hsaturn/TinyMqtt into main
Version 0.9.6 bump
2022-11-23 13:01:24 +01:00 · 2022-11-23 12:56:35 +01:00 · 2022-11-23 12:54:15 +01:00 · 2022-11-23 12:51:12 +01:00 · 2022-11-21 04:42:30 +01:00 · 2022-11-21 04:42:16 +01:00
35 changed files with 3298 additions and 1194 deletions
--- a/.github/workflows/aunit.yml
+++ b/.github/workflows/aunit.yml
@@ -0,0 +1,34 @@
+# See https://docs.github.com/en/actions/guides for documentation about GitHub
+# Actions.
+
+name: AUnit Tests
+
+# Run on all branches.
+on: [push]
+
+jobs:
+  build:
+
+    runs-on: ubuntu-18.04
+
+    steps:
+    - uses: actions/checkout@v2
+
+    - name: Setup
+      run: |
+        cd ..
+        git clone https://github.com/bxparks/EpoxyDuino
+        git clone https://github.com/bxparks/AceRoutine
+        git clone https://github.com/bxparks/AUnit
+        git clone https://github.com/bxparks/AceCommon
+        git clone https://github.com/hsaturn/EspMock
+    - name: Verify tests
+      run: |
+        # Run tests for ESP8266
+        make -C tests ESP_LIBS="ESP8266WiFi ESPAsyncTCP" tests
+        make -C tests runtests
+        make -C tests clean
+        # Run tests for ESP32
+        #make -C tests ESP_LIBS="ESP8266WiFi ESPAsyncTCP" tests
+        #make -C tests runtests
+        #make -C tests clean
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -0,0 +1,18 @@
+name: "CI"
+on:
+  
+jobs:
+  ci:
+    runs-on: ubuntu-20.04
+    steps:
+    - name: Checkout this repository
+      uses: actions/checkout@v2.3.4
+    - name: Cache for arduino-ci
+      uses: actions/cache@v2.1.3
+      with:
+        path: |
+          ~/.arduino15
+        key: ${{ runner.os }}-arduino
+    - name: Install nix
+      uses: cachix/install-nix-action@v12
+    - run: nix-shell -I nixpkgs=channel:nixpkgs-unstable -p arduino-ci --run "arduino-ci"
--- a/.github/workflows/superlinter.yml
+++ b/.github/workflows/superlinter.yml
@@ -0,0 +1,52 @@
+---
+#################################
+#################################
+## Super Linter GitHub Actions ##
+#################################
+#################################
+name: Lint Code Base
+
+#
+# Documentation:
+# https://docs.github.com/en/actions/learn-github-actions/workflow-syntax-for-github-actions
+#
+
+#############################
+# Start the job on all push #
+#############################
+on: push
+
+###############
+# Set the Job #
+###############
+jobs:
+  build:
+    # Name the Job
+    name: Lint Code Base
+    # Set the agent to run on
+    runs-on: ubuntu-latest
+
+    ##################
+    # Load all steps #
+    ##################
+    steps:
+      ##########################
+      # Checkout the code base #
+      ##########################
+      - name: Checkout Code
+        uses: actions/checkout@v3
+        with:
+          # Full git history is needed to get a proper
+          # list of changed files within `super-linter`
+          fetch-depth: 0
+
+      ################################
+      # Run Linter against code base #
+      ################################
+      - name: Lint Code Base
+        uses: github/super-linter/slim@v4
+        env:
+          VALIDATE_ALL_CODEBASE: false
+          # Change to 'master' if your main branch differs
+          DEFAULT_BRANCH: main
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
--- a/.gitignore
+++ b/.gitignore
@@ -1,2 +0,0 @@
-*~
-src/my_credentials.h
--- a/README.md
+++ b/README.md
@@ -1,66 +1,77 @@
 # TinyMqtt

-![](https://img.shields.io/github/v/release/hsaturn/TinyMqtt)
-![](https://img.shields.io/github/issues/hsaturn/TinyMqtt)
-![](https://img.shields.io/badge/platform-ESP8266-green)
-![](https://img.shields.io/github/license/hsaturn/TinyMqtt)
-![](https://img.shields.io/badge/Mqtt-%203.1.1-yellow)
+[![Release](https://img.shields.io/github/v/release/hsaturn/TinyMqtt)](https://github.com/hsaturn/TinyMqtt/releases)
+[![AUnit Tests](https://github.com/hsaturn/TinyMqtt/actions/workflows/aunit.yml/badge.svg)](https://github.com/hsaturn/TinyMqtt/actions/workflows/aunit.yml)
+[![Issues](https://img.shields.io/github/issues/hsaturn/TinyMqtt)](https://github.com/hsaturn/TinyMqtt/issues)
+[![Esp8266](https://img.shields.io/badge/platform-ESP8266-green)](https://www.espressif.com/en/products/socs/esp8266)
+[![Esp32](https://img.shields.io/badge/platform-ESP32-green)](https://www.espressif.com/en/products/socs/esp32)
+[![Gpl 3.0](https://img.shields.io/github/license/hsaturn/TinyMqtt)](https://www.gnu.org/licenses/gpl-3.0.fr.html)
+[![Mqtt 3.1.1](https://img.shields.io/badge/Mqtt-%203.1.1-yellow)](https://docs.oasis-open.org/mqtt/mqtt/v3.1.1/errata01/os/mqtt-v3.1.1-errata01-os-complete.html#_Toc442180822)

-ESP 8266 is a small, fast and capable Mqtt Broker and Client
+TinyMqtt is a small, fast and capable Mqtt Broker and Client for Esp8266 / Esp32 / Esp WROOM

 ## Features

- Very (very !!) fast broker I saw it re-sent 1000 topics per second for two
-  clients that had subscribed (payload ~15 bytes). No topic lost.
+- Very fast broker I saw it re-sent 1000 topics per second for two
+  clients that had subscribed (payload ~15 bytes ESP8266). No topic lost.
  The max I've seen was 2k msg/s (1 client 1 subscription)
 - Act as as a mqtt broker and/or a mqtt client
 - Mqtt 3.1.1 / Qos 0 supported
+- Wildcards supported (+ # $ and * (even if not part of the spec...))
 - Standalone (can work without WiFi) (degraded/local mode)
 - Brokers can connect to another broker and becomes then a
  proxy for clients that are connected to it.
 - zeroconf, this is a strange but very powerful mode where
  all brokers tries to connect together on the same local network.
+- small memory footprint (very efficient topic storage)
+- long messages are supported (>127 bytes)
+- TinyMQTT is largely unit tested, so once a bug is fixed, it is fixed forever

-## TODO List
-* Use [Async library](https://github.com/me-no-dev/ESPAsyncTCP)
-* Implement zeroconf mode (needs async)
-* Add a max_clients in MqttBroker. Used with zeroconf, there will be
-no need for having tons of clients (also RAM is the problem with many clients)
-* Test what is the real max number of clients for broker. As far as I saw, 1k is needed per client which would make more than 30 clients critical.
-* ~~MqttMessage uses a buffer 256 bytes which is usually far than needed.~~
-* ~~MqttClient does not support more than one subscription at time~~
-* ~~MqttClient auto re-subscribe (::resubscribe works bad on broker.emqx.io)~~
-* MqttClient auto reconnection
-* ~~MqttClient unsubscribe~~
-* MqttClient does not sent payload to callback...
-* MqttClient user/password
-* Wildcards (I may implement only # as I'm not interrested by a clever and cpu consuming matching)
+## Limitations
+
+- Max of 255 different topics can be stored (change index_t type to allow more)
+- No Qos because messages are not queued but immediately sent to clients

 ## Quickstart

 * install [TinyMqtt library](https://github.com/hsaturn/TinyMqtt)
+  (you can use the Arduino library manager and search for TinyMqtt)
 * modify <libraries/TinyMqtt/src/my_credentials.h> (wifi setup)

 ## Examples

-
 | Example             | Description                                |
-| ---------------------------- | --------------------------------- |
-| client-without-wifi | standalone example                         |
-| simple-client       | Connect the ESP to an external Mqtt broker |
-| simple-broker       | Simple Mqtt broker with your ESP           |
-| tinymqtt-test       | Complex console example                    |
+| ------------------- | ------------------------------------------ |
+| [client-with-wifi](https://github.com/hsaturn/TinyMqtt/tree/main/examples/client-with-wifi/client-with-wifi.ino) | standalone example                         |
+| [client-without-wifi](https://github.com/hsaturn/TinyMqtt/tree/main/examples/client-without-wifi/client-without-wifi.ino) | standalone example                         |
+| [simple-client](https://github.com/hsaturn/TinyMqtt/tree/main/examples/simple-client/simple-client.ino)       | Connect the ESP to an external Mqtt broker |
+| [simple-broker](https://github.com/hsaturn/TinyMqtt/tree/main/examples/simple-broker/simple-broker.ino)       | Simple Mqtt broker with your ESP           |
+| [tinymqtt-test](https://github.com/hsaturn/TinyMqtt/tree/main/examples/tinymqtt-test/tinymqtt-test.ino)       | Complex console example                    |

 - tinymqtt-test : This is a complex sketch with a terminal console
  that allows to add clients publish, connect etc with interpreted commands.

 ## Standalone mode (zeroconf)
 -> The zeroconf mode is not yet implemented
-zerofonf clients to connect to broker on local network.
+zeroconf clients to connect to broker on local network.

 In Zeroconf mode, each ESP is a a broker and scans the local network.
 After a while one ESP naturally becomes a 'master' and all ESP are connected together.
 No problem if the master dies, a new master will be choosen soon.

+## TODO List
+* ~~Use [Async library](https://github.com/me-no-dev/ESPAsyncTCP)~~
+* Implement zeroconf mode (needs async)
+* Add a max_clients in MqttBroker. Used with zeroconf, there will be
+no need for having tons of clients (also RAM is the problem with many clients)
+* Why not a 'global' TinyMqtt::loop() instead of having to call loop for all broker/clients instances
+* Test what is the real max number of clients for broker. As far as I saw, 1k is needed per client which would make more than 30 clients critical.
+* ~~MqttClient auto re-subscribe (::resubscribe works bad on broker.emqx.io)~~
+* MqttClient auto reconnection
+* MqttClient user/password
+* ~~Wildcards (I may implement only # as I'm not interrested by a clever and cpu consuming matching)~~
+* I suspect that MqttClient::parent could be removed and replaced with a simple boolean
+  (this'll need to rewrite a few functions)
+
 ## License
 Gnu GPL 3.0, see [LICENSE](https://github.com/hsaturn/TinyMqtt/blob/main/LICENSE).
--- a/examples/client-with-wifi/client-with-wifi.ino
+++ b/examples/client-with-wifi/client-with-wifi.ino
@@ -3,6 +3,23 @@
 /** 
  * Local broker that accept connections and two local clients
  *
+  * 
+  *  +-----------------------------+
+  *  | ESP                         |
+  *  |                 +--------+  | 1883 <--- External client/s
+  *  |       +-------->| broker |  | 1883 <--- External client/s
+  *  |       |         +--------+  |
+  *  |       |             ^       |
+  *  |       |             |       |
+  *  |       |             |       |     -----
+  *  |       v             v       |      ---  
+  *  | +----------+  +----------+  |       -  
+  *  | | internal |  | internal |  +-------*  Wifi
+  *  | | client   |  | client   |  |          
+  *  | +----------+  +----------+  |          
+  *  |                             |
+  *  +-----------------------------+
+  * 
  * pros - Reduces internal latency (when publish is received by the same ESP)
  *      - Reduces wifi traffic
  *      - No need to have an external broker
@@ -12,14 +29,10 @@
  * cons - Takes more memory
  *      - a bit hard to understand
  *
-  * This sounds crazy: a mqtt mqtt that do not need a broker !
-  *  The use case arise when one ESP wants to publish topics and subscribe to them at the same time.
-  *  Without broker, the ESP won't react to its own topics.
-  *  
-  *  TinyMqtt mqtt allows this use case to work.
  */

-#include <my_credentials.h>
+const char *ssid     = "";
+const char *password = "";

 std::string topic="sensor/temperature";

@@ -28,11 +41,11 @@ MqttBroker broker(1883);
 MqttClient mqtt_a(&broker);
 MqttClient mqtt_b(&broker);

-void onPublishA(const MqttClient* source, const Topic& topic, const char* payload, size_t length)
-{ Serial << endl << "---------> A Received " << topic.c_str() << endl; }
+void onPublishA(const MqttClient* /* source */, const Topic& topic, const char* payload, size_t /* length */)
+{ Serial << "--> client A received " << topic.c_str() << ", " << payload << endl; }

-void onPublishB(const MqttClient* source, const Topic& topic, const char* payload, size_t length)
-{ Serial << endl << "---------> B Received " << topic.c_str() << endl; }
+void onPublishB(const MqttClient* /* source */, const Topic& topic, const char* payload, size_t /* length */)
+{ Serial << "--> client B Received " << topic.c_str() << ", " << payload << endl; }

 void setup()
 {
@@ -40,6 +53,9 @@ void setup()
  delay(500);
  Serial << "Clients with wifi " << endl;

+	if (strlen(ssid)==0)
+		Serial << "****** PLEASE EDIT THE EXAMPLE AND MODIFY ssid/password *************" << endl;
+
  WiFi.mode(WIFI_STA);
  WiFi.begin(ssid, password);

@@ -58,20 +74,20 @@ void setup()

 void loop()
 {
-	broker.loop();
+  broker.loop();  // Don't forget to add loop for every broker and clients

  mqtt_a.loop();
  mqtt_b.loop();

  // ============= client A publish ================
-	static const int intervalA = 5000;  // publishes every 5s
+  static const int intervalA = 5000;  // publishes every 5s (please avoid usage of delay())
  static uint32_t timerA = millis() + intervalA;

  if (millis() > timerA)
  {
    Serial << "A is publishing " << topic.c_str() << endl;
    timerA += intervalA;
-		mqtt_a.publish(topic);
+    mqtt_a.publish(topic, " sent by A");
  }

  // ============= client B publish ================
@@ -80,8 +96,9 @@ void loop()

  if (millis() > timerB)
  {
+		static int temperature;
    Serial << "B is publishing " << topic.c_str() << endl;
    timerB += intervalB;
-		mqtt_b.publish(topic, std::string(String(15+millis()%10).c_str()));
+    mqtt_b.publish(topic, " sent by B: "+std::string(String(16+temperature++%6).c_str()));
  }
 }
--- a/examples/client-without-wifi/client-without-wifi.ino
+++ b/examples/client-without-wifi/client-without-wifi.ino
@@ -1,11 +1,29 @@
 #include <TinyMqtt.h>   // https://github.com/hsaturn/TinyMqtt

 /** TinyMQTT allows a disconnected mode:
+  * 
+  *  +-----------------------------+
+  *  | ESP                         |
+  *  |                 +--------+  |
+  *  |       +-------->| broker |  |
+  *  |       |         +--------+  |
+  *  |       |             ^       |
+  *  |       |             |       |
+  *  |       v             v       |
+  *  | +----------+  +----------+  |
+  *  | | internal |  | internal |  |
+  *  | | client   |  | client   |  |          
+  *  | +----------+  +----------+  |          
+  *  |                             |
+  *  +-----------------------------+
  *
  *  In this example, local clients A and B are talking together, no need to be connected.
+  *
  *  A single ESP can use this to be able to comunicate with itself with the power
  *  of MQTT, and once connected still continue to work with others.
  *
+  *  The broker may still be conected if wifi is on.
+  *
  */

 std::string topic="sensor/temperature";
@@ -14,11 +32,11 @@ MqttBroker broker(1883);
 MqttClient mqtt_a(&broker);
 MqttClient mqtt_b(&broker);

-void onPublishA(const MqttClient* srce, const Topic& topic, const char* payload, size_t length)
-{ Serial << "--> A Received " << topic.c_str() << endl; }
+void onPublishA(const MqttClient* /* srce */, const Topic& topic, const char* payload, size_t /* length */)
+{ Serial << "--> Client A received msg on topic " << topic.c_str() << ", " << payload << endl; }

-void onPublishB(const MqttClient* srce, const Topic& topic, const char* payload, size_t length)
-{ Serial << "--> B Received " << topic.c_str() << endl; }
+void onPublishB(const MqttClient* /* srce */, const Topic& topic, const char* payload, size_t /* length */)
+{ Serial << "--> Client B received msg on topic " << topic.c_str() << ", " << payload << endl; }

 void setup()
 {
@@ -35,7 +53,7 @@ void setup()

 void loop()
 {
-	broker.loop();
+	broker.loop();	// Don't forget to call loop() for all brokers and clients
  mqtt_a.loop();
  mqtt_b.loop();

@@ -47,7 +65,7 @@ void loop()
 	{
 		Serial << "A is publishing " << topic.c_str() << endl;
 		timerA += intervalA;
-		mqtt_a.publish(topic);
+		mqtt_a.publish(topic, "sent by A");
 	}

  // ============= client B publish ================
@@ -58,6 +76,6 @@ void loop()
 	{
 		Serial << "B is publishing " << topic.c_str() << endl;
 		timerB += intervalB;
-		mqtt_b.publish(topic);
+		mqtt_b.publish(topic, "sent by B");
 	}
 }
--- a/examples/simple-broker/simple-broker.ino
+++ b/examples/simple-broker/simple-broker.ino
@@ -1,14 +1,33 @@
 #include "TinyMqtt.h"   // https://github.com/hsaturn/TinyMqtt

-#include <my_credentials.h>
-
 #define PORT 1883
 MqttBroker broker(PORT);

+/** Basic Mqtt Broker
+  *
+  *  +-----------------------------+
+  *  | ESP                         |
+  *  |       +--------+            | 
+  *  |       | broker |            | 1883 <--- External client/s
+  *  |       +--------+            |
+  *  |                             |
+  *  +-----------------------------+
+  *
+  *  Your ESP will become a MqttBroker.
+	*  You can test it with any client such as mqtt-spy for example
+	*  
+  */
+
+const char* ssid = "";
+const char* password = "";
+
 void setup() 
 {
  Serial.begin(115200);

+	if (strlen(ssid)==0)
+		Serial << "****** PLEASE MODIFY ssid/password *************" << endl;
+
  WiFi.mode(WIFI_STA);
  WiFi.begin(ssid, password);
 
--- a/examples/simple-client/simple-client.ino
+++ b/examples/simple-client/simple-client.ino
@@ -1,9 +1,25 @@
-#include <ESP8266WiFi.h>
 #include "TinyMqtt.h"   // https://github.com/hsaturn/TinyMqtt

-/** Simple Client
+/** Simple Client (The simplest configuration)
  *
-	* This is the simplest Mqtt client configuration
+  *                             
+  *                   +--------+       
+  *           +------>| broker |<--- <  Other client
+  *           |       +--------+       
+  *           |                               
+  *   +-----------------+
+  *   | ESP   |         |           
+  *   | +----------+    |          
+  *   | | internal |    |              
+  *   | | client   |    |          
+  *   | +----------+    |          
+  *   |                 |
+  *   +-----------------+
+  * 
+	* 1 - change the ssid/password
+	* 2 - change BROKER values (or keep emqx.io test broker)
+	* 3 - you can use mqtt-spy to connect to the same broker and
+	*     see the sensor/temperature updated by the client.
 	*
 	* pro  - small memory footprint (both ram and flash)
 	*      - very simple to setup and use
@@ -13,7 +29,11 @@
 	*      - local publishes takes more time (because they go outside)
 	*/

-#include <my_credentials.h>
+const char* BROKER = "broker.emqx.io";
+const uint16_t BROKER_PORT = 1883;
+
+const char* ssid = "";
+const char* password = "";

 static float temp=19;
 static MqttClient client;
@@ -22,7 +42,10 @@ void setup()
 {
  Serial.begin(115200);
 	delay(500);
+
 	Serial << "Simple clients with wifi " << endl;
+	if (strlen(ssid)==0)
+		Serial << "****** PLEASE MODIFY ssid/password *************" << endl;

  WiFi.mode(WIFI_STA);
  WiFi.begin(ssid, password);
@@ -32,21 +55,33 @@ void setup()

  Serial << "Connected to " << ssid << "IP address: " << WiFi.localIP() << endl;  

-	client.connect("192.168.1.40", 1883);	// Put here your broker ip / port
-
+	client.connect(BROKER, BROKER_PORT);	// Put here your broker ip / port
 }

 void loop()
 {
-	client.loop();
+	client.loop();	// Don't forget to call loop() for each broker and client

-	delay(1000);
+	// delay(1000);		please avoid usage of delay (see below how this done using next_send and millis())
+	static auto next_send = millis();
+	
+	if (millis() > next_send)
+	{
+		next_send += 1000;
+
+		if (not client.connected())
+		{
+			Serial << millis() << ": Not connected to broker" << endl;
+			return;
+		}

 		auto rnd=random(100);

 		if (rnd > 66) temp += 0.1;
 		else if (rnd < 33) temp -= 0.1;

-	client.publish("sensor/temperature", String(temp));
+		Serial << "--> Publishing a new sensor/temperature value: " << temp << endl;

+		client.publish("sensor/temperature", String(temp));
+	}
 }
--- a/examples/tinymqtt-test/tinymqtt-test.ino
+++ b/examples/tinymqtt-test/tinymqtt-test.ino
@@ -1,81 +1,164 @@
+// vim: ts=2 sw=2
 #define TINY_MQTT_DEBUG
 #include <TinyMqtt.h>       // https://github.com/hsaturn/TinyMqtt
 #include <MqttStreaming.h>
+#if defined(ESP8266)
+  #include <ESP8266mDNS.h>
+#elif defined(ESP32)
+  #include <WiFi.h>
+  #include <ESPmDNS.h>
+#else
+  #error Unsupported platform
+#endif
+
 #include <sstream>
 #include <map>

-/** 
-  * Console allowing to make any kind of test.
+bool echo_on = true;
+
+/** Very complex example
+  * Console allowing to make any kind of test,
+	* even some stress tests.
  *
-  * pros - Reduces internal latency (when publish is received by the same ESP)
-  *      - Reduces wifi traffic
-  *      - No need to have an external broker
-	*      - can still report to a 'main' broker (TODO see documentation that have to be written)
-	*      - accepts external clients
+	* Upload the sketch, the use the terminal.
+	* Press H for mini help.
 	*
-  * cons - Takes more memory
-	*      - a bit hard to understand
-	*
-  * This sounds crazy: a mqtt mqtt that do not need a broker !
-  *  The use case arise when one ESP wants to publish topics and subscribe to them at the same time.
-  *  Without broker, the ESP won't react to its own topics.
-  *  
-  *  TinyMqtt mqtt allows this use case to work.
+  * tested with mqtt-spy-0.5.4
+	* TODO examples of scripts
  */

-#include <my_credentials.h>
+const char* ssid = "";
+const char* password = "";

 std::string topic="sensor/temperature";

 void onPublish(const MqttClient* srce, const Topic& topic, const char* payload, size_t length)
-{ Serial << "--> " << srce->id().c_str() << ": ======> received " << topic.c_str() << endl; }
+{
+	Serial << "--> " << srce->id().c_str() << ": ======> received " << topic.c_str();
+	if (payload)
+	{
+		Serial << ", payload[" << length << "]=[";
+		while(length--)
+		{
+			const char c=*payload++;
+			if (c<32)
+				Serial << '?';
+			else
+				Serial << c;
+		}
+		Serial << ']' << endl;
+	}
+}

 std::map<std::string, MqttClient*> clients;
 std::map<std::string, MqttBroker*> brokers;

-
 void setup()
 {
+	WiFi.persistent(false); // https://github.com/esp8266/Arduino/issues/1054
  Serial.begin(115200);
 	delay(500);
-	Serial << endl << endl << endl
-	<< "Demo started. Type help for more..." << endl
-	<< "Connecting to '" << ssid << "' ";

+  Serial << endl << endl;
+  Serial << "***************************************************************" << endl;
+  Serial << "*  Welcome to the TinyMqtt console" << endl;
+  Serial << endl;
+  Serial << "*  The console allows to test all features of the libraries." << endl;
+  Serial << endl;
+  if (strlen(ssid)==0)
+    Serial << "*  WARNING: You may want to modify ssid/password in order" << endl
+		       << "            to reflect your Wifi configuration." << endl;
+  Serial << endl;
+	Serial << "*  Enter help to view the list of commands." << endl;
+  Serial << "***************************************************************" << endl;
+  Serial << endl;
+
+	Serial << "Connecting to '" << ssid << "' ";
+
+  WiFi.mode(WIFI_STA);
+  WiFi.begin(ssid, password);
  WiFi.mode(WIFI_STA);
  WiFi.begin(ssid, password);

  while (WiFi.status() != WL_CONNECTED)
  { Serial << '-'; delay(500); }

-  Serial << "Connected to " << ssid << "IP address: " << WiFi.localIP() << endl;
+  Serial << endl << "Connected to " << ssid << "IP address: " << WiFi.localIP() << endl;
+
+  const char* name="tinytest";
+  Serial << "Starting MDNS, name= " << name;
+  if (!MDNS.begin(name))
+    Serial << "  error, not available." << endl;
+  else
+    Serial << " ok." << endl;
+

 	MqttBroker* broker = new MqttBroker(1883);
 	broker->begin();
 	brokers["broker"] = broker;
 }

+std::string getword(std::string& str, const char* if_empty=nullptr, char sep=' ');
+
 int getint(std::string& str, const int if_empty=0)
 {
-	std::string sword;
-	while(str.length() && str[0]>='0' && str[0]<='9')
+	std::string str2=str;
+	std::string sword = getword(str);
+	if (sword[0] and isdigit(sword[0]))
 	{
-		sword += str[0]; str.erase(0,1);
+		int ret=atoi(sword.c_str());
+		while(isdigit(sword[0]) or sword[0]==' ') sword.erase(0,1);
+		if (sword.length()) str = sword+' '+str;
+	  return ret;
 	}
-	while(str[0]==' ') str.erase(0,1);
-	if (if_empty and sword.length()==0) return if_empty;
-	return atoi(sword.c_str());
+	str=str2;
+  return if_empty;
 }

-std::string getword(std::string& str, const char* if_empty=nullptr, char sep=' ')
+std::string getword(std::string& str, const char* if_empty/*=nullptr*/, char sep/*=' '*/)
 {
+	char quote=(str[0]=='"' or str[0]=='\'' ? str[0] : 0);
+	if (quote) str.erase(0,1);
 	std::string sword;
-	while(str.length() && str[0]!=sep)
+	while(str.length() and (str[0]!=sep or quote))
 	{
-		sword += str[0]; str.erase(0,1);
+		if (str[0]==quote)
+		{
+			str.erase(0,1);
+			break;
+		}
+		sword += str[0];
+		str.erase(0,1);
 	}
 	while(str[0]==sep) str.erase(0,1);
 	if (if_empty and sword.length()==0) return if_empty;
+	if (quote==false and sword.length()>=4 and sword.substr(0,3)=="rnd")
+	{
+		sword.erase(0,3);
+		if (sword[0]=='(')
+		{
+			int to = 100;
+			sword.erase(0,1);
+			int from=getint(sword);
+			if (sword[0]==',')
+			{
+				sword.erase(0,1);
+				to = getint(sword);
+				if (sword[0]!=')') Serial << "Missing ')'" << endl;
+			}
+			else
+			{
+				to=from;
+				from=0;
+			}
+			return String(random(from,to)).c_str();
+		}
+		else
+		{
+			Serial << "Missing '('" << endl;
+		}
+	}
+	while(str[0]==' ') str.erase(0,1);
 	return sword;
 }

@@ -92,7 +175,6 @@ std::string getip(std::string& str, const char* if_empty=nullptr, char sep=' ')
 	std::string addr=getword(str, if_empty, sep);
 	std::string ip=addr;
 	std::vector<std::string> build;
-	bool ok=true;
 	while(ip.length())
 	{
 		std::string b=getword(ip,nullptr,'.');
@@ -104,7 +186,7 @@ std::string getip(std::string& str, const char* if_empty=nullptr, char sep=' ')
 			return addr;
 	}
 	IPAddress local=WiFi.localIP();
-	addr="";
+	addr.clear();
 	while(build.size()!=4)
 	{
 		std::stringstream b;
@@ -122,13 +204,13 @@ std::string getip(std::string& str, const char* if_empty=nullptr, char sep=' ')
 std::map<std::string, std::string> vars;

 std::set<std::string> commands = {
-	"auto", "broker", "client", "connect",
+	"auto", "broker", "blink", "client", "connect",
 	"create", "delete", "help", "interval",
 	"ls", "ip", "off", "on", "set",
-	"publish", "reset", "subscribe", "view"
+	"publish", "reset", "subscribe", "unsubscribe", "view", "echo", "every"
 };

-void getCommand(std::string& search)
+void convertToCommand(std::string& search)
 {
 	while(search[0]==' ') search.erase(0,1);
 	if (search.length()==0) return;
@@ -148,7 +230,7 @@ void getCommand(std::string& search)
 	else if (count>1)
 	{
 		Serial << "Ambiguous command: " << matches << endl;
-		search="";
+		search.clear();
 	}
 }

@@ -164,7 +246,7 @@ void replace(const char* d, std::string& str, std::string srch, std::string to)
 		{
 			str.erase(pos, srch.length());
 			str.insert(pos, to);
-			pos += to.length();
+			pos += to.length()-1;
 		}
 	}
 }
@@ -182,6 +264,7 @@ void replaceVars(std::string& cmd)
 	}
 	cmd.erase(0, cmd.find_first_not_of(" "));
 	cmd.erase(cmd.find_last_not_of(" ")+1);
+
 }

 // publish at regular interval
@@ -303,44 +386,47 @@ std::map<MqttClient*, automatic*> automatic::autos;

 bool compare(std::string s, const char* cmd)
 {
-	if (s.length()==0 or s.length()>strlen(cmd))  return false;
-	return strncmp(cmd, s.c_str(), s.length())==0;
+	uint8_t p=0;
+	while(s[p++]==*cmd++)
+	{
+		if (*cmd==0 or s[p]==0) return true;
+		if (s[p]==' ') return true;
+	}
+	return false;
 }

 using ClientFunction = void(*)(std::string& cmd, MqttClient* publish);

-void loop()
+struct Every
 {
-	static long count;
-	if (MqttClient::counter != count)
+	std::string cmd;
+	uint32_t ms;
+	uint32_t next;
+	uint32_t underrun=0;
+	bool active=true;
+
+	void dump()
 	{
-		Serial << "# " << MqttClient::counter << endl;
-		count = MqttClient::counter;
-	}
-	for(auto it: brokers)
-		it.second->loop();
-
-	for(auto it: clients)
-		it.second->loop();
-
-	automatic::loop();
-
-	if (Serial.available())
-	{
-		static std::string cmd;
-		char c=Serial.read();
-
-		if (c==10 or c==14)
-		{
-
-			Serial << "----------------[ " << cmd.c_str() << " ]--------------" << endl;
-			static std::string last_cmd;
-			if (cmd=="!")
-				cmd=last_cmd;
+		Serial << (active ? "enabled  " : "disabled ");
+		auto mill=millis();
+		Serial << ms << "ms [" << cmd << "] next in ";
+		if (mill > next)
+			Serial << "now";
 		else
-				last_cmd=cmd;
+			Serial << next-mill << "ms";
+	}
+};

-			if (cmd.substr(0,3)!="set") replaceVars(cmd);
+uint32_t blink_ms_on[16];
+uint32_t blink_ms_off[16];
+uint32_t blink_next[16];
+bool blink_state[16];
+int16_t blink;
+
+std::vector<Every> everies;
+
+void eval(std::string& cmd)
+{
 	while(cmd.length())
 	{
 		MqttError retval = MqttOk;
@@ -350,7 +436,6 @@ void loop()
 		MqttClient* client = nullptr;

 		// client.function notation
-				// ("a.fun " becomes "fun a ")
 		if (cmd.find('.') != std::string::npos &&
 				cmd.find('.') < cmd.find(' '))
 		{
@@ -369,13 +454,13 @@ void loop()
 				else
 				{
 					Serial << "Unknown class (" << s.c_str() << ")" << endl;
-							cmd="";
+					cmd.clear();
 				}
 			}
 		}

 		s = getword(cmd);
-				if (s.length()) getCommand(s);
+		if (s.length()) convertToCommand(s);
 		if (s.length()==0)
 		{}
 		else if (compare(s, "delete"))
@@ -396,11 +481,11 @@ void loop()
 			}
 			if (client)
 			{
-						clients.erase(s);
 				for (auto it: clients)
 				{
 					if (it.second != client) continue;
 					Serial << "deleted" << endl;
+					delete (it.second);
 					clients.erase(it.first);
 					break;
 				}
@@ -410,9 +495,9 @@ void loop()
 			{
 				for(auto it: brokers)
 				{
-							Serial << (int32_t)it.second << '/' << (int32_t)broker << endl;
 					if (broker != it.second) continue;
 					Serial << "deleted" << endl;
+					delete (it.second);
 					brokers.erase(it.first);
 					break;
 				}
@@ -431,6 +516,11 @@ void loop()
 			{
 				broker->dump();
 			}
+			else
+			{
+				Serial << "Unknown broker command (" << s << ")" << endl;
+				s.clear();
+			}
 		}
 		else if (client)
 		{
@@ -441,18 +531,145 @@ void loop()
 			}
 			else if (compare(s,"publish"))
 			{
-						while (cmd[0]==' ') cmd.erase(0,1);
-						retval = client->publish(getword(cmd, topic.c_str()), cmd.c_str(), cmd.length());
-						cmd="";	// remove payload
+				retval = client->publish(getword(cmd, topic.c_str()), getword(cmd));
 			}
 			else if (compare(s,"subscribe"))
 			{
 				client->subscribe(getword(cmd, topic.c_str()));
 			}
+			else if (compare(s, "unsubscribe"))
+			{
+				client->unsubscribe(getword(cmd, topic.c_str()));
+			}
 			else if (compare(s, "view"))
 			{
 				client->dump();
 			}
+			else
+			{
+				Serial << "Unknown client command (" << s << ")" << endl;
+				s.clear();
+			}
+		}
+		else if (compare(s, "on"))
+		{
+			uint8_t pin=getint(cmd, 2);
+			pinMode(pin, OUTPUT);
+			digitalWrite(pin, HIGH);
+		}
+		else if (compare(s, "off"))
+		{
+			uint8_t pin=getint(cmd, 2);
+			pinMode(pin, OUTPUT);
+			digitalWrite(pin, LOW);
+		}
+		else if (compare(s, "echo"))
+		{
+			s=getword(cmd);
+			if (s=="on")
+				echo_on = true;
+			else if (s=="off")
+				echo_on = false;
+			else
+			{
+				Serial << s << ' ';
+				while(cmd.length())
+				{
+					Serial << getword(cmd) << ' ';
+				}
+			}
+		}
+		else if (compare(s, "every"))
+		{
+			uint32_t ms = getint(cmd, 0);
+			if (ms)
+			{
+				if (cmd.length())
+				{
+					Every every;
+					every.ms=ms;
+					every.cmd=cmd;
+					every.next=millis()+ms;
+					everies.push_back(every);
+					every.dump();
+					Serial << endl;
+					cmd.clear();
+				}
+			}
+			else if (compare(cmd, "off") or compare(cmd, "on"))
+			{
+				bool active=getword(cmd)=="on";
+				uint8_t ever=getint(cmd, 100);
+				uint8_t count=0;
+				for(auto& every: everies)
+				{
+					if (count==ever or (ever==100))
+					{
+						if (every.active != active)
+						{
+							Serial << "every #" << count << (active ? " on" :" off") << endl;
+							every.active = active;
+							every.underrun = 0;
+						}
+					}
+					count++;
+				}
+			}
+			else if (compare(cmd, "list") or cmd.length()==0)
+			{
+				getword(cmd);
+				Serial << "List of everies (ms=" << millis() << ")" << endl;
+				uint8_t count=0;
+				for(auto& every: everies)
+				{
+					Serial << count << ": ";
+					every.dump();
+					Serial << endl;
+					count++;
+				}
+			}
+			else if (compare(cmd, "remove"))
+			{
+				Serial << "Removing..." << endl;
+				getword(cmd);
+				int8_t every=getint(cmd, -1);
+				if (every==-1 and compare(cmd, "last") and everies.size())
+				{
+					getword(cmd);
+					everies.erase(everies.begin()+everies.size()-1);
+				}
+				else if (every==-1 and compare(cmd, "all"))
+				{
+					getword(cmd);
+					everies.clear();
+				}
+				else if (everies.size() > (uint8_t)every)
+				{
+					everies.erase(everies.begin()+every);
+				}
+				else
+					Serial << "Bad colmmand" << endl;
+			}
+			else
+				Serial << "Bad command" << endl;
+		}
+		else if (compare(s, "blink"))
+		{
+			int8_t blink_nr = getint(cmd, -1);
+			if (blink_nr >= 0)
+			{
+				blink_ms_on[blink_nr]=getint(cmd, blink_ms_on[blink_nr]);
+				blink_ms_off[blink_nr]=getint(cmd, blink_ms_on[blink_nr]);
+				pinMode(blink_nr, OUTPUT);
+				blink_next[blink_nr] = millis();
+				Serial << "Blink " << blink_nr << ' ' << (blink_ms_on[blink_nr] ? "on" : "off") << endl;
+				if (blink_ms_on[blink_nr])
+					blink |= 1<< blink_nr;
+				else
+				{
+					blink &= ~(1<< blink_nr);
+				}
+			}
 		}
 		else if (compare(s, "auto"))
 		{
@@ -463,7 +680,12 @@ void loop()
 		else if (compare(s, "broker"))
 		{
 			std::string id=getword(cmd);
-					if (id.length() or brokers.find(id)!=brokers.end())
+      if (clients.find(id) != clients.end())
+      {
+        Serial << "A client already have that name" << endl;
+        cmd.clear();
+      }
+			else if (id.length() or brokers.find(id)!=brokers.end())
 			{
 				int port=getint(cmd, 0);
 				if (port)
@@ -475,16 +697,26 @@ void loop()
 					Serial << "new broker (" << id.c_str() << ")" << endl;
 				}
 				else
+        {
 					Serial << "Missing port" << endl;
+          cmd.clear();
+        }
 			}
 			else
+      {
 				Serial << "Missing or existing broker name (" << id.c_str() << ")" << endl;
-					cmd+=" ls";
+        cmd.clear();
+      }
 		}
 		else if (compare(s, "client"))
 		{
 			std::string id=getword(cmd);
-					if (id.length() or clients.find(id)!=clients.end())
+      if (brokers.find(id) != brokers.end())
+      {
+				Serial << "A broker have that name" << endl;
+				cmd.clear();
+      }
+			else if (id.length() or clients.find(id)!=clients.end())
 			{
 				s=getword(cmd);	// broker name
 				if (s=="" or brokers.find(s) != brokers.end())
@@ -501,11 +733,14 @@ void loop()
 				else if (s.length())
 				{
 					Serial << " not found." << endl;
+				  cmd.clear();
 				}
 			}
 			else
+      {
 				Serial << "Missing or existing client name" << endl;
-					cmd+=" ls";
+        cmd.clear();
+ 			}
 		}
 		else if (compare(s, "set"))
 		{
@@ -538,14 +773,14 @@ void loop()
 			Serial << "--< " << clients.size() << " client/s. >--" << endl;
 			for(auto it: clients)
 			{
-						Serial << "  "; it.second->dump();
+				it.second->dump("  ");
 			}

 			Serial << "--< " << brokers.size() << " brokers/s. >--" << endl;
 			for(auto it: brokers)
 			{
-						Serial << " ==[ Broker: " << it.first.c_str() << " ]== ";
-						it.second->dump();
+				Serial << "  +-- '" << it.first.c_str() << "' " << it.second->clientsCount() << " client/s."<< endl;
+				it.second->dump("     ");
 			}
 		}
 		else if (compare(s, "reset"))
@@ -556,24 +791,32 @@ void loop()
 		{
 			Serial << "syntax:" << endl;
 			Serial << "  MqttBroker:" << endl;
-					Serial << "    broker {name} {port} : create a new broker" << endl;
+			Serial << "    broker {broker_name} {port} : create a new broker" << endl;
+      Serial << "      broker_name.delete : delete a broker (buggy)" << endl;
+      Serial << "      broker_name.view   : dump a broker" << endl;
 			Serial << endl;
 			Serial << "  MqttClient:" << endl;
 			Serial << "    client {name} {parent broker} : create a client then" << endl;
 			Serial << "      name.connect  [ip] [port] [alive]" << endl;
-					Serial << "      name.subscribe [topic]" << endl;
+			Serial << "      name.[un]subscribe [topic]" << endl;
 			Serial << "      name.publish [topic][payload]" << endl;
 			Serial << "      name.view" << endl;
 			Serial << "      name.delete" << endl;
+			Serial << endl;

 			automatic::help();
 			Serial << endl;
 			Serial << "  help" << endl;
+			Serial << "  blink [Dx on_ms off_ms]    : make pin blink" << endl;
 			Serial << "  ls / ip / reset" << endl;
 			Serial << "  set [name][value]" << endl;
 			Serial << "  !  repeat last command" << endl;
 			Serial << endl;
+			Serial << "  echo [on|off] or strings" << endl;
+			Serial << "  every ms [command]; every list; every remove [nr|all]; every (on|off) [#]" << endl;
+			Serial << "  on {output}; off {output}" << endl;
 			Serial << "  $id : name of the client." << endl;
+			Serial << "  rnd[(min[,max])] random number." << endl;
 			Serial << "  default topic is '" << topic.c_str() << "'" << endl;
 			Serial << endl;
 		}
@@ -586,10 +829,87 @@ void loop()

 		if (retval != MqttOk)
 		{
-					Serial << "## ERROR " << retval << endl;
+			Serial << "# MQTT ERROR " << retval << endl;
 		}
 	}
 }
+
+void loop()
+{
+	auto ms=millis();
+	int8_t out=0;
+	int16_t blink_bits = blink;
+	uint8_t e=0;
+
+	for(auto& every: everies)
+	{
+		if (not every.active) continue;
+		if (every.ms && every.cmd.length() && ms > every.next)
+		{
+			std::string cmd(every.cmd);
+			eval(cmd);
+			every.next += every.ms;
+			if (ms > every.next and ms > every.underrun)
+			{
+				Serial << "Underrun every #" << e << ", " <<  (ms - every.next) << "ms late" << endl;
+				every.underrun = ms+5000;
+			}
+		}
+		e++;
+	}
+
+	while(blink_bits)
+	{
+		if (blink_ms_on[out] and ms > blink_next[out])
+		{
+			if (blink_state[out])
+			{
+				blink_next[out] += blink_ms_on[out];
+				digitalWrite(out, LOW);
+			}
+			else
+			{
+				blink_next[out] += blink_ms_off[out];
+				digitalWrite(abs(out), HIGH);
+			}
+			blink_state[out] = not blink_state[out];
+		}
+		blink_bits >>=1;
+		out++;
+	}
+
+	static long count;
+  #if defined(ESP9266)
+  MDNS.update();
+  #endif
+
+	for(auto it: brokers)
+		it.second->loop();
+
+	for(auto it: clients)
+		it.second->loop();
+
+	automatic::loop();
+
+	if (Serial.available())
+	{
+		static std::string cmd;
+		char c=Serial.read();
+		if (echo_on)
+			Serial << c;
+
+		if (c==10 or c==13)
+		{
+			Serial << "----------------[ " << cmd.c_str() << " ]--------------" << endl;
+			static std::string last_cmd;
+			if (cmd=="!")
+				cmd=last_cmd;
+			else
+				last_cmd=cmd;
+
+			if (cmd.substr(0,3)!="set") replaceVars(cmd);
+			eval(cmd);
+		}
 		else
 		{
 			cmd=cmd+c;
--- a/keywords.txt
+++ b/keywords.txt
@@ -9,13 +9,19 @@
 TinyMqtt    KEYWORD1

 MqttBroker  KEYWORD1
+connect		  KEYWORD2
+clientsCount KEYWORD2
 begin				KEYWORD2
 loop				KEYWORD2
+port				KEYWORD2

 MqttClient  KEYWORD1
+connect		  KEYWORD2
+connected	  KEYWORD2
 publish     KEYWORD2
 setCallback	KEYWORD2
 subscribe	  KEYWORD2
+unsubscribe	KEYWORD2

 Topic				KEYWORD1
 matches			KEYWORD2
--- a/library.json
+++ b/library.json
@@ -1,18 +0,0 @@
-{
-    "name": "TinyMqtt",
-    "keywords": "ethernet, mqtt, m2m, iot",
-    "description": "MQTT is a lightweight messaging protocol ideal for small devices. This library allows you to send and receive MQTT messages. It does support MQTT 3.1.1 without any QOS.",
-    "repository": {
-        "type": "git",
-        "url": "https://github.com/hsaturn/TinyMqtt.git"
-    },
-    "version": "0.6.0",
-    "exclude": "",
-    "examples": "examples/*/*.ino",
-    "frameworks": "arduino",
-    "platforms": [
-        "atmelavr",
-        "espressif8266",
-        "espressif32"
-    ]
-}
--- a/library.properties
+++ b/library.properties
@@ -1,9 +1,9 @@
 name=TinyMqtt
-version=0.6.0
+version=0.9.5
 author=Francois BIOT, HSaturn, <hsaturn@gmail.com>
 maintainer=Francois BIOT, HSaturn, <hsaturn@gmail.com>
 sentence=A tiny broker and client library for MQTT messaging.
-paragraph=MQTT is a lightweight messaging protocol ideal for small devices. This library allows you to send and receive MQTT messages and to jhost a broker in your ESP. It does support MQTT 3.1.1 without any QOS.
+paragraph=MQTT is a lightweight messaging protocol ideal for small devices. This library allows to send and receive MQTT messages and to host a broker in your ESP 8266 and 32 WROOM. It does support MQTT 3.1.1 with QoS=0.
 category=Communication
 url=https://github.com/hsaturn/TinyMqtt
 architectures=*
--- a/src/MqttStreaming.h
+++ b/src/MqttStreaming.h
@@ -38,11 +38,12 @@
  4.  Simple _FMT mechanism ala printf, but without the typeunsafetyness 
      and no internal buffers for replaceable stream printing
 */
+#pragma once

 #ifndef ARDUINO_STREAMING
 #define ARDUINO_STREAMING

-#if defined(ARDUINO) && ARDUINO >= 100
+#if (defined(ARDUINO) && ARDUINO >= 100) || defined(EPOXY_DUINO)
 #include "Arduino.h"
 #else
 #ifndef STREAMING_CONSOLE
@@ -154,7 +155,7 @@ template<typename T>
 inline Print &operator <<(Print &obj, const _BASED<T> &arg)
 { obj.print(arg.val, arg.base); return obj; }

-#if ARDUINO >= 18
+#if ARDUINO >= 18 || defined(EPOXY_DUINO)
 // Specialization for class _FLOAT
 // Thanks to Michael Margolis for suggesting a way
 // to accommodate Arduino 0018's floating point precision
--- a/src/StringIndexer.h
+++ b/src/StringIndexer.h
@@ -2,7 +2,6 @@
 #include <map>
 #include <string>
 #include <string.h>
-#include <ESP8266WiFi.h>

 /***
 * Allows to store up to 255 different strings with one byte class
@@ -15,33 +14,20 @@ class StringIndexer
    std::string str;
    uint8_t used=0;
    friend class StringIndexer;
+
+    #if EPOXY_DUINO
+    public:
+    // Workaround to avoid coredump in Indexer::release
+    // when destroying a Topic after the deletion of
+    // StringIndexer::strings map (which can occurs only with AUnit,
+    // never in the ESP itself, because ESP never ends)
+    // (I hate static vars)
+    ~StringCounter() { used=255; }
+    #endif
  };
  public:
    using index_t = uint8_t;

-		static const index_t strToIndex(const char* str, uint8_t len)
-		{
-			for(auto it=strings.begin(); it!=strings.end(); it++)
-			{
-				if (strncmp(it->second.str.c_str(), str, len)==0)
-				{
-					it->second.used++;
-					return it->first;
-				}
-			}
-			for(index_t index=0; index<255; index++)
-			{
-				if (strings.find(index)==strings.end())
-				{
-					strings[index].str = std::string(str, len);
-					strings[index].used++;
-					// Serial << "Creating index " << index << " for (" << strings[index].str.c_str() << ") len=" << len << endl;
-					return index;
-				}
-			}
-			return 0;	// TODO out of indexes
-		}
-
   static const std::string& str(const index_t& index)
    {
      static std::string dummy;
@@ -70,7 +56,35 @@ class StringIndexer
      }
    }

+    static uint16_t count() { return strings.size(); }
+
  private:
+    friend class IndexedString;
+
+    // increment use of str or create a new index
+    static index_t strToIndex(const char* str, uint8_t len)
+    {
+      for(auto it=strings.begin(); it!=strings.end(); it++)
+      {
+        if (it->second.str.length() == len && strcmp(it->second.str.c_str(), str)==0)
+        {
+          it->second.used++;
+          return it->first;
+        }
+      }
+      for(index_t index=1; index; index++)
+      {
+        if (strings.find(index)==strings.end())
+        {
+          strings[index].str = std::string(str, len);
+          strings[index].used++;
+          // Serial << "Creating index " << index << " for (" << strings[index].str.c_str() << ") len=" << len << endl;
+          return index;
+        }
+      }
+      return 0;  // TODO out of indexes
+    }
+
    static std::map<index_t, StringCounter> strings;
 };

@@ -88,6 +102,8 @@ class IndexedString
      index=StringIndexer::strToIndex(str, len);
    }

+    IndexedString(const std::string& str) : IndexedString(str.c_str(), str.length()) {};
+
    ~IndexedString() { StringIndexer::release(index); }

    IndexedString& operator=(const IndexedString& source)
@@ -102,9 +118,14 @@ class IndexedString
      return i1.index < i2.index;
    }

+    friend bool operator==(const IndexedString& i1, const IndexedString& i2)
+    {
+      return i1.index == i2.index;
+    }
+
    const std::string& str() const { return StringIndexer::str(index); }

-		const StringIndexer::index_t getIndex() const { return index; }
+    const StringIndexer::index_t& getIndex() const { return index; }

  private:
    StringIndexer::index_t index;
--- a/src/TinyMqtt.cpp
+++ b/src/TinyMqtt.cpp
@@ -1,16 +1,16 @@
 #include "TinyMqtt.h"
 #include <sstream>

-void outstring(const char* prefix, const char*p, uint16_t len)
-{
-	return;
-	Serial << prefix << "='";
-	while(len--) Serial << (char)*p++;
-	Serial << '\'' << endl;
-}
+#ifdef EPOXY_DUINO
+  std::map<MqttMessage::Type, int> MqttClient::counters;
+#endif

-MqttBroker::MqttBroker(uint16_t port) : server(port)
+MqttBroker::MqttBroker(uint16_t port)
 {
+  server = new TcpServer(port);
+#ifdef TINY_MQTT_ASYNC
+  server->onClient(onClient, this);
+#endif
 }

 MqttBroker::~MqttBroker()
@@ -19,18 +19,30 @@ MqttBroker::~MqttBroker()
  {
    delete clients[0];
  }
+  delete server;
 }

 // private constructor used by broker only
-MqttClient::MqttClient(MqttBroker* parent, WiFiClient& new_client)
+MqttClient::MqttClient(MqttBroker* parent, TcpClient* new_client)
  : parent(parent)
 {
-	client = new WiFiClient(new_client);
-	alive = millis()+5000;	// client expires after 5s if no CONNECT msg
+#ifdef TINY_MQTT_ASYNC
+  client = new_client;
+  client->onData(onData, this);
+  // client->onConnect() TODO
+  // client->onDisconnect() TODO
+#else
+  client = new WiFiClient(*new_client);
+#endif
+#ifdef EPOXY_DUINO
+  alive = millis()+500000;
+#else
+  alive = millis()+5000;  // TODO MAGIC client expires after 5s if no CONNECT msg
+#endif
 }

-MqttClient::MqttClient(MqttBroker* parent)
-	: parent(parent)
+MqttClient::MqttClient(MqttBroker* parent, const std::string& id)
+  : parent(parent), clientId(id)
 {
    client = nullptr;

@@ -43,12 +55,17 @@ MqttClient::~MqttClient()
  delete client;
 }

-void MqttClient::close()
+void MqttClient::close(bool bSendDisconnect)
 {
  debug("close " << id().c_str());
  mqtt_connected = false;
-	if (client)
+  if (client)  // connected to a remote broker
  {
+    if (bSendDisconnect and client->connected())
+    {
+      message.create(MqttMessage::Type::Disconnect);
+      message.sendTo(this);
+    }
    client->stop();
  }

@@ -59,32 +76,31 @@ void MqttClient::close()
  }
 }

+void MqttClient::connect(MqttBroker* parentBroker)
+{
+  close();
+  parent = parentBroker;
+}
+
 void MqttClient::connect(std::string broker, uint16_t port, uint16_t ka)
 {
-	debug("cnx: closing");
+  debug("MqttClient::connect");
+  keep_alive = ka;
  close();
  if (client) delete client;
-	client = new WiFiClient;
+  client = new TcpClient;
+
  debug("Trying to connect to " << broker.c_str() << ':' << port);
+#ifdef TINY_MQTT_ASYNC
+  client->onData(onData, this);
+  client->onConnect(onConnect, this);
+  client->connect(broker.c_str(), port);
+#else
  if (client->connect(broker.c_str(), port))
  {
-	  debug("cnx: connecting");
-		MqttMessage msg(MqttMessage::Type::Connect);
-		msg.add("MQTT",4);
-		msg.add(0x4);	// Mqtt protocol version 3.1.1
-		msg.add(0x0);	// Connect flags         TODO user / name
-
-		keep_alive = ka;
-		msg.add(0x00);			// keep_alive
-		msg.add((char)keep_alive);
-		msg.add(clientId);
-	  debug("cnx: mqtt connecting");
-		msg.sendTo(this);
-		msg.reset();
-	  debug("cnx: mqtt sent " << (int32_t)parent);
-
-		clientAlive(0);
+    onConnect(this, client);
  }
+#endif
 }

 void MqttBroker::addClient(MqttClient* client)
@@ -92,6 +108,13 @@ void MqttBroker::addClient(MqttClient* client)
    clients.push_back(client);
 }

+void MqttBroker::connect(const std::string& host, uint16_t port)
+{
+  if (broker == nullptr) broker = new MqttClient;
+  broker->connect(host, port);
+  broker->parent = this;  // Because connect removed the link
+}
+
 void MqttBroker::removeClient(MqttClient* remove)
 {
  for(auto it=clients.begin(); it!=clients.end(); it++)
@@ -99,6 +122,11 @@ void MqttBroker::removeClient(MqttClient* remove)
    auto client=*it;
    if (client==remove)
    {
+      // TODO if this broker is connected to an external broker
+      // we have to unsubscribe remove's topics.
+      // (but doing this, check that other clients are not subscribed...)
+      // Unless -> we could receive useless messages
+      //        -> we are using (memory) one IndexedString plus its string for nothing.
      debug("Remove " << clients.size());
      clients.erase(it);
      debug("Client removed " << clients.size());
@@ -108,19 +136,35 @@ void MqttBroker::removeClient(MqttClient* remove)
  debug("Error cannot remove client");  // TODO should not occur
 }

+void MqttBroker::onClient(void* broker_ptr, TcpClient* client)
+{
+  MqttBroker* broker = static_cast<MqttBroker*>(broker_ptr);
+
+  broker->addClient(new MqttClient(broker, client));
+  debug("New client");
+}
+
 void MqttBroker::loop()
 {
-  WiFiClient client = server.available();
+#ifndef TINY_MQTT_ASYNC
+  WiFiClient client = server->available();

  if (client)
  {
-		addClient(new MqttClient(this, client));
-		debug("New client (" << clients.size() << ')');
+    onClient(this, &client);
  }
+#endif
+  if (broker)
+  {
+    // TODO should monitor broker's activity.
+    // 1 When broker disconnect and reconnect we have to re-subscribe
+    broker->loop();
+  }
+

  // for(auto it=clients.begin(); it!=clients.end(); it++)
  // use index because size can change during the loop
-	for(int i=0; i<clients.size(); i++)
+  for(size_t i=0; i<clients.size(); i++)
  {
    auto client = clients[i];
    if (client->connected())
@@ -129,7 +173,7 @@ void MqttBroker::loop()
    }
    else
    {
-      debug("Client " << client->id().c_str() << "  Disconnected, parent=" << (int32_t)client->parent);
+      debug("Client " << client->id().c_str() << "  Disconnected, parent=" << (dbg_ptr)client->parent);
      // Note: deleting a client not added by the broker itself will probably crash later.
      delete client;
      break;
@@ -137,7 +181,16 @@ void MqttBroker::loop()
  }
 }

-MqttError MqttBroker::publish(const MqttClient* source, const Topic& topic, MqttMessage& msg)
+MqttError MqttBroker::subscribe(const Topic& topic, uint8_t qos)
+{
+  if (broker && broker->connected())
+  {
+    return broker->subscribe(topic, qos);
+  }
+  return MqttNowhereToSend;
+}
+
+MqttError MqttBroker::publish(const MqttClient* source, const Topic& topic, MqttMessage& msg) const
 {
  MqttError retval = MqttOk;

@@ -146,33 +199,32 @@ MqttError MqttBroker::publish(const MqttClient* source, const Topic& topic, Mqtt
  for(auto client: clients)
  {
    i++;
-#if TINY_MQTT_DEBUG
+#ifdef TINY_MQTT_DEBUG
    Serial << "brk_" << (broker && broker->connected() ? "con" : "dis") <<
       "  srce=" << (source->isLocal() ? "loc" : "rem") << " clt#" << i << ", local=" << client->isLocal() << ", con=" << client->connected() << endl;
 #endif
    bool doit = false;
-		if (broker && broker->connected())	// Broker is connected
+    if (broker && broker->connected())  // this (MqttBroker) is connected (to a external broker)
    {
-			//    ext broker -> clients or
-			// or clients -> ext broker
-			if (source == broker)	// broker -> clients
+      // ext_broker -> clients or clients -> ext_broker
+      if (source == broker)  // external broker -> internal clients
        doit = true;
-			else									// clients -> broker
+      else                  // external clients -> this broker
      {
-				MqttError ret = broker->publish(topic, msg);
+        // As this broker is connected to another broker, simply forward the msg
+        MqttError ret = broker->publishIfSubscribed(topic, msg);
        if (ret != MqttOk) retval = ret;
      }
    }
-		else // Disconnected: R7
+    else // Disconnected
    {
-			// All is allowed
      doit = true;
    }
-#if TINY_MQTT_DEBUG
+#ifdef TINY_MQTT_DEBUG
    Serial << ", doit=" << doit << ' ';
 #endif

-		if (doit) retval = client->publish(topic, msg);
+    if (doit) retval = client->publishIfSubscribed(topic, msg);
    debug("");
  }
  return retval;
@@ -198,7 +250,11 @@ void MqttClient::clientAlive(uint32_t more_seconds)
 {
  if (keep_alive)
  {
+#ifdef EPOXY_DUINO
+    alive=millis()+500000;
+#else
    alive=millis()+1000*(keep_alive+more_seconds);
+#endif
  }
  else
    alive=0;
@@ -218,24 +274,64 @@ void MqttClient::loop()
    {
      debug("pingreq");
      uint16_t pingreq = MqttMessage::Type::PingReq;
-			client->write((uint8_t*)(&pingreq), 2);
+      client->write((const char*)(&pingreq), 2);
      clientAlive(0);

-			// TODO when many MqttClient passes through a local browser
+      // TODO when many MqttClient passes through a local broker
      // there is no need to send one PingReq per instance.
    }
  }
-
+#ifndef TINY_MQTT_ASYNC
  while(client && client->available()>0)
  {
    message.incoming(client->read());
    if (message.type())
    {
-			processMessage();
+      processMessage(&message);
+      message.reset();
    }
  }
+#endif
 }

+void MqttClient::onConnect(void *mqttclient_ptr, TcpClient*)
+{
+  MqttClient* mqtt = static_cast<MqttClient*>(mqttclient_ptr);
+  debug("cnx: connecting");
+  MqttMessage msg(MqttMessage::Type::Connect);
+  msg.add("MQTT",4);
+  msg.add(0x4);  // Mqtt protocol version 3.1.1
+  msg.add(0x0);  // Connect flags         TODO user / name
+
+  msg.add(0x00);      // keep_alive
+  msg.add((char)mqtt->keep_alive);
+  msg.add(mqtt->clientId);
+  debug("cnx: mqtt connecting");
+  msg.sendTo(mqtt);
+  msg.reset();
+  debug("cnx: mqtt sent " << (dbg_ptr)mqtt->parent);
+
+  mqtt->clientAlive(0);
+}
+
+#ifdef TINY_MQTT_ASYNC
+void MqttClient::onData(void* client_ptr, TcpClient*, void* data, size_t len)
+{
+  char* char_ptr = static_cast<char*>(data);
+  MqttClient* client=static_cast<MqttClient*>(client_ptr);
+  while(len>0)
+  {
+    client->message.incoming(*char_ptr++);
+    if (client->message.type())
+    {
+      client->processMessage(&client->message);
+      client->message.reset();
+    }
+    len--;
+  }
+}
+#endif
+
 void MqttClient::resubscribe()
 {
  // TODO resubscription limited to 256 bytes
@@ -263,10 +359,34 @@ MqttError MqttClient::subscribe(Topic topic, uint8_t qos)

   subscriptions.insert(topic);

-	if (parent==nullptr) // remote broker ?
+  if (parent==nullptr) // remote broker
  {
-		debug("remote subscribe");
-		MqttMessage msg(MqttMessage::Type::Subscribe, 2);
+    return sendTopic(topic, MqttMessage::Type::Subscribe, qos);
+  }
+  else
+  {
+    return parent->subscribe(topic, qos);
+  }
+  return ret;
+}
+
+MqttError MqttClient::unsubscribe(Topic topic)
+{
+  auto it=subscriptions.find(topic);
+  if (it != subscriptions.end())
+  {
+    subscriptions.erase(it);
+    if (parent==nullptr) // remote broker
+    {
+      return sendTopic(topic, MqttMessage::Type::UnSubscribe, 0);
+    }
+  }
+  return MqttOk;
+}
+
+MqttError MqttClient::sendTopic(const Topic& topic, MqttMessage::Type type, uint8_t qos)
+{
+  MqttMessage msg(type, 2);

  // TODO manage packet identifier
  msg.add(0);
@@ -274,31 +394,35 @@ MqttError MqttClient::subscribe(Topic topic, uint8_t qos)

  msg.add(topic);
  msg.add(qos);
-		ret = msg.sendTo(this);

-		// TODO we should wait (state machine) for SUBACK
-	}
-	return ret;
+  // TODO instead we should wait (state machine) for SUBACK / UNSUBACK ?
+  return msg.sendTo(this);
 }

-long MqttClient::counter=0;
-
-void MqttClient::processMessage()
+void MqttClient::processMessage(MqttMessage* mesg)
 {
-	counter++;
-#if TINY_MQTT_DEBUG
-if (message.type() != MqttMessage::Type::PingReq && message.type() != MqttMessage::Type::PingResp)
+#ifdef TINY_MQTT_DEBUG
+if (mesg->type() != MqttMessage::Type::PingReq && mesg->type() != MqttMessage::Type::PingResp)
 {
-	Serial << "---> INCOMING " << _HEX(message.type()) << " client(" << (int)client << ':' << clientId << ") mem=" << ESP.getFreeHeap() << endl;
-	// message.hexdump("Incoming");
+  #ifdef NOT_ESP_CORE
+    Serial << "---> INCOMING " << _HEX(mesg->type()) << " client(" << (dbg_ptr)client << ':' << clientId << ") mem=" << " ESP.getFreeHeap() "<< endl;
+  #else
+    Serial << "---> INCOMING " << _HEX(mesg->type()) << " client(" << (dbg_ptr)client << ':' << clientId << ") mem=" << ESP.getFreeHeap() << endl;
+  #endif
+  // mesg->hexdump("Incoming");
+  mesg->hexdump("Incoming");
 }
 #endif
-  auto header = message.getVHeader();
+  auto header = mesg->getVHeader();
  const char* payload;
  uint16_t len;
  bool bclose=true;

-	switch(message.type() & 0XF0)
+#ifdef EPOXY_DUINO
+  counters[mesg->type()]++;
+#endif
+
+  switch(mesg->type())
  {
    case MqttMessage::Type::Connect:
      if (mqtt_connected)
@@ -321,35 +445,35 @@ if (message.type() != MqttMessage::Type::PingReq && message.type() != MqttMessag
      }

      // ClientId
-			message.getString(payload, len);
+      mesg->getString(payload, len);
      clientId = std::string(payload, len);
      payload += len;

      if (mqtt_flags & FlagWill)  // Will topic
      {
-				message.getString(payload, len);	// Will Topic
-				outstring("WillTopic", payload, len);
+        mesg->getString(payload, len);  // Will Topic
        payload += len;

-				message.getString(payload, len);	// Will Message
-				outstring("WillMessage", payload, len);
+        mesg->getString(payload, len);  // Will Message
        payload += len;
      }
      // FIXME forgetting credential is allowed (security hole)
      if (mqtt_flags & FlagUserName)
      {
-				message.getString(payload, len);
+        mesg->getString(payload, len);
        if (!parent->checkUser(payload, len)) break;
        payload += len;
      }
      if (mqtt_flags & FlagPassword)
      {
-				message.getString(payload, len);
+        mesg->getString(payload, len);
        if (!parent->checkPassword(payload, len)) break;
        payload += len;
      }

+      #ifdef TINY_MQTT_DEBUG
        Serial << "Connected client:" << clientId.c_str() << ", keep alive=" << keep_alive << '.' << endl;
+      #endif
      bclose = false;
      mqtt_connected=true;
      {
@@ -383,7 +507,7 @@ if (message.type() != MqttMessage::Type::PingReq && message.type() != MqttMessag
      if (client)
      {
        uint16_t pingreq = MqttMessage::Type::PingResp;
-				client->write((uint8_t*)(&pingreq), 2);
+        client->write((const char*)(&pingreq), 2);
        bclose = false;
      }
      else
@@ -398,84 +522,179 @@ if (message.type() != MqttMessage::Type::PingReq && message.type() != MqttMessag
        if (!mqtt_connected) break;
        payload = header+2;
        
-				debug("subscribe loop");
-				while(payload < message.end())
+        debug("un/subscribe loop");
+        std::string qoss;
+        while(payload < mesg->end())
        {
-					message.getString(payload, len);	// Topic
+          mesg->getString(payload, len);  // Topic
          debug( "  topic (" << std::string(payload, len) << ')');
-					outstring("Subscribes", payload, len);
          // subscribe(Topic(payload, len));
          Topic topic(payload, len);
-					if ((message.type() & 0XF0) == MqttMessage::Type::Subscribe)
+
+          payload += len;
+          if (mesg->type() == MqttMessage::Type::Subscribe)
+          {
+            uint8_t qos = *payload++;
+            if (qos != 0)
+            {
+              debug("Unsupported QOS" << qos << endl);
+              qoss.push_back(0x80);
+            }
+            else
+              qoss.push_back(qos);
            subscriptions.insert(topic);
+          }
          else
          {
            auto it=subscriptions.find(topic);
            if (it != subscriptions.end())
              subscriptions.erase(it);
          }
-					payload += len;
-					uint8_t qos = *payload++;
-					debug("  qos=" << qos);
        }
        debug("end loop");
        bclose = false;
-				// TODO SUBACK
+
+        MqttMessage ack(mesg->type() == MqttMessage::Type::Subscribe ? MqttMessage::Type::SubAck : MqttMessage::Type::UnSuback);
+        ack.add(header[0]);
+        ack.add(header[1]);
+        ack.add(qoss.c_str(), qoss.size(), false);
+        ack.sendTo(this);
      }
      break;

-		case MqttMessage::Type::Publish:
+    case MqttMessage::Type::UnSuback:
      if (!mqtt_connected) break;
+      bclose = false;
+      break;
+
+    case MqttMessage::Type::Publish:
+      #ifdef TINY_MQTT_DEBUG
+        Serial << "publish " << mqtt_connected << '/' << (long) client << endl;
+      #endif
+      if (mqtt_connected or client == nullptr)
      {
-				uint8_t qos = message.type() & 0x6;
+        uint8_t qos = mesg->flags();
        payload = header;
-				message.getString(payload, len);
+        mesg->getString(payload, len);
        Topic published(payload, len);
        payload += len;
-				len=message.end()-payload;
        // Serial << "Received Publish (" << published.str().c_str() << ") size=" << (int)len
-				// << '(' << std::string(payload, len).c_str() << ')'	<< " msglen=" << message.length() << endl; 
+        // << '(' << std::string(payload, len).c_str() << ')'  << " msglen=" << mesg->length() << endl;
        if (qos) payload+=2;  // ignore packet identifier if any
+        len=mesg->end()-payload;
        // TODO reset DUP
        // TODO reset RETAIN
-				if (parent)
+
+        if (parent==nullptr or client==nullptr)  // internal MqttClient receives publish
+        {
+          #ifdef TINY_MQTT_DEBUG
+            Serial << (isSubscribedTo(published) ? "not" : "") << " subscribed.\n";
+            Serial << "has " << (callback ? "" : "no ") << " callback.\n";
+          #endif
+          if (callback and isSubscribedTo(published))
+          {
+            callback(this, published, payload, len);  // TODO send the real payload
+          }
+        }
+        else if (parent) // from outside to inside
        {
          debug("publishing to parent");
-					parent->publish(this, published, message);
+          parent->publish(this, published, *mesg);
        }
-				else if (callback && subscriptions.find(published)!=subscriptions.end())
-				{
-					callback(this, published, nullptr, 0);	// TODO send the real payload
-				}
-				// TODO should send PUBACK
        bclose = false;
      }
      break;

+    case MqttMessage::Type::Disconnect:
+      // TODO should discard any will msg
+      if (!mqtt_connected) break;
+      mqtt_connected = false;
+      close(false);
+      bclose=false;
+      break;
+
    default:
      bclose=true;
      break;
  };
  if (bclose)
  {
-		Serial << "*************** Error msg 0x" << _HEX(message.type());
-		message.hexdump("-------ERROR ------");
+    #ifdef TINY_MQTT_DEBUG
+      Serial << "*************** Error msg 0x" << _HEX(mesg->type());
+      mesg->hexdump("-------ERROR ------");
+      dump();
      Serial << endl;
+    #endif
    close();
  }
  else
  {
    clientAlive(parent ? 5 : 0);
  }
-	message.reset();
 }

 bool Topic::matches(const Topic& topic) const
 {
  if (getIndex() == topic.getIndex()) return true;
-	if (str() == topic.str()) return true;
+  const char* p1 = c_str();
+  const char* p2 = topic.c_str();
+
+  if (p1 == p2) return true;
+  if (*p2 == '$' and *p1 != '$') return false;
+
+  while(*p1 and *p2)
+  {
+    if (*p1 == '+')
+    {
+      ++p1;
+      if (*p1 and *p1!='/') return false;
+      if (*p1) ++p1;
+      while(*p2 and *p2++!='/');
+    }
+    else if (*p1 == '#')
+    {
+      if (*++p1==0) return true;
      return false;
    }
+    else if (*p1 == '*')
+    {
+      const char c=*(p1+1);
+      if (c==0) return true;
+      if (c!='/') return false;
+      const char*p = p1+2;
+      while(*p and *p2)
+      {
+        if (*p == *p2)
+        {
+          if (*p==0) return true;
+          if (*p=='/')
+          {
+            p1=p;
+            break;
+          }
+        }
+        else
+        {
+          while(*p2 and *p2++!='/');
+          break;
+        }
+        ++p;
+        ++p2;
+      }
+      if (*p==0) return true;
+    }
+    else if (*p1 == *p2)
+    {
+      ++p1;
+      ++p2;
+    }
+    else
+      return false;
+  }
+  if (*p1=='/' and p1[1]=='#' and p1[2]==0) return true;
+  return *p1==0 and *p2==0;
+}
+

 // publish from local client
 MqttError MqttClient::publish(const Topic& topic, const char* payload, size_t pay_length)
@@ -483,8 +702,12 @@ MqttError MqttClient::publish(const Topic& topic, const char* payload, size_t pa
  MqttMessage msg(MqttMessage::Publish);
  msg.add(topic);
  msg.add(payload, pay_length, false);
+  msg.complete();
+
  if (parent)
+  {
    return parent->publish(this, topic, msg);
+  }
  else if (client)
    return msg.sendTo(this);
  else
@@ -492,29 +715,37 @@ MqttError MqttClient::publish(const Topic& topic, const char* payload, size_t pa
 }

 // republish a received publish if it matches any in subscriptions
-MqttError MqttClient::publish(const Topic& topic, MqttMessage& msg)
+MqttError MqttClient::publishIfSubscribed(const Topic& topic, MqttMessage& msg)
 {
  MqttError retval=MqttOk;

  debug("mqttclient publish " << subscriptions.size());
-	for(const auto& subscription: subscriptions)
+  if (isSubscribedTo(topic))
  {
-		if (subscription.matches(topic))
-		{
-			debug(" match client=" << (int32_t)client << ", topic " << topic.str().c_str() << ' ');
    if (client)
-			{
      retval = msg.sendTo(this);
-			}
-			else if (callback)
+    else
    {
-				callback(this, topic, nullptr, 0);	// TODO Payload
-			}
+      processMessage(&msg);
+
+      #ifdef TINY_MQTT_DEBUG
+        Serial << "Should call the callback ?\n";
+      #endif
+      // callback(this, topic, nullptr, 0);  // TODO Payload
    }
  }
  return retval;
 }

+bool MqttClient::isSubscribedTo(const Topic& topic) const
+{
+  for(const auto& subscription: subscriptions)
+    if (subscription.matches(topic))
+      return true;
+
+  return false;
+}
+
 void MqttMessage::reset()
 {
  buffer.clear();
@@ -528,24 +759,23 @@ void MqttMessage::incoming(char in_byte)
  switch(state)
  {
    case FixedHeader:
-			size=0;
+      size=MaxBufferLength;
      state = Length;
      break;
    case Length:
-			size = (size<<7) + (in_byte & 0x3F);
+
+      if (size==MaxBufferLength)
+        size = in_byte & 0x7F;
+      else
+        size += static_cast<uint16_t>(in_byte & 0x7F)<<7;
+
      if (size > MaxBufferLength)
-			{
        state = Error;
-			}
      else if ((in_byte & 0x80) == 0)
      {
        vheader = buffer.length();
        if (size==0)
          state = Complete;
-				else if (size > 500)	// TODO magic
-				{
-					state = Error;
-				}
        else
        {
          buffer.reserve(size);
@@ -567,12 +797,14 @@ void MqttMessage::incoming(char in_byte)
      break;
    case Complete:
    default:
+      #ifdef TINY_MQTT_DEBUG
        Serial << "Spurious " << _HEX(in_byte) << endl;
        hexdump("spurious");
+      #endif
      reset();
      break;
  }
-	if (buffer.length() > MaxBufferLength)	// TODO magic 256 ?
+  if (buffer.length() > MaxBufferLength)
  {
    debug("Too long " << state);
    reset();
@@ -583,29 +815,42 @@ void MqttMessage::add(const char* p, size_t len, bool addLength)
 {
  if (addLength)
  {
+    buffer.reserve(buffer.length()+2);
    incoming(len>>8);
    incoming(len & 0xFF);
  }
  while(len--) incoming(*p++);
 }

-void MqttMessage::encodeLength(char* msb, int length)
+void MqttMessage::encodeLength()
 {
-	do
+  if (state != Complete)
  {
-		uint8_t encoded(length & 0x7F);
-		length >>=7;
-		if (length) encoded |= 0x80;
-		*msb++ = encoded;
-	} while (length);
+    int length = buffer.size()-3;  // 3 = 1 byte for header + 2 bytes for pre-reserved length field.
+    if (length <= 0x7F)
+    {
+      buffer.erase(1,1);
+      buffer[1] = length;
+      vheader = 2;
+    }
+    else
+    {
+      buffer[1] = 0x80 | (length & 0x7F);
+      buffer[2] = (length >> 7);
+      vheader = 3;
+    }
+      
+    // We could check that buffer[2] < 128 (end of length encoding)
+    state = Complete;
+  }
 };

 MqttError MqttMessage::sendTo(MqttClient* client)
 {
-	if (buffer.size()>2)
+  if (buffer.size())
  {
    debug("sending " << buffer.size() << " bytes");
-		encodeLength(&buffer[1], buffer.size()-2);
+    encodeLength();
    // hexdump("snd");
    client->write(&buffer[0], buffer.size());
  }
@@ -619,6 +864,8 @@ MqttError MqttMessage::sendTo(MqttClient* client)

 void MqttMessage::hexdump(const char* prefix) const
 {
+  (void)prefix;
+#ifdef TINY_MQTT_DEBUG
  uint16_t addr=0;
  const int bytes_per_row = 8;
  const char* hex_to_str = " | ";
@@ -654,4 +901,5 @@ void MqttMessage::hexdump(const char* prefix) const
  }

  Serial << endl;
+#endif
 }
--- a/src/TinyMqtt.h
+++ b/src/TinyMqtt.h
@@ -1,19 +1,56 @@
+#pragma once
+
+// TODO Should add a AUnit with both TINY_MQTT_ASYNC and not TINY_MQTT_ASYNC
+// #define TINY_MQTT_ASYNC  // Uncomment this to use ESPAsyncTCP instead of normal cnx
+
+#if defined(ESP8266) || defined(EPOXY_DUINO)
+  #ifdef TINY_MQTT_ASYNC
+    #include <ESPAsyncTCP.h>
+  #else
    #include <ESP8266WiFi.h>
+  #endif
+#elif defined(ESP32)
+  #include <WiFi.h>
+  #ifdef TINY_MQTT_ASYNC
+    #include <AsyncTCP.h> // https://github.com/me-no-dev/AsyncTCP
+  #endif
+#endif
+#ifdef EPOXY_DUINO
+  #define dbg_ptr uint64_t
+#else
+  #define dbg_ptr uint32_t
+#endif
+
+#ifdef WIO_TERMINAL
+  // Uncommon board handling
+  // If you have a problem with this line, just remove it.
+  // Note: https://github.com/hsaturn/TinyMqtt/issues/41
+  #include <rpcWiFi.h>
+#endif
+
 #include <vector>
 #include <set>
 #include <string>
 #include "StringIndexer.h"
 #include <MqttStreaming.h>

-#if 0
-  #define debug(what) { Serial << __LINE__ << ' ' << what << endl; delay(100); }
-  #define TINY_MQTT_DEBUG 1
+// #define TINY_MQTT_DEBUG
+
+#ifdef TINY_MQTT_DEBUG
+  #define debug(what) { Serial << (int)__LINE__ << ' ' << what << endl; delay(100); }
 #else
-  #define TINY_MQTT_DEBUG 0
  #define debug(what) {}
 #endif

-enum MqttError
+#ifdef TINY_MQTT_ASYNC
+  using TcpClient = AsyncClient;
+  using TcpServer = AsyncServer;
+#else
+  using TcpClient = WiFiClient;
+  using TcpServer = WiFiServer;
+#endif
+
+enum __attribute__((packed)) MqttError
 {
  MqttOk = 0,
  MqttNowhereToSend=1,
@@ -35,9 +72,9 @@ class Topic : public IndexedString
 class MqttClient;
 class MqttMessage
 {
-	const uint16_t MaxBufferLength = 255;
+  const uint16_t MaxBufferLength = 4096;  //hard limit: 16k due to size decoding
  public:
-		enum Type
+    enum __attribute__((packed)) Type
    {
      Unknown     =    0,
      Connect     = 0x10,
@@ -47,10 +84,12 @@ class MqttMessage
      Subscribe   = 0x80,
      SubAck      = 0x90,
      UnSubscribe = 0xA0,
+      UnSuback    = 0xB0,
      PingReq     = 0xC0,
      PingResp    = 0xD0,
+      Disconnect  = 0xE0
    };
-		enum State
+    enum __attribute__((packed)) State
    {
      FixedHeader=0,
      Length=1,
@@ -70,7 +109,7 @@ class MqttMessage
    void add(const Topic& t) { add(t.str()); }
    const char* end() const { return &buffer[0]+buffer.size(); }
    const char* getVHeader() const { return &buffer[vheader]; }
-		uint16_t length() const { return buffer.size(); }
+    void complete() { encodeLength(); }

    void reset();

@@ -78,17 +117,19 @@ class MqttMessage
    // output buff+=2, len=length(str)
    static void getString(const char* &buff, uint16_t& len);

-
    Type type() const
    {
-			return state == Complete ? static_cast<Type>(buffer[0]) : Unknown;
+      return state == Complete ? static_cast<Type>(buffer[0] & 0xF0) : Unknown;
    }

+    uint8_t flags() const { return static_cast<uint8_t>(buffer[0] & 0x0F); }
+
    void create(Type type)
    {
-			buffer=(char)type;
-			buffer+='\0';
-			vheader=2;
+      buffer=(decltype(buffer)::value_type)type;
+      buffer+='\0';    // reserved for msg length byte 1/2
+      buffer+='\0';    // reserved for msg length byte 2/2 (fixed)
+      vheader=3;      // Should never change
      size=0;
      state=Create;
    }
@@ -96,7 +137,7 @@ class MqttMessage
    void hexdump(const char* prefix=nullptr) const;

  private:
-		void encodeLength(char* msb, int length);
+    void encodeLength();

    std::string buffer;
    uint8_t vheader;
@@ -108,7 +149,7 @@ class MqttBroker;
 class MqttClient
 {
  using CallBack = void (*)(const MqttClient* source, const Topic& topic, const char* payload, size_t payload_length);
-	enum Flags
+  enum __attribute__((packed)) Flags
  {
    FlagUserName = 128,
    FlagPassword = 64,
@@ -119,14 +160,18 @@ class MqttClient
    FlagReserved = 1
  };
  public:
-		MqttClient(MqttBroker*);
-		MqttClient() : MqttClient(nullptr) {};
+    /** Constructor. If broker is not null, this is the adress of a local broker.
+        If you want to connect elsewhere, leave broker null and use connect() **/
+    MqttClient(MqttBroker* broker = nullptr, const std::string& id="");
+    MqttClient(const std::string& id) : MqttClient(nullptr, id){}

    ~MqttClient();

    void connect(MqttBroker* parent);
-		void connect(std::string broker, uint16_t port, uint16_t ka=10);
+    void connect(std::string broker, uint16_t port, uint16_t keep_alive = 10);

+    // TODO it seems that connected returns true in tcp mode even if
+    // no negociation occured (only if tcp link is established)
    bool connected() { return
      (parent!=nullptr and client==nullptr) or
      (client and client->connected()); }
@@ -136,59 +181,82 @@ class MqttClient
    const std::string& id() const { return clientId; }
    void id(std::string& new_id) { clientId = new_id; }

+    /** Should be called in main loop() */
    void loop();
-		void close();
-		void setCallback(CallBack fun) {callback=fun; };
+    void close(bool bSendDisconnect=true);
+    void setCallback(CallBack fun)
+    {
+      callback=fun;
+      #ifdef TINY_MQTT_DEBUG
+        Serial << "Callback set to " << (long)fun << endl;
+        if (callback) callback(this, "test/topic", "value", 5);
+      #endif
+    };

    // Publish from client to the world
    MqttError publish(const Topic&, const char* payload, size_t pay_length);
+    MqttError publish(const Topic& t, const char* payload) { return publish(t, payload, strlen(payload)); }
    MqttError publish(const Topic& t, const String& s) { return publish(t, s.c_str(), s.length()); }
    MqttError publish(const Topic& t, const std::string& s) { return publish(t,s.c_str(),s.length());}
    MqttError publish(const Topic& t) { return publish(t, nullptr, 0);};

    MqttError subscribe(Topic topic, uint8_t qos=0);
-		MqttError unsubscribe(Topic& topic);
+    MqttError unsubscribe(Topic topic);
+    bool isSubscribedTo(const Topic& topic) const;

    // connected to local broker
    // TODO seems to be useless
    bool isLocal() const { return client == nullptr; }

-		void dump()
+    void dump(std::string indent="")
    {
+      (void)indent;
+      #ifdef TINY_MQTT_DEBUG
        uint32_t ms=millis();
-			Serial << "MqttClient (" << clientId.c_str() << ") p=" << (int32_t) parent
-				<< " c=" << (int32_t)client << (connected() ? " ON " : " OFF"); 
-			Serial << ", alive=" << (uint32_t)alive << '/' << ms << ", ka=" << keep_alive;
-			Serial << " cnx " << (client && client->connected());
-		  message.hexdump("entrant msg");
+        Serial << indent << "+-- " << '\'' << clientId.c_str() << "' " << (connected() ? " ON " : " OFF");
+        Serial << ", alive=" << alive << '/' << ms << ", ka=" << keep_alive << ' ';
+        Serial << (client && client->connected() ? "" : "dis") << "connected";
+        if (subscriptions.size())
+        {
          bool c = false;
          Serial << " [";
          for(auto s: subscriptions)
          {
-				Serial << (c?", ": "")<< s.str().c_str();
+            if (c) Serial << ", ";
+            Serial << s.str().c_str();
            c=true;
          }
-
-			
-			Serial << "]" << endl;
+          Serial << ']';
+        }
+        Serial << endl;
+      #endif
    }

-		static long counter;	// Number of messages sent
+#ifdef EPOXY_DUINO
+    static std::map<MqttMessage::Type, int> counters;  // Number of processed messages
+#endif

  private:
+
+    // event when tcp/ip link established (real or fake)
+    static void onConnect(void * client_ptr, TcpClient*);
+#ifdef TINY_MQTT_ASYNC
+    static void onData(void* client_ptr, TcpClient*, void* data, size_t len);
+#endif
+    MqttError sendTopic(const Topic& topic, MqttMessage::Type type, uint8_t qos);
    void resubscribe();

    friend class MqttBroker;
-		MqttClient(MqttBroker* parent, WiFiClient& client);
+    MqttClient(MqttBroker* parent, TcpClient* client);
    // republish a received publish if topic matches any in subscriptions
-		MqttError publish(const Topic& topic, MqttMessage& msg);
+    MqttError publishIfSubscribed(const Topic& topic, MqttMessage& msg);

    void clientAlive(uint32_t more_seconds);
-		void processMessage();
+    void processMessage(MqttMessage* message);

    bool mqtt_connected = false;
    char mqtt_flags;
-		uint32_t keep_alive;
+    uint32_t keep_alive = 60;
    uint32_t alive;
    MqttMessage message;

@@ -197,7 +265,7 @@ class MqttClient
    // (this is the case when MqttBroker isn't used except here)
    MqttBroker* parent=nullptr;    // connection to local broker

-		WiFiClient* client=nullptr;		// connection to mqtt client or to remote broker
+    TcpClient* client=nullptr;    // connection to remote broker
    std::set<Topic>  subscriptions;
    std::string clientId;
    CallBack callback = nullptr;
@@ -205,7 +273,7 @@ class MqttClient

 class MqttBroker
 {
-	enum State
+  enum __attribute__((packed)) State
  {
    Disconnected,  // Also the initial state
    Connecting,    // connect and sends a fake publish to avoid circular cnx
@@ -216,27 +284,24 @@ class MqttBroker
    MqttBroker(uint16_t port);
    ~MqttBroker();

-		void begin() { server.begin(); }
+    void begin() { server->begin(); }
    void loop();

-		uint8_t port() const { return server.port(); }
-
-		void connect(std::string host, uint32_t port=1883);
+    void connect(const std::string& host, uint16_t port=1883);
    bool connected() const { return state == Connected; }

-		void dump()
+    size_t clientsCount() const { return clients.size(); }
+
+    void dump(std::string indent="")
    {
-			Serial << clients.size() << " client/s" << endl;
      for(auto client: clients)
-			{
-				Serial << "  ";
-				client->dump();
-			}
+        client->dump(indent);
    }

  private:
    friend class MqttClient;

+    static void onClient(void*, TcpClient*);
    bool checkUser(const char* user, uint8_t len) const
    { return compareString(auth_user, user, len); }

@@ -244,7 +309,9 @@ class MqttBroker
    { return compareString(auth_password, password, len); }


-		MqttError publish(const MqttClient* source, const Topic& topic, MqttMessage& msg);
+    MqttError publish(const MqttClient* source, const Topic& topic, MqttMessage& msg) const;
+
+    MqttError subscribe(const Topic& topic, uint8_t qos);

    // For clients that are added not by the broker itself
    void addClient(MqttClient* client);
@@ -252,7 +319,7 @@ class MqttBroker

    bool compareString(const char* good, const char* str, uint8_t str_len) const;
    std::vector<MqttClient*>  clients;
-		WiFiServer server;
+    TcpServer* server;

    const char* auth_user = "guest";
    const char* auth_password = "guest";
--- a/tests/Makefile
+++ b/tests/Makefile
@@ -0,0 +1,28 @@
+tests:
+	set -e; \
+	for i in *-tests/Makefile; do \
+		echo '==== Making:' $$(dirname $$i); \
+		$(MAKE) -C $$(dirname $$i) -j; \
+	done
+
+debugtest:
+	set -e; \
+	$(MAKE) clean; \
+	$(MAKE) -C debug-mode -j; \
+	debug-mode/debug-tests.out
+
+runtests: debugtest
+	$(MAKE) clean
+	$(MAKE) tests
+	set -e; \
+	for i in *-tests/Makefile; do \
+		echo '==== Running:' $$(dirname $$i); \
+		$$(dirname $$i)/$$(dirname $$i).out; \
+	done
+
+clean:
+	set -e; \
+	for i in *-tests/Makefile; do \
+		echo '==== Cleaning:' $$(dirname $$i); \
+		$(MAKE) -C $$(dirname $$i) clean; \
+	done
--- a/tests/debug-mode/Makefile
+++ b/tests/debug-mode/Makefile
@@ -0,0 +1,13 @@
+# See https://github.com/bxparks/EpoxyDuino for documentation about this
+# Makefile to compile and run Arduino programs natively on Linux or MacOS.
+
+EXTRA_CXXFLAGS=-g3 -O0 -DTINY_MQTT_DEBUG
+
+# Remove flto flag from EpoxyDuino (too many <optimized out>)
+CXXFLAGS = -Wextra -Wall -std=gnu++11 -fno-exceptions -fno-threadsafe-statics
+
+APP_NAME := debug-tests
+ARDUINO_LIBS := AUnit AceCommon AceTime TinyMqtt EspMock ESP8266WiFi  ESPAsyncTCP
+ARDUINO_LIB_DIRS := ../../../EspMock/libraries
+EPOXY_CORE := EPOXY_CORE_ESP8266
+include ../../../EpoxyDuino/EpoxyDuino.mk
--- a/tests/debug-mode/debug-tests.ino
+++ b/tests/debug-mode/debug-tests.ino
@@ -0,0 +1,15 @@
+#include <Arduino.h>
+#include <AUnit.h>
+#include <TinyMqtt.h>
+#include <map>
+#include <iostream>
+#include <iomanip>
+#include <sstream>
+#include <string>
+
+// Only compilation check, so do nothing
+
+void setup() {}
+void loop() {
+  aunit::TestRunner::run();
+}
--- a/tests/howto
+++ b/tests/howto
@@ -0,0 +1,7 @@
+cd TinyMqtt/tests/../..
+git clone https://github.com/hsaturn/EspMock.git
+git clone https://github.com/bxparks/AUnit.git
+git clone https://github.com/bxparks/EpoxyDuino.git
+cd TinyMqtt/tests
+make
+make runtests
--- a/tests/length-tests.todo/Makefile
+++ b/tests/length-tests.todo/Makefile
@@ -0,0 +1,10 @@
+# See https://github.com/bxparks/EpoxyDuino for documentation about this
+# Makefile to compile and run Arduino programs natively on Linux or MacOS.
+
+EXTRA_CXXFLAGS=-g3 -O0
+
+APP_NAME := length-tests
+ARDUINO_LIBS := AUnit AceCommon AceTime TinyMqtt EspMock ESP8266WiFi  ESPAsyncTCP
+ARDUINO_LIB_DIRS := ../../../EspMock/libraries
+EPOXY_CORE := EPOXY_CORE_ESP8266
+include ../../../EpoxyDuino/EpoxyDuino.mk
--- a/tests/length-tests.todo/length-tests.ino
+++ b/tests/length-tests.todo/length-tests.ino
@@ -0,0 +1,53 @@
+#include <AUnit.h>
+#include <TinyMqtt.h>
+#include <map>
+
+/**
+	* TinyMqtt local unit tests.
+	*
+	* Clients are connected to pseudo remote broker
+	* The remote should be 127.0.0.1:1883 <--- But this does not work due to Esp network limitations
+	* We are using 127.0.0.1 because this is simpler to test with a single ESP
+	* Also, this will allow to mock and thus run Action on github
+	**/
+
+using namespace std;
+
+MqttBroker broker(1883);
+
+std::map<std::string, std::map<Topic, int>>	published;		// map[client_id] => map[topic] = count
+
+const char* lastPayload;
+size_t lastLength;
+
+void onPublish(const MqttClient* srce, const Topic& topic, const char* payload, size_t length)
+{
+	if (srce)
+		published[srce->id()][topic]++;
+  lastPayload = payload;
+	lastLength = length;
+}
+
+test(length_decode_greater_than_127)
+{
+  // TODO WRITE THIS TEST
+  // The test should verify than a mqtt message with more than 127 bytes is correctly decoded
+	assertEqual(1,2);
+}
+
+
+//----------------------------------------------------------------------------
+// setup() and loop()
+void setup() {
+	delay(1000);
+	Serial.begin(115200);
+	while(!Serial);
+
+	Serial.println("=============[ NO WIFI CONNECTION TinyMqtt TESTS ]========================");
+}
+
+void loop() {
+	aunit::TestRunner::run();
+
+	if (Serial.available()) ESP.reset();
+}
--- a/tests/local-tests/Makefile
+++ b/tests/local-tests/Makefile
@@ -0,0 +1,13 @@
+# See https://github.com/bxparks/EpoxyDuino for documentation about this
+# Makefile to compile and run Arduino programs natively on Linux or MacOS.
+
+EXTRA_CXXFLAGS=-g3 -O0
+
+# Remove flto flag from EpoxyDuino (too many <optimized out>)
+CXXFLAGS = -Wextra -Wall -std=gnu++11 -fno-exceptions -fno-threadsafe-statics
+
+APP_NAME := local-tests
+ARDUINO_LIBS := AUnit AceCommon AceTime TinyMqtt EspMock ESP8266WiFi  ESPAsyncTCP
+ARDUINO_LIB_DIRS := ../../../EspMock/libraries
+EPOXY_CORE := EPOXY_CORE_ESP8266
+include ../../../EpoxyDuino/EpoxyDuino.mk
--- a/tests/local-tests/local-tests.ino
+++ b/tests/local-tests/local-tests.ino
@@ -0,0 +1,151 @@
+#include <Arduino.h>
+#include <AUnit.h>
+#include <TinyMqtt.h>
+#include <map>
+
+/**
+  * TinyMqtt local unit tests.
+  *
+  * Clients are connected to pseudo remote broker
+  * The remote should be 127.0.0.1:1883 <--- But this does not work due to Esp network limitations
+  * We are using 127.0.0.1 because this is simpler to test with a single ESP
+  * Also, this will allow to mock and thus run Action on github
+  **/
+
+using namespace std;
+
+MqttBroker broker(1883);
+
+std::map<std::string, std::map<Topic, int>>  published;    // map[client_id] => map[topic] = count
+
+const char* lastPayload;
+size_t lastLength;
+
+void onPublish(const MqttClient* srce, const Topic& topic, const char* payload, size_t length)
+{
+  if (srce)
+    published[srce->id()][topic]++;
+  lastPayload = payload;
+  lastLength = length;
+}
+
+test(local_client_should_unregister_when_destroyed)
+{
+  assertEqual(broker.clientsCount(), (size_t)0);
+  {
+    assertEqual(broker.clientsCount(), (size_t)0);  // Ensure client is not yet connected
+    MqttClient client(&broker);
+    assertEqual(broker.clientsCount(), (size_t)1);  // Ensure client is now connected
+  }
+  assertEqual(broker.clientsCount(), (size_t)0);
+}
+
+#if 0
+test(local_connect)
+{
+  assertEqual(broker.clientsCount(), (size_t)0);
+
+  MqttClient client;
+  assertTrue(client.connected());
+  assertEqual(broker.clientsCount(), (size_t)1);
+}
+
+test(local_publish_should_be_dispatched)
+{
+  published.clear();
+  assertEqual(broker.clientsCount(), (size_t)0);
+
+  MqttClient subscriber;
+  subscriber.subscribe("a/b");
+  subscriber.subscribe("a/c");
+  subscriber.setCallback(onPublish);
+
+  MqttClient publisher;
+  publisher.publish("a/b");
+  publisher.publish("a/c");
+  publisher.publish("a/c");
+
+  assertEqual(published.size(), (size_t)1);  // 1 client has received something
+  assertEqual(published[""]["a/b"], 1);
+  assertEqual(published[""]["a/c"], 2);
+}
+
+test(local_publish_should_be_dispatched_to_local_clients)
+{
+  published.clear();
+  assertEqual(broker.clientsCount(), (size_t)0);
+
+  MqttClient subscriber_a("A");
+  subscriber_a.setCallback(onPublish);
+  subscriber_a.subscribe("a/b");
+  subscriber_a.subscribe("a/c");
+
+  MqttClient subscriber_b("B");
+  subscriber_b.setCallback(onPublish);
+  subscriber_b.subscribe("a/b");
+
+  MqttClient publisher;
+  publisher.publish("a/b");
+  publisher.publish("a/c");
+
+  assertEqual(published.size(), (size_t)2);  // 2 clients have received something
+  assertEqual(published["A"]["a/b"], 1);
+  assertEqual(published["A"]["a/c"], 1);
+  assertEqual(published["B"]["a/b"], 1);
+  assertEqual(published["B"]["a/c"], 0);
+}
+
+test(local_unsubscribe)
+{
+  published.clear();
+  assertEqual(broker.clientsCount(), (size_t)0);
+
+  MqttClient subscriber;
+  subscriber.setCallback(onPublish);
+  subscriber.subscribe("a/b");
+
+  MqttClient publisher;
+  publisher.publish("a/b");
+
+  subscriber.unsubscribe("a/b");
+
+  publisher.publish("a/b");
+  publisher.publish("a/b");
+
+  assertEqual(published[""]["a/b"], 1);  // Only one publish has been received
+}
+
+test(local_nocallback_when_destroyed)
+{
+  published.clear();
+  assertEqual(broker.clientsCount(), (size_t)0);
+
+  MqttClient publisher;
+  {
+    MqttClient subscriber;
+    subscriber.setCallback(onPublish);
+    subscriber.subscribe("a/b");
+    publisher.publish("a/b");
+  }
+
+  publisher.publish("a/b");
+
+  assertEqual(published.size(), (size_t)1);  // Only one publish has been received
+}
+#endif
+
+//----------------------------------------------------------------------------
+// setup() and loop()
+void setup() {
+  delay(1000);
+  Serial.begin(115200);
+  while(!Serial);
+
+  Serial.println("=============[ LOCAL TinyMqtt TESTS              ]========================");
+}
+
+void loop() {
+  aunit::TestRunner::run();
+
+  if (Serial.available()) ESP.reset();
+}
--- a/tests/network-tests/Makefile
+++ b/tests/network-tests/Makefile
@@ -0,0 +1,13 @@
+# See https://github.com/bxparks/EpoxyDuino for documentation about this
+# Makefile to compile and run Arduino programs natively on Linux or MacOS.
+
+EXTRA_CXXFLAGS=-g3 -O0
+
+# Remove flto flag from EpoxyDuino (too many <optimized out>)
+CXXFLAGS = -Wextra -Wall -std=gnu++11 -fno-exceptions -fno-threadsafe-statics
+
+APP_NAME := network-tests
+ARDUINO_LIBS := AUnit AceCommon AceTime TinyMqtt EspMock ESP8266WiFi  ESPAsyncTCP
+ARDUINO_LIB_DIRS := ../../../EspMock/libraries
+EPOXY_CORE := EPOXY_CORE_ESP8266
+include ../../../EpoxyDuino/EpoxyDuino.mk
--- a/tests/network-tests/network-tests.ino
+++ b/tests/network-tests/network-tests.ino
@@ -0,0 +1,429 @@
+#include <Arduino.h>
+#include <AUnit.h>
+#include <TinyMqtt.h>
+#include <map>
+#include <iostream>
+#include <iomanip>
+#include <sstream>
+#include <string>
+
+/**
+  * TinyMqtt network unit tests.
+	*
+	* No wifi connection unit tests.
+  * Checks with a local broker. Clients must connect to the local broker
+	**/
+
+// if ascii_pos = 0, no ascii dump, else ascii dump starts after column ascii_pos
+std::string bufferToHexa(const uint8_t* buffer, size_t length, char sep = 0, size_t ascii_pos = 0)
+{
+  std::stringstream out;
+  std::string ascii;
+  std::string h("0123456789ABCDEF");
+  for(size_t i=0; i<length; i++)
+  {
+    uint8_t c = buffer[i];
+    out << h[ c >> 4] << h[ c & 0x0F ];
+    if (sep) out << sep;
+    if (ascii_pos)
+    {
+      if (c>=32)
+        ascii += c;
+      else
+        ascii +='.';
+    }
+  }
+  std::string ret(out.str());
+  if (ascii_pos)
+  {
+    while(ret.length() < ascii_pos)
+      ret += ' ';
+    ret +='[' + ascii + ']';
+  }
+  return ret;
+}
+
+void dumpMqttMessage(const uint8_t* buffer, size_t length)
+{
+  std::map<int, std::string> pkt =
+  { { MqttMessage::Unknown     , "Unknown     " },
+    { MqttMessage::Connect     , "Connect     " },
+    { MqttMessage::ConnAck     , "ConnAck     " },
+    { MqttMessage::Publish     , "Publish     " },
+    { MqttMessage::PubAck      , "PubAck      " },
+    { MqttMessage::Subscribe   , "Subscribe   " },
+    { MqttMessage::SubAck      , "SubAck      " },
+    { MqttMessage::UnSubscribe , "Unsubscribe " },
+    { MqttMessage::UnSuback    , "UnSubAck    " },
+    { MqttMessage::PingReq     , "PingReq     " },
+    { MqttMessage::PingResp    , "PingResp    " },
+    { MqttMessage::Disconnect  , "Disconnect  " } };
+
+  std::cout << "       |   data sent " << std::setw(3) << length << " : ";
+  auto it = pkt.find(buffer[0] & 0xF0);
+  if (it == pkt.end())
+    std::cout << pkt[MqttMessage::Unknown];
+  else
+    std::cout << it->second;
+
+  std::cout << bufferToHexa(buffer, length, ' ', 60) << std::endl;
+}
+
+String toString(const IPAddress& ip)
+{
+  return String(ip[0])+'.'+String(ip[1])+'.'+String(ip[2])+'.'+String(ip[3]);
+}
+
+MqttBroker broker(1883);
+
+std::map<std::string, std::map<Topic, int>>	published;		// map[client_id] => map[topic] = count
+
+char* lastPayload = nullptr;
+size_t lastLength;
+
+void start_servers(int n, bool early_accept = true)
+{
+    ESP8266WiFiClass::resetInstances();
+    ESP8266WiFiClass::earlyAccept = early_accept;
+    while(n)
+    {
+      ESP8266WiFiClass::selectInstance(n--);
+      WiFi.mode(WIFI_STA);
+      WiFi.begin("fake_ssid", "fake_pwd");
+    }
+}
+
+void onPublish(const MqttClient* srce, const Topic& topic, const char* payload, size_t length)
+{
+	if (srce)
+		published[srce->id()][topic]++;
+	
+	if (lastPayload) free(lastPayload);
+  lastPayload = strdup(payload);
+	lastLength = length;
+}
+
+test(network_single_broker_begin)
+{
+  assertEqual(WiFi.status(), WL_CONNECTED);
+
+  MqttBroker broker(1883);
+  broker.begin();
+
+  // TODO Nothing is tested here !
+}
+
+test(suback)
+{
+  start_servers(2, true);
+  assertEqual(WiFi.status(), WL_CONNECTED);
+
+  MqttBroker broker(1883);
+  broker.begin();
+  IPAddress broker_ip = WiFi.localIP();
+
+  ESP8266WiFiClass::selectInstance(2);
+  MqttClient client;
+  client.connect(broker_ip.toString().c_str(), 1883);
+  broker.loop();
+
+  assertTrue(broker.clientsCount() == 1);
+  assertTrue(client.connected());
+
+  MqttClient::counters[MqttMessage::Type::SubAck] = 0;
+  client.subscribe("a/b");
+
+  // TODO how to avoid these loops ???
+  broker.loop();
+  client.loop();
+
+  assertEqual(MqttClient::counters[MqttMessage::Type::SubAck], 1);
+}
+
+test(network_client_to_broker_connexion)
+{
+  start_servers(2, true);
+  assertEqual(WiFi.status(), WL_CONNECTED);
+
+  MqttBroker broker(1883);
+  broker.begin();
+  IPAddress broker_ip = WiFi.localIP();
+
+  ESP8266WiFiClass::selectInstance(2);
+  MqttClient client;
+  client.connect(broker_ip.toString().c_str(), 1883);
+  broker.loop();
+
+  assertTrue(broker.clientsCount() == 1);
+  assertTrue(client.connected());
+}
+
+test(network_one_client_one_broker_publish_and_subscribe_through_network)
+{
+  start_servers(2, true);
+  published.clear();
+  assertEqual(WiFi.status(), WL_CONNECTED);
+
+  MqttBroker broker(1883);
+  broker.begin();
+  IPAddress ip_broker = WiFi.localIP();
+
+  // We have a 2nd ESP in order to test through wifi (opposed to local)
+  ESP8266WiFiClass::selectInstance(2);
+  MqttClient client;
+  client.connect(ip_broker.toString().c_str(), 1883);
+  broker.loop();
+  assertTrue(client.connected());
+
+  client.setCallback(onPublish);
+  client.subscribe("a/b");
+  client.publish("a/b", "ab");
+
+  for (int i =0; i<2; i++)
+  {
+    client.loop();
+    broker.loop();
+  }
+  
+  assertEqual(published.size(), (size_t)1);
+  assertEqual((int)lastLength, (int)2); // sizeof(ab)
+}
+
+test(network_one_client_one_broker_hudge_publish_and_subscribe_through_network)
+{
+  start_servers(2, true);
+  published.clear();
+  assertEqual(WiFi.status(), WL_CONNECTED);
+
+  MqttBroker broker(1883);
+  broker.begin();
+  IPAddress ip_broker = WiFi.localIP();
+
+  // We have a 2nd ESP in order to test through wifi (opposed to local)
+  ESP8266WiFiClass::selectInstance(2);
+  MqttClient client;
+  client.connect(ip_broker.toString().c_str(), 1883);
+  broker.loop();
+  assertTrue(client.connected());
+
+  std::string sent;
+
+  for(int i=0; i<200; i++)
+    sent += char('0'+i%10);
+
+  client.setCallback(onPublish);
+  client.subscribe("a/b");
+  client.publish("a/b", sent.c_str());
+
+  for (int i =0; i<2; i++)
+  {
+    client.loop();
+    broker.loop();
+  }
+
+  assertEqual(published.size(), (size_t)1);
+  assertEqual((unsigned int)lastLength, (unsigned int)sent.size());
+}
+
+test(network_client_should_unregister_when_destroyed)
+{
+	assertEqual(broker.clientsCount(), (size_t)0);
+	{
+		MqttClient client(&broker);
+		assertEqual(broker.clientsCount(), (size_t)1);
+	}
+	assertEqual(broker.clientsCount(), (size_t)0);
+}
+
+
+// THESE TESTS ARE IN LOCAL MODE
+// WE HAVE TO CONVERT THEM TO WIFI MODE (pass through virtual TCP link)
+
+test(network_connect)
+{
+	assertEqual(broker.clientsCount(), (size_t)0);
+
+	MqttClient client(&broker);
+	assertTrue(client.connected());
+	assertEqual(broker.clientsCount(), (size_t)1);
+}
+
+test(network_publish_should_be_dispatched)
+{
+	published.clear();
+	assertEqual(broker.clientsCount(), (size_t)0);
+
+	MqttClient subscriber(&broker);
+	subscriber.subscribe("a/b");
+	subscriber.subscribe("a/c");
+	subscriber.setCallback(onPublish);
+
+	MqttClient publisher(&broker);
+	publisher.publish("a/b");
+	publisher.publish("a/c");
+	publisher.publish("a/c");
+
+	assertEqual(published.size(), (size_t)1);	// 1 client has received something
+	assertEqual(published[""]["a/b"], 1);
+	assertEqual(published[""]["a/c"], 2);
+}
+
+test(network_publish_should_be_dispatched_to_clients)
+{
+	published.clear();
+	assertEqual(broker.clientsCount(), (size_t)0);
+
+	MqttClient subscriber_a(&broker, "A");
+	subscriber_a.setCallback(onPublish);
+	subscriber_a.subscribe("a/b");
+	subscriber_a.subscribe("a/c");
+
+	MqttClient subscriber_b(&broker, "B");
+	subscriber_b.setCallback(onPublish);
+	subscriber_b.subscribe("a/b");
+
+	MqttClient publisher(&broker);
+	publisher.publish("a/b");		// A and B should receive this
+	publisher.publish("a/c");		// A should receive this 
+
+	assertEqual(published.size(), (size_t)2);	// 2 clients have received something
+	assertEqual(published["A"]["a/b"], 1);
+	assertEqual(published["A"]["a/c"], 1);
+	assertEqual(published["B"]["a/b"], 1);
+	assertEqual(published["B"]["a/c"], 0);
+}
+
+test(network_unsubscribe)
+{
+	published.clear();
+	assertEqual(broker.clientsCount(), (size_t)0);
+
+	MqttClient subscriber(&broker);
+	subscriber.setCallback(onPublish);
+	subscriber.subscribe("a/b");
+
+	MqttClient publisher(&broker);
+	publisher.publish("a/b");		// This publish is received
+
+	subscriber.unsubscribe("a/b");
+
+	publisher.publish("a/b");		// Those one, no (unsubscribed)
+	publisher.publish("a/b");
+
+	assertEqual(published[""]["a/b"], 1);	// Only one publish has been received
+}
+
+test(network_nocallback_when_destroyed)
+{
+	published.clear();
+	assertEqual(broker.clientsCount(), (size_t)0);
+
+	MqttClient publisher(&broker);
+
+	{
+		MqttClient subscriber(&broker);
+		subscriber.setCallback(onPublish);
+		subscriber.subscribe("a/b");
+		publisher.publish("a/b");
+	}
+
+	publisher.publish("a/b");
+
+	assertEqual(published.size(), (size_t)1);	// Only one publish has been received
+}
+
+test(network_small_payload)
+{
+	published.clear();
+
+	const char* payload="abcd";
+
+	MqttClient subscriber(&broker);
+	subscriber.setCallback(onPublish);
+	subscriber.subscribe("a/b");
+
+	MqttClient publisher(&broker);
+	publisher.publish("a/b", payload, strlen(payload));		// This publish is received
+
+  // coming from MqttClient::publish(...)
+  assertEqual(payload, lastPayload);
+	assertEqual(lastLength, (size_t)4);
+}
+
+test(network_hudge_payload)
+{
+  const char* payload="This payload is hudge, just because its length exceeds 127. Thus when encoding length, we have to encode it on two bytes at min. This should not prevent the message from being encoded and decoded successfully !";
+
+  MqttClient subscriber(&broker);
+  subscriber.setCallback(onPublish);
+  subscriber.subscribe("a/b");          // Note -> this does not send any byte .... (nowhere to send)
+
+	MqttClient publisher(&broker);
+	publisher.publish("a/b", payload);		// This publish is received
+
+  // onPublish should have filled lastPayload and lastLength
+  assertEqual(payload, lastPayload);
+	assertEqual(lastLength, strlen(payload));
+	assertEqual(strcmp(payload, lastPayload), 0);
+}
+
+test(connack)
+{
+  const bool view = false;
+
+  NetworkObserver check(
+    [this](const WiFiClient*, const uint8_t* buffer, size_t length)
+    {
+      if (view) dumpMqttMessage(buffer, length);
+      if (buffer[0] == MqttMessage::ConnAck)
+      {
+        std::string hex = bufferToHexa(buffer, length);
+        assertStringCaseEqual(hex.c_str(), "20020000");
+      }
+    }
+  );
+
+  start_servers(2, true);
+  assertEqual(WiFi.status(), WL_CONNECTED);
+
+  MqttBroker broker(1883);
+  broker.begin();
+  IPAddress broker_ip = WiFi.localIP();
+
+  ESP8266WiFiClass::selectInstance(2);
+  MqttClient client;
+  client.connect(broker_ip.toString().c_str(), 1883);
+  broker.loop();
+
+  assertTrue(broker.clientsCount() == 1);
+  assertTrue(client.connected());
+
+  MqttClient::counters[MqttMessage::Type::SubAck] = 0;
+  client.subscribe("a/b");
+
+  // TODO how to avoid these loops ???
+  broker.loop();
+  client.loop();
+
+  assertEqual(MqttClient::counters[MqttMessage::Type::SubAck], 1);
+}
+
+//----------------------------------------------------------------------------
+// setup() and loop()
+void setup() {
+	/* delay(1000);
+	Serial.begin(115200);
+	while(!Serial);
+	*/
+
+	Serial.println("=============[ FAKE NETWORK TinyMqtt TESTS       ]========================");
+
+	WiFi.mode(WIFI_STA);
+	WiFi.begin("network", "password");
+}
+
+void loop() {
+	aunit::TestRunner::run();
+
+	if (Serial.available()) ESP.reset();
+}
--- a/tests/nowifi-tests/Makefile
+++ b/tests/nowifi-tests/Makefile
@@ -0,0 +1,13 @@
+# See https://github.com/bxparks/EpoxyDuino for documentation about this
+# Makefile to compile and run Arduino programs natively on Linux or MacOS.
+
+EXTRA_CXXFLAGS=-g3 -O0
+
+# Remove flto flag from EpoxyDuino (too many <optimized out>)
+CXXFLAGS = -Wextra -Wall -std=gnu++11 -fno-exceptions -fno-threadsafe-statics
+
+APP_NAME := nowifi-tests
+ARDUINO_LIBS := AUnit AceCommon AceTime TinyMqtt EspMock ESP8266WiFi  ESPAsyncTCP
+ARDUINO_LIB_DIRS := ../../../EspMock/libraries
+EPOXY_CORE := EPOXY_CORE_ESP8266
+include ../../../EpoxyDuino/EpoxyDuino.mk
--- a/tests/nowifi-tests/nowifi-tests.ino
+++ b/tests/nowifi-tests/nowifi-tests.ino
@@ -0,0 +1,281 @@
+#include <Arduino.h>
+#include <AUnit.h>
+#include <TinyMqtt.h>
+#include <map>
+
+/**
+  * TinyMqtt nowifi unit tests.
+	*
+	* No wifi connection unit tests.
+  * Checks with a local broker. Clients must connect to the local broker
+	**/
+
+using namespace std;
+
+MqttBroker broker(1883);
+
+std::map<std::string, std::map<Topic, int>>	published;		// map[client_id] => map[topic] = count
+
+char* lastPayload = nullptr;
+size_t lastLength;
+
+void onPublish(const MqttClient* srce, const Topic& topic, const char* payload, size_t length)
+{
+	if (srce)
+		published[srce->id()][topic]++;
+	
+	if (lastPayload) free(lastPayload);
+  lastPayload = strdup(payload);
+	lastLength = length;
+}
+
+test(nowifi_client_should_unregister_when_destroyed)
+{
+	assertEqual(broker.clientsCount(), (size_t)0);
+	{
+		MqttClient client(&broker);
+		assertEqual(broker.clientsCount(), (size_t)1);
+	}
+	assertEqual(broker.clientsCount(), (size_t)0);
+}
+
+test(nowifi_connect)
+{
+	assertEqual(broker.clientsCount(), (size_t)0);
+
+	MqttClient client(&broker);
+	assertTrue(client.connected());
+	assertEqual(broker.clientsCount(), (size_t)1);
+}
+
+test(nowifi_publish_should_be_dispatched)
+{
+	published.clear();
+	assertEqual(broker.clientsCount(), (size_t)0);
+
+	MqttClient subscriber(&broker);
+	subscriber.subscribe("a/b");
+	subscriber.subscribe("a/c");
+	subscriber.setCallback(onPublish);
+
+	MqttClient publisher(&broker);
+	publisher.publish("a/b");
+	publisher.publish("a/c");
+	publisher.publish("a/c");
+
+	assertEqual(published.size(), (size_t)1);	// 1 client has received something
+	assertEqual(published[""]["a/b"], 1);
+	assertEqual(published[""]["a/c"], 2);
+}
+
+test(nowifi_publish_should_be_dispatched_to_clients)
+{
+	published.clear();
+	assertEqual(broker.clientsCount(), (size_t)0);
+
+	MqttClient subscriber_a(&broker, "A");
+	subscriber_a.setCallback(onPublish);
+	subscriber_a.subscribe("a/b");
+	subscriber_a.subscribe("a/c");
+
+	MqttClient subscriber_b(&broker, "B");
+	subscriber_b.setCallback(onPublish);
+	subscriber_b.subscribe("a/b");
+
+	MqttClient publisher(&broker);
+	publisher.publish("a/b");		// A and B should receive this
+	publisher.publish("a/c");		// A should receive this 
+
+	assertEqual(published.size(), (size_t)2);	// 2 clients have received something
+	assertEqual(published["A"]["a/b"], 1);
+	assertEqual(published["A"]["a/c"], 1);
+	assertEqual(published["B"]["a/b"], 1);
+	assertEqual(published["B"]["a/c"], 0);
+}
+
+test(nowifi_subscribe_with_star_wildcard)
+{
+	published.clear();
+	assertEqual(broker.clientsCount(), (size_t)0);
+
+	MqttClient subscriber(&broker, "A");
+	subscriber.setCallback(onPublish);
+	subscriber.subscribe("house/*/temp");
+
+	MqttClient publisher(&broker);
+	publisher.publish("house/bedroom/temp");
+	publisher.publish("house/kitchen/temp");
+	publisher.publish("house/living_room/tv/temp");
+	publisher.publish("building/location1/bedroom/temp");
+
+	assertEqual(published["A"]["house/bedroom/temp"], 1);
+	assertEqual(published["A"]["house/kitchen/temp"], 1);
+	assertEqual(published["A"]["house/living_room/tv/temp"], 1);
+	assertEqual(published["A"]["building/location1/bedroom/temp"], 0);
+}
+
+test(nowifi_subscribe_with_plus_wildcard)
+{
+	published.clear();
+	assertEqual(broker.clientsCount(), (size_t)0);
+
+	MqttClient subscriber(&broker, "A");
+	subscriber.setCallback(onPublish);
+	subscriber.subscribe("house/+/temp");
+
+	MqttClient publisher(&broker);
+	publisher.publish("house/bedroom/temp");
+	publisher.publish("house/kitchen/temp");
+	publisher.publish("house/living_room/tv/temp");
+	publisher.publish("building/location1/bedroom/temp");
+
+	assertEqual(published["A"]["house/bedroom/temp"], 1);
+	assertEqual(published["A"]["house/kitchen/temp"], 1);
+	assertEqual(published["A"]["house/living_room/tv/temp"], 0);
+	assertEqual(published["A"]["building/location1/bedroom/temp"], 0);
+}
+
+test(nowifi_should_not_receive_sys_msg)
+{
+	published.clear();
+	assertEqual(broker.clientsCount(), (size_t)0);
+
+	MqttClient subscriber(&broker, "A");
+	subscriber.setCallback(onPublish);
+	subscriber.subscribe("+/data");
+
+	MqttClient publisher(&broker);
+	publisher.publish("$SYS/data");
+
+	assertEqual(published["A"]["$SYS/data"], 0);
+}
+
+test(nowifi_subscribe_with_mixed_wildcards)
+{
+	published.clear();
+	assertEqual(broker.clientsCount(), (size_t)0);
+
+	MqttClient subscriber(&broker, "A");
+	subscriber.setCallback(onPublish);
+	subscriber.subscribe("+/data/#");
+
+	MqttClient publisher(&broker);
+	publisher.publish("node1/data/update");
+	publisher.publish("node2/data/delta");
+	publisher.publish("node3/data");
+
+	assertEqual(published["A"]["node1/data/update"], 1);
+	assertEqual(published["A"]["node2/data/delta"], 1);
+	assertEqual(published["A"]["node3/data"], 1);
+}
+
+test(nowifi_unsubscribe_with_wildcards)
+{
+	published.clear();
+	assertEqual(broker.clientsCount(), (size_t)0);
+
+	MqttClient subscriber(&broker, "A");
+	subscriber.setCallback(onPublish);
+	subscriber.subscribe("one/two/+");
+	subscriber.subscribe("one/two/three");
+
+	MqttClient publisher(&broker);
+	publisher.publish("one/two/three");
+	publisher.publish("one/two/four");
+
+	subscriber.unsubscribe("one/two/+");
+	publisher.publish("one/two/five");
+
+	assertEqual(published["A"]["one/two/three"], 1);
+	assertEqual(published["A"]["one/two/four"], 1);
+	assertEqual(published["A"]["one/two/five"], 0);
+}
+
+test(nowifi_unsubscribe)
+{
+	published.clear();
+	assertEqual(broker.clientsCount(), (size_t)0);
+
+	MqttClient subscriber(&broker);
+	subscriber.setCallback(onPublish);
+	subscriber.subscribe("a/b");
+
+	MqttClient publisher(&broker);
+	publisher.publish("a/b");		// This publish is received
+
+	subscriber.unsubscribe("a/b");
+
+	publisher.publish("a/b");		// Those one, no (unsubscribed)
+	publisher.publish("a/b");
+
+	assertEqual(published[""]["a/b"], 1);	// Only one publish has been received
+}
+
+test(nowifi_nocallback_when_destroyed)
+{
+	published.clear();
+	assertEqual(broker.clientsCount(), (size_t)0);
+
+	MqttClient publisher(&broker);
+
+	{
+		MqttClient subscriber(&broker);
+		subscriber.setCallback(onPublish);
+		subscriber.subscribe("a/b");
+		publisher.publish("a/b");
+	}
+
+	publisher.publish("a/b");
+
+	assertEqual(published.size(), (size_t)1);	// Only one publish has been received
+}
+
+test(nowifi_small_payload)
+{
+	published.clear();
+
+	const char* payload="abcd";
+
+	MqttClient subscriber(&broker);
+	subscriber.setCallback(onPublish);
+	subscriber.subscribe("a/b");
+
+	MqttClient publisher(&broker);
+	publisher.publish("a/b", payload, strlen(payload));		// This publish is received
+
+  // coming from MqttClient::publish(...)
+  assertEqual(payload, lastPayload);
+	assertEqual(lastLength, (size_t)4);
+}
+
+test(nowifi_hudge_payload)
+{
+  const char* payload="This payload is hudge, just because its length exceeds 127. Thus when encoding length, we have to encode it on two bytes at min. This should not prevent the message from being encoded and decoded successfully !";
+
+  MqttClient subscriber(&broker);
+  subscriber.setCallback(onPublish);
+  subscriber.subscribe("a/b");
+
+	MqttClient publisher(&broker);
+	publisher.publish("a/b", payload);		// This publish is received
+
+  // onPublish should have filled lastPayload and lastLength
+  assertEqual(payload, lastPayload);
+	assertEqual(lastLength, strlen(payload));
+}
+
+//----------------------------------------------------------------------------
+// setup() and loop()
+void setup() {
+	delay(1000);
+	Serial.begin(115200);
+	while(!Serial);
+
+	Serial.println("=============[ NO WIFI CONNECTION TinyMqtt TESTS ]========================");
+}
+
+void loop() {
+	aunit::TestRunner::run();
+
+	if (Serial.available()) ESP.reset();
+}
--- a/tests/result.json
+++ b/tests/result.json
@@ -0,0 +1,6 @@
+{
+    "schemaVersion" : 1,
+    "label" : "tests",
+    "message" : "Message content",
+    "color": "red"
+}
--- a/tests/result.yaml
+++ b/tests/result.yaml
@@ -0,0 +1,2 @@
+result: 1
+insert: "passed"
--- a/tests/string-indexer-tests/Makefile
+++ b/tests/string-indexer-tests/Makefile
@@ -0,0 +1,10 @@
+# See https://github.com/bxparks/EpoxyDuino for documentation about this
+# Makefile to compile and run Arduino programs natively on Linux or MacOS.
+
+EXTRA_CXXFLAGS=-g3 -O0
+
+APP_NAME := string-indexer-tests
+ARDUINO_LIBS := AUnit AceCommon AceTime TinyMqtt EspMock ESP8266WiFi  ESPAsync
+ARDUINO_LIB_DIRS := ../../../EspMock/libraries
+EPOXY_CORE := EPOXY_CORE_ESP8266
+include ../../../EpoxyDuino/EpoxyDuino.mk
--- a/tests/string-indexer-tests/string-indexer-tests.ino
+++ b/tests/string-indexer-tests/string-indexer-tests.ino
@@ -0,0 +1,118 @@
+#include <Arduino.h>
+#include <AUnit.h>
+#include <StringIndexer.h>
+#include <map>
+
+/**
+	* TinyMqtt / StringIndexer unit tests.
+	*
+	**/
+
+using namespace std;
+
+test(indexer_empty)
+{
+  assertEqual(StringIndexer::count(), 0);
+}
+
+test(indexer_strings_deleted_should_empty_indexer)
+{
+  assertTrue(StringIndexer::count()==0);
+	{
+		IndexedString one("one");
+    assertEqual(StringIndexer::count(), 1);
+		IndexedString two("two");
+    assertEqual(StringIndexer::count(), 2);
+		IndexedString three("three");
+    assertEqual(StringIndexer::count(), 3);
+		IndexedString four("four");
+    assertEqual(StringIndexer::count(), 4);
+	}
+  assertEqual(StringIndexer::count(), 0);
+}
+
+test(indexer_same_strings_count_as_one)
+{
+	IndexedString one  ("one");
+	IndexedString two  ("one");
+	IndexedString three("one");
+	IndexedString fourt("one");
+
+	assertEqual(StringIndexer::count(), 1);
+}
+
+test(indexer_size_of_indexed_string)
+{
+	assertEqual(sizeof(IndexedString), (size_t)1);
+}
+
+test(indexer_different_strings_are_different)
+{
+	IndexedString one("one");
+	IndexedString two("two");
+
+	assertFalse(one == two);
+}
+
+test(indexer_same_strings_should_equal)
+{
+	IndexedString one("one");
+	IndexedString two("one");
+
+	assertTrue(one == two);
+}
+
+test(indexer_compare_strings_with_same_beginning)
+{
+  IndexedString two("one_two");
+  IndexedString one("one");
+
+  assertNotEqual(one.getIndex(), two.getIndex());
+}
+
+test(indexer_indexed_operator_eq)
+{
+	IndexedString one("one");
+	{
+		IndexedString same = one;
+		assertTrue(one == same);
+		assertEqual(StringIndexer::count(), 1);
+  }
+	assertEqual(StringIndexer::count(), 1);
+}
+
+test(indexer_get_string)
+{
+	std::string sone("one");
+	IndexedString one(sone);
+
+  assertTrue(sone==one.str());
+}
+
+test(indexer_get_index)
+{
+	IndexedString one1("one");
+	IndexedString one2("one");
+	IndexedString two1("two");
+	IndexedString two2("two");
+
+  assertTrue(one1.getIndex() == one2.getIndex());
+	assertTrue(two1.getIndex() == two2.getIndex());
+	assertTrue(one1.getIndex() != two1.getIndex());
+}
+
+//----------------------------------------------------------------------------
+// setup() and loop()
+void setup() {
+	delay(1000);
+	Serial.begin(115200);
+	while(!Serial);
+
+	Serial.println("=============[ TinyMqtt StringIndexer TESTS ]========================");
+}
+
+void loop() {
+	aunit::TestRunner::run();
+
+	// if (Serial.available()) ESP.reset();
+}
--- a/tests/topic-tests/Makefile
+++ b/tests/topic-tests/Makefile
@@ -0,0 +1,10 @@
+# See https://github.com/bxparks/EpoxyDuino for documentation about this
+# Makefile to compile and run Arduino programs natively on Linux or MacOS.
+
+EXTRA_CXXFLAGS=-g3 -O0
+
+APP_NAME := topic-tests
+ARDUINO_LIBS := AUnit AceCommon AceTime TinyMqtt EspMock ESP8266WiFi  ESPAsync
+ARDUINO_LIB_DIRS := ../../../EspMock/libraries
+EPOXY_CORE := EPOXY_CORE_ESP8266
+include ../../../EpoxyDuino/EpoxyDuino.mk
--- a/tests/topic-tests/topic-tests.ino
+++ b/tests/topic-tests/topic-tests.ino
@@ -0,0 +1,85 @@
+#include <Arduino.h>
+#include <AUnit.h>
+#include <TinyMqtt.h>
+#include <map>
+#include <iostream>
+
+#define endl "\n"
+
+/**
+	* TinyMqtt / StringIndexer unit tests.
+	*
+	**/
+
+using namespace std;
+
+bool testTopicMatch(const char* a, const char* b, bool expected)
+{
+  Topic ta(a);
+  Topic tb(b);
+  bool match(ta.matches(tb));
+  cout << "  " << ta.c_str() << ' ';
+  if (match != expected)
+    cout << (expected ? " should match " : " should not match ");
+  else
+    cout << (expected ? " matches " : " unmatches ");
+  cout << tb.c_str() << endl;
+  return expected == match;
+}
+
+test(topic_matches)
+{
+  // matching
+  assertTrue(testTopicMatch("a/b/c"    , "a/b/c"     , true));
+  assertTrue(testTopicMatch("a/*/c"    , "a/xyz/c"   , true));
+  assertTrue(testTopicMatch("a/*/e"    , "a/b/c/d/e" , true));
+  assertTrue(testTopicMatch("a/*"      , "a/b/c/d/e" , true));
+  assertTrue(testTopicMatch("*/c"      , "a/b/c"     , true));
+  assertTrue(testTopicMatch("/*/c"     , "/a/b/c"    , true));
+  assertTrue(testTopicMatch("a/*"      , "a/b/c/d"   , true));
+  assertTrue(testTopicMatch("a/+/c"    , "a/b/c"     , true));
+  assertTrue(testTopicMatch("a/+/c/+/e", "a/b/c/d/e" , true));
+  assertTrue(testTopicMatch("a/*/c/+/e", "a/b/c/d/e" , true));
+  assertTrue(testTopicMatch("/+/b"     , "/a/b"      , true));
+  assertTrue(testTopicMatch("+"        , "a"         , true));
+  assertTrue(testTopicMatch("a/b/#"    , "a/b/c/d"   , true));
+  assertTrue(testTopicMatch("a/b/#"    , "a/b"       , true));
+  assertTrue(testTopicMatch("a/*/c"    , "a/*/c"     , true));
+
+  // not matching
+  assertTrue(testTopicMatch("a/b/c"    , "a/b/d"     , false));
+  assertTrue(testTopicMatch("a/b/c"    , "a/b/d"     , false));
+  assertTrue(testTopicMatch("a/*/e"    , "a/b/c/d/f" , false));
+  assertTrue(testTopicMatch("a/+"      , "a"         , false));
+  assertTrue(testTopicMatch("a/+"      , "a/b/d"     , false));
+  assertTrue(testTopicMatch("a/+/"     , "a/"        , false));
+
+  // $SYS topics
+  assertTrue(testTopicMatch("+/any"    , "$SYS/any"  , false));
+  assertTrue(testTopicMatch("*/any"    , "$SYS/any"  , false));
+  assertTrue(testTopicMatch("$SYS/any" , "$SYS/any"  , true));
+  assertTrue(testTopicMatch("$SYS/+/y" , "$SYS/a/y"  , true));
+  assertTrue(testTopicMatch("$SYS/#"   , "$SYS/a/y"  , true));
+
+  // not valid
+  assertTrue(testTopicMatch("a/#/b"    , "a/x/b"     , false));
+  assertTrue(testTopicMatch("a+"      , "a/b/d"     , false));
+  assertTrue(testTopicMatch("a/b/#/d"  , "a/b/c/d"   , false));
+
+}
+
+//----------------------------------------------------------------------------
+// setup() and loop()
+void setup() {
+	delay(1000);
+	Serial.begin(115200);
+	while(!Serial);
+
+	Serial.println("=============[ TinyMqtt StringIndexer TESTS ]========================");
+}
+
+void loop() {
+	aunit::TestRunner::run();
+
+	// if (Serial.available()) ESP.reset();
+}
Author	SHA1	Message	Date
hsaturn	d12096ef51	Ooops bad tag	2022-11-23 13:01:24 +01:00
hsaturn	ea56d21190	Merge branch 'main' of github.com:hsaturn/TinyMqtt into main	2022-11-23 12:56:35 +01:00
hsaturn	c802c895b6	Version 0.9.6 bump	2022-11-23 12:54:15 +01:00
hsaturn	074bca971f	Update README.md	2022-11-23 12:51:12 +01:00
hsaturn	7bd9c27b89	Merge branch 'main' of github.com:hsaturn/TinyMqtt into main	2022-11-21 04:42:30 +01:00
hsaturn	3e73673302	[tinymqtt-test] Fix lot of errors - TINY_MQTT_DEBUG was not set (no dump) - MqttClient::counter has disapeared (compilation error) - payload was badly displayed - broker/client names could be reused for client/brokers	2022-11-21 04:42:16 +01:00
hsaturn	4b12aaa198	Update README.md Unit tests in features	2022-11-21 01:47:47 +01:00
hsaturn	5f9cab8992	Update README.md Wildcards	2022-11-21 01:44:54 +01:00
hsaturn	96766f7091	[Topic] Wildcards added + wildcard added # wildcard added * wildcard added (but does not appear in mqtt specification...) $SYS messages compare is supported	2022-11-21 01:37:55 +01:00
hsaturn	354aec239f	[tests] Re-added debug mode in tests The EXTRA_FLAGS needs some clean before running tests. This commit allows to compile twice for this situation, but it is not perfect because EXTRA_CFLAGS can still cause some problems. The tests Makefile should be able to detect this and to group builds and tests with each own EXTRA flags.	2022-10-31 02:12:15 +01:00
hsaturn	3839a0a830	[tests] Fix unit tests timed out The debug-tests was changing the compilation (TINY_MQTT_DEBUG on) Thus the other tests were too long to execute due to Serial output emulation.	2022-10-31 01:49:11 +01:00
hsaturn	0444a4c348	[tests] removed useless code in debug-tests.ino	2022-10-31 01:35:21 +01:00
hsaturn	73207e4745	Renamed TCP_ASYNC define to TINY_MQTT_ASYNC for name consistency.	2022-10-31 01:24:41 +01:00
hsaturn	b7d44445af	[tests] Added a debug mode compilation phase (and fixed it)	2022-10-31 01:20:30 +01:00
hsaturn	cce6b2ecfc	Update README.md Added links for examples	2022-10-30 22:01:54 +01:00
hsaturn	883f1e27e6	Release 0.9.3	2022-10-30 21:47:58 +01:00
hsaturn	e7fc147424	Changed tab to spaces	2022-10-30 21:43:45 +01:00
hsaturn	2147b147fc	[Readme] Some minor changes	2022-10-30 21:42:59 +01:00
hsaturn	f5e9a43461	[StringIndexer] Fix compare bug and moved strToIndex to private strToIndex is dangerous because it can increment the use of a string, or create a new string. This method should only be called by IndexedString.	2022-10-30 21:41:52 +01:00
hsaturn	cabb56fc8c	[tests] Added -g3 for tests for debugging purposes	2022-10-30 20:44:44 +01:00
hsaturn	58786eb6d9	Release 0.9.2	2022-10-30 19:48:04 +01:00
hsaturn	776242b259	Release 0.9.1	2022-10-30 19:45:50 +01:00
hsaturn	a9d19c3218	[lib] Remove library.json	2022-10-30 18:31:46 +01:00
hsaturn	7bd299ec07	Use slim lint	2022-10-30 15:23:50 +01:00
hsaturn	107469cd78	Lint action, upgrade to latest	2022-10-30 15:13:42 +01:00
hsaturn	709e1fd567	Tabs changed to spaces (at least)	2022-10-30 13:26:33 +01:00
hsaturn	4eb8f18ebf	[MqttMessage] Rewrite of the length encoding	2022-10-30 13:24:05 +01:00
hsaturn	d5d27c8020	Merge pull request #25 from hsaturn/pr22 was pr#22 : added reply to message subscribe and unsubscribe	2022-01-10 05:28:08 +01:00
hsaturn	da3ec41d71	Update network-tests.ino Remove useless code	2022-01-10 05:27:15 +01:00
hsaturn	5f7b4537c8	Enhance PR#22	2022-01-05 02:03:42 +01:00
hsaturn	cce4fecac6	Fix test local_client_should_unregister_when_destroyed	2022-01-05 02:02:18 +01:00
hsaturn	737e217172	fix type return value	2022-01-05 02:01:22 +01:00
hsaturn	8fe3517894	added packed attribute for enums	2022-01-05 02:00:02 +01:00
hsaturn	710503663a	better type management	2022-01-05 01:59:16 +01:00
hsaturn	a5b8afc0bd	Added some ifdef for debugging purposes	2022-01-05 01:56:45 +01:00
terror	f1d3a15498	added reply to message subscribe and unsubscribe	2021-09-25 15:44:09 +03:00
hsaturn	dfd5983715	Rewrite comments and added hudge payload test	2021-09-20 01:57:40 +02:00
hsaturn	4dcc6a6cf4	Minor changes	2021-09-19 12:40:04 +02:00
hsaturn	b58f3e3d67	Merge branch 'issue_2_broken_large_payloads' into main	2021-09-17 22:35:28 +02:00
hsaturn	a6b3540cb8	Fix issue_2 : Broken large payloads	2021-09-17 22:32:00 +02:00
hsaturn	ccbf42f81b	howto added for building and running tests	2021-09-17 19:58:24 +02:00
hsaturn	d39c58d8f5	Fix issue_2 broken payload	2021-09-17 19:51:32 +02:00
hsaturn	36dde2c063	Fix for debugging for other platform than ESP	2021-08-09 11:24:27 +02:00
hsaturn	64a05bb60b	Release 0.7.9	2021-08-09 10:47:18 +02:00
hsaturn	bb89fc5284	Release 0.7.8	2021-08-09 10:45:17 +02:00
hsaturn	c1fd1bc907	Remove pending length test	2021-08-09 10:44:19 +02:00
hsaturn	d919188eb0	Merge pull request #15 from bxparks/epoxyfix Fix unit tests for EpoxyDuino	2021-08-09 10:39:26 +02:00
hsaturn	9c7f3b6b8e	Fix of decode length	2021-08-09 10:37:46 +02:00
Brian Park	88c7d552cb	Fix unit tests for EpoxyDuino	2021-08-08 19:37:04 -07:00
hsaturn	fab242e212	Version 0.7.6	2021-08-09 03:04:21 +02:00
hsaturn	56a2be621f	Fix message length error	2021-08-09 03:00:28 +02:00
hsaturn	c4cf39ab68	Fix aunit tests	2021-08-09 02:33:01 +02:00
hsaturn	90dea36ab0	Attempt to write more readable examples	2021-05-13 03:21:03 +02:00
hsaturn	25a721e06a	Attempt to write more readable examples	2021-05-13 03:21:03 +02:00
hsaturn	b228d35ab0	Attempt to write more readable examples	2021-05-13 03:21:03 +02:00
hsaturn	c70716a595	Attempt to write more readable examples	2021-05-13 03:21:03 +02:00
hsaturn	8d5cad5fec	Added overload of Client::publish, fix compilation	2021-05-13 03:21:03 +02:00
hsaturn	d5430228e5	Fix cr/lf bug Added echo on\|off for later vt100 terminal Added rnd(min,max) function Simplied every function Better parsing for getword (accept strings) Fix for blink command	2021-05-13 03:21:03 +02:00
hsaturn	91c1f96146	Update README.md links updates	2021-05-08 15:14:59 +02:00
hsaturn	f04a2a07c0	Fix aunit.yml	2021-04-28 21:22:07 +00:00
hsaturn	38f306c170	Fix compilation esp8266 esp32	2021-04-28 23:16:33 +02:00
hsaturn	024e80c9dc	Perpare for future ESP32 aunit tests	2021-04-28 21:00:31 +00:00
hsaturn	2249ddef7f	Release 0.7.5	2021-04-28 18:57:24 +02:00
hsaturn	e193929f8f	changed every command	2021-04-28 18:56:17 +02:00
hsaturn	e00e31de33	Fix build in Esp8266 mode Modify dump() functions	2021-04-28 18:55:57 +02:00
hsaturn	20292b7b7b	Fix example syntax	2021-04-28 08:24:44 +02:00
hsaturn	26de3befa8	TinyTest Esp32 port Update library definition	2021-04-28 08:19:55 +02:00
hsaturn	1098466055	Update README.md	2021-04-28 08:14:46 +02:00
hsaturn	2d3663e78c	Update README.md	2021-04-28 07:32:56 +02:00
hsaturn	5e16282ad0	Disable ci.yml	2021-04-21 01:10:35 +02:00
hsaturn	e35a43c4a4	Trying to remove unsupported platform that break ci.yml	2021-04-21 01:05:31 +02:00
hsaturn	087a203ba0	Create ci.yml	2021-04-21 00:56:49 +02:00
hsaturn	5d313bbf5e	Rewrite examples	2021-04-12 00:27:25 +02:00
hsaturn	ce896f02c4	Merge pull request #6 from hsaturn/AsyncAndWifi AsyncTcp can be activated by removing the command on TCP_ASYNC in TinyMqtt.h But the code is not bug free yet.	2021-04-11 23:33:29 +02:00
hsaturn	d3210c3c93	Merge branch 'main' into AsyncAndWifi	2021-04-11 23:30:13 +02:00
hsaturn	23f1207718	Lot of new functions for tinytest - command every allowing to add peridic evaluations very usefull for benchmarks and load tests - on/off command	2021-04-11 23:27:15 +02:00
hsaturn	122ab88960	Rewrite client-with-wifi.ino	2021-04-11 23:26:49 +02:00
hsaturn	28b0ac1611	Fix missing receive loop for mqttclient	2021-04-11 21:21:48 +02:00
hsaturn	1cfb5cfab1	Allow multiple command per line separated by ;	2021-04-11 19:19:06 +02:00
hsaturn	b023cd67a9	Fix AUnit in debug mode / Not async	2021-04-11 17:02:24 +02:00
hsaturn	24ee6b5201	Fixes in WiFiClient mode	2021-04-11 16:33:12 +02:00
hsaturn	2e92a98db2	Trying to fuse togeter Async and not async version	2021-04-11 15:51:33 +02:00
hsaturn	c59bddfd39	Implementation of Unsuback (unless MqttClient disconnects)	2021-04-11 01:58:44 +02:00
hsaturn	7bdb9cc0cd	Tinytest, allow to blink output 0	2021-04-11 01:57:58 +02:00
hsaturn	be62699702	Fix connect problem with MqttClient	2021-04-11 00:48:04 +02:00
hsaturn	77da47e1da	Update README.md	2021-04-10 18:02:48 +02:00
hsaturn	88797bfafd	Added AUnit	2021-04-10 18:02:28 +02:00
hsaturn	1e3b37623d	Fix AUnit build	2021-04-10 17:54:46 +02:00
hsaturn	ba6a96976a	ESP32 version that could work	2021-04-10 17:47:21 +02:00
hsaturn	6afd3939b3	Merge remote-tracking branch 'origin/AsyncTcp' into main	2021-04-10 17:23:53 +02:00
hsaturn	2ffe0c13fa	README.md update	2021-04-10 17:23:46 +02:00
hsaturn	fe3f8d7b32	Very promising async commit	2021-04-10 17:19:57 +02:00
hsaturn	d1c7ebe134	Added unsubscribe to tinytest	2021-04-10 17:18:53 +02:00
hsaturn	aa0ed9a7a7	Bad merge fix	2021-04-10 17:18:53 +02:00
hsaturn	48eb0daf9a	Fix bug in unsubscription list	2021-04-10 17:16:25 +02:00
hsaturn	34c05bc37a	Fix compilation in DEBUG mode	2021-04-10 17:16:25 +02:00
hsaturn	7c96c4a5cc	Fix warning	2021-04-10 17:16:25 +02:00
hsaturn	b280196395	Added mqDns to tinytest	2021-04-10 17:16:25 +02:00
hsaturn	c75f4893e8	AsyncTcp AsyncTcp	2021-04-10 17:16:25 +02:00
hsaturn	d666f6a53b	AsyncTCP (to be continued)	2021-04-10 17:16:25 +02:00
hsaturn	7ef18de755	Very promising async commit	2021-04-10 17:16:25 +02:00
hsaturn	838df3a34a	Added unsubscribe to tinytest	2021-04-10 17:15:21 +02:00
hsaturn	ad602194cf	Fix bug in unsubscription list	2021-04-10 16:51:56 +02:00
hsaturn	afc9370e3e	Fix compilation in DEBUG mode	2021-04-10 16:51:35 +02:00
hsaturn	d96143f185	Fix warning	2021-04-10 16:50:45 +02:00
hsaturn	9c939a5667	Added mqDns to tinytest	2021-04-10 16:50:14 +02:00
hsaturn	8a25155fd8	Bad merge fix	2021-04-10 16:06:45 +02:00
hsaturn	d64ffe772e	Merge branch 'AsyncTcp' of github.com:hsaturn/TinyMqtt into AsyncTcp	2021-04-10 15:57:13 +02:00
hsaturn	db610e6f0f	Merge branch 'AsyncTcp' of github.com:hsaturn/TinyMqtt into AsyncTcp	2021-04-10 15:52:04 +02:00
hsaturn	6711f30ad0	AsyncTcp AsyncTcp	2021-04-10 15:51:29 +02:00
hsaturn	3e8d34e4e7	Very promising async commit Very promising async commit	2021-04-10 15:47:49 +02:00
hsaturn	67a296eb28	Fix too many things in StringIndexer test	2021-04-10 15:39:42 +02:00
hsaturn	e90076d010	AsyncTcp	2021-04-10 14:03:36 +02:00
hsaturn	f42464c173	AsyncTCP (to be continued)	2021-04-10 13:58:23 +02:00
hsaturn	36b452281f	Very promising async commit	2021-04-10 13:42:43 +02:00
hsaturn	077c0c6adf	Typo in libraries text	2021-04-09 23:29:32 +02:00
hsaturn	6f1e5d7488	Added blink command allowing to check if loop slows down	2021-04-09 23:27:50 +02:00
hsaturn	ca8ad88109	Refactoring of EspMock	2021-04-07 06:44:15 +02:00
hsaturn	986a9c592d	Update README.md	2021-04-05 14:18:21 +02:00
hsaturn	62868cba34	Fix payload test (the payload was sent, the test was buggy)	2021-04-05 13:54:40 +02:00
hsaturn	80dade00fe	Avoid unitialized values	2021-04-05 13:54:09 +02:00
hsaturn	8254bd4831	gitignore removed (not properly used)	2021-04-05 13:53:35 +02:00
hsaturn	5834a278c7	Release 0.7.3	2021-04-04 06:36:47 +02:00
hsaturn	146d0de1d4	MqttClient: bug fix, connection lost at each publish received	2021-04-04 06:35:50 +02:00
hsaturn	297a22efb5	Big rewrite of MqttClient in order to avoid code duplicate	2021-04-04 05:57:48 +02:00
hsaturn	510ff514a9	[tests] Changed assertions	2021-04-04 01:07:12 +02:00
hsaturn	ad6f7155e5	Added test for StringIndexer	2021-04-03 21:11:54 +02:00
hsaturn	3ed5874373	Fix compilation	2021-04-02 19:57:04 +02:00
hsaturn	e1a936e081	Merge branch 'main' of github.com:hsaturn/TinyMqtt into main	2021-04-02 19:23:53 +02:00
hsaturn	0757a95fbf	Keywords updated, code clean	2021-04-02 19:22:59 +02:00
hsaturn	7c8d71262f	Fix test (not yet finished)	2021-04-02 18:59:07 +02:00
hsaturn	138ce973f2	Typos in libraries	2021-04-02 18:48:37 +02:00
hsaturn	bf499117b7	Merge branch 'main' of github.com:hsaturn/TinyMqtt into main	2021-03-31 19:12:28 +02:00
hsaturn	4ed6f72602	Merge branch 'test' into main	2021-03-31 19:11:24 +02:00
hsaturn	87a78c549f	Fix crash at end of unit tests	2021-03-31 19:09:43 +02:00
hsaturn	5211360b91	Local tests added	2021-03-31 19:09:05 +02:00
hsaturn	549a23ffb7	Fix delete was not really deleting in tinytest	2021-03-31 10:40:06 +02:00
hsaturn	3a1af655d7	Fix compilation problem	2021-03-31 00:33:15 +02:00
hsaturn	e71ffefc5a	Fixed a useless test and modified MqttClient constructors	2021-03-31 00:22:31 +02:00
hsaturn	b6a0dde2b1	json	2021-03-30 08:52:46 +02:00
hsaturn	babc391632	Added json	2021-03-30 08:52:10 +02:00
hsaturn	27bdbb9a0b	str	2021-03-30 08:41:30 +02:00
hsaturn	6a9e158428	results	2021-03-30 08:39:02 +02:00
hsaturn	6fc6794dc3	result0.yaml	2021-03-30 08:37:25 +02:00
hsaturn	1eaa514579	result.yaml	2021-03-30 08:35:33 +02:00
hsaturn	7af4c2ca69	Added .o to gitignore	2021-03-30 08:21:56 +02:00
hsaturn	a340558460	Fix tests	2021-03-30 08:21:33 +02:00
hsaturn	9a7db237d3	Renamed local to nowifi as local will be used for local (127.0.0.1) tests	2021-03-30 08:15:13 +02:00
hsaturn	91e083e7b0	Merge branch 'linter' into main	2021-03-29 23:58:00 +02:00
hsaturn	97adc985e6	Code clean	2021-03-29 23:56:36 +02:00
hsaturn	6fcfc9dfc0	ptr	2021-03-29 23:20:49 +02:00
hsaturn	a6596ffc89	Fix ptr	2021-03-29 23:06:40 +02:00
hsaturn	533ab0c70d	Try to mock Esp	2021-03-29 21:47:14 +02:00
hsaturn	d5dd896b45	MqttClient::unsubscribe implemented	2021-03-29 20:48:45 +02:00
hsaturn	bd7fa8f39c	Update readme.md	2021-03-29 20:47:14 +02:00
hsaturn	6395e931ce	refix EspWifi	2021-03-29 20:47:14 +02:00
hsaturn	635fee6f7c	ESP8266WiFi lib added for aunit	2021-03-29 20:47:14 +02:00
hsaturn	dc2420d88e	Fix makefile	2021-03-29 20:47:14 +02:00
hsaturn	2fbc46cbe2	Revert auint	2021-03-29 20:47:14 +02:00
hsaturn	a003156ae1	Fix aunit	2021-03-29 20:47:14 +02:00
hsaturn	913e1aa7ae	Fixed make target	2021-03-29 20:46:59 +02:00
hsaturn	8272515bd7	Fixed make target	2021-03-29 20:46:46 +02:00
hsaturn	9a7f6a3020	Fixed make target	2021-03-29 20:46:46 +02:00
hsaturn	fead702d9f	Added makefile for aunit	2021-03-29 20:46:46 +02:00
hsaturn	eaf938f2fd	Test aunit	2021-03-29 20:46:46 +02:00
hsaturn	8eefa63f45	Lint fixes	2021-03-29 20:46:46 +02:00
hsaturn	9d48c436d8	test	2021-03-29 20:46:46 +02:00
hsaturn	792a28e831	deleted	2021-03-29 20:45:33 +02:00
hsaturn	9407193454	MqttClient::unsubscribe implemented	2021-03-29 20:39:10 +02:00
hsaturn	602050f309	Update readme.md	2021-03-29 11:45:51 +02:00
hsaturn	1a70c90af2	refix EspWifi	2021-03-29 00:01:32 +02:00
hsaturn	ed4091c53e	ESP8266WiFi lib added for aunit	2021-03-28 23:57:06 +02:00
hsaturn	f2a805f724	Fix makefile	2021-03-28 23:50:50 +02:00
hsaturn	3083bcf071	Revert auint	2021-03-28 23:44:11 +02:00
hsaturn	d01f46dbc1	Fix aunit	2021-03-28 23:42:57 +02:00
hsaturn	39b2257619	Merge branch 'linter' of github.com:hsaturn/TinyMqtt into linter	2021-03-28 23:39:50 +02:00
hsaturn	60d385189b	Fixed make target	2021-03-28 23:39:37 +02:00
hsaturn	82c5b971e9	Release 0.7.0	2021-03-28 23:34:54 +02:00
hsaturn	3f2c1c57e1	Fixed make target	2021-03-28 23:30:19 +02:00
hsaturn	e550197d0a	Fixed make target	2021-03-28 23:28:48 +02:00
hsaturn	253bc9b3f5	Added makefile for aunit	2021-03-28 23:26:53 +02:00
hsaturn	96d8018960	Test aunit	2021-03-28 23:16:07 +02:00
hsaturn	505cacc2df	Lint fixes	2021-03-28 23:09:10 +02:00
hsaturn	62848056a2	test	2021-03-28 23:01:14 +02:00
hsaturn	01998e74ec	Test linter	2021-03-28 22:59:42 +02:00
hsaturn	5f46fd304c	Release 0.7.0	2021-03-28 22:47:13 +02:00
hsaturn	213d637eaf	Code cleaning	2021-03-28 21:31:10 +02:00
hsaturn	3bb2dd5a81	Code cleaning	2021-03-28 21:29:02 +02:00
hsaturn	7d9ab6381d	Disconnect added (finally)	2021-03-28 21:28:06 +02:00