Merge branch 'main' into timeout

[readme] Words about retain
[fixes] Timeout and broker to broker modifications
2023-03-23 13:46:02 +01:00 · 2023-03-23 13:44:48 +01:00 · 2023-03-23 13:42:09 +01:00 · 2023-03-22 20:37:28 +01:00 · 2023-03-22 20:31:41 +01:00 · 2023-03-22 20:31:05 +01:00
40 changed files with 3798 additions and 1902 deletions
--- a/.github/workflows/aunit.yml
+++ b/.github/workflows/aunit.yml
@@ -9,7 +9,7 @@ on: [push]
 jobs:
  build:

-    runs-on: ubuntu-18.04
+    runs-on: ubuntu-20.04

    steps:
    - uses: actions/checkout@v2
@@ -17,9 +17,10 @@ jobs:
    - name: Setup
      run: |
        cd ..
-        git clone https://github.com/bxparks/EpoxyDuino
+        git clone https://github.com/hsaturn/TinyConsole
+        git clone https://github.com/hsaturn/EpoxyDuino
        git clone https://github.com/bxparks/AceRoutine
-        git clone https://github.com/bxparks/AUnit
+        git clone https://github.com/hsaturn/AUnit
        git clone https://github.com/bxparks/AceCommon
        git clone https://github.com/hsaturn/EspMock
    - name: Verify tests
--- a/README.md
+++ b/README.md
@@ -10,18 +10,41 @@

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

+### Statuses of all unit tests of TinyMqtt and its dependencies
+
+| Project     | Unit tests result |
+| ----------- | ------------ |
+| TinyMqtt    | [![](https://github.com/hsaturn/TinyMqtt/actions/workflows/aunit.yml/badge.svg)](https://github.com/hsaturn/TinyMqtt/actions/workflows/aunit.yml) |
+| Dependencies                  ||
+| TinyConsole | [![](https://github.com/hsaturn/TinyConsole/actions/workflows/aunit.yml/badge.svg)](https://github.com/hsaturn/TinyConsole/actions/workflows/aunit.yml) |
+| EpoxyDuino  | [![AUnit Tests](https://github.com/hsaturn/EpoxyDuino/actions/workflows/aunit_tests.yml/badge.svg)](https://github.com/hsaturn/EpoxyDuino/actions/workflows/aunit_tests.yml) |
+| EspMock     | [![AUnit Tests](https://github.com/hsaturn/EspMock/actions/workflows/aunit.yml/badge.svg)](https://github.com/hsaturn/EspMock/actions/workflows/aunit.yml) |
+| AUnit | [![AUnit Tests](https://github.com/hsaturn/AUnit/actions/workflows/aunit_tests.yml/badge.svg)](https://github.com/hsaturn/AUnit/actions/workflows/aunit_tests.yml) |
+| AceRoutine | [![AUnit Tests](https://github.com/bxparks/AceRoutine/actions/workflows/aunit_tests.yml/badge.svg)](https://github.com/bxparks/AceRoutine/actions/workflows/aunit_tests.yml) |
+
 ## Features

+- Supports retained messages (not activated by default)
+- Async Wifi compatible (me-no-dev/ESPAsyncTCP@^1.2.2)
 - 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
+
+## 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

@@ -33,14 +56,22 @@ TinyMqtt is a small, fast and capable Mqtt Broker and Client for Esp8266 / Esp32

 | 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.

+## Retained messages
+
+Qos 1 is not supported, but retained messages are. So a new subscription is able to send old messages.
+This feature is disabled by default.
+The default retain parameter of MqttBroker::MqttBroker takes an optional (0 by default) number of retained messages.
+MqttBroker::retain(n) will also make the broker store n messages at max.
+
 ## Standalone mode (zeroconf)
 -> The zeroconf mode is not yet implemented
 zeroconf clients to connect to broker on local network.
@@ -59,7 +90,7 @@ no need for having tons of clients (also RAM is the problem with many clients)
 * ~~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)
+* ~~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)

--- a/bump_version.sh
+++ b/bump_version.sh
@@ -0,0 +1,61 @@
+#!/bin/bash
+current_version=$(git describe --tags --abbrev=0)
+if [ "$1" == "-d" ]; then
+  do=0
+  shift
+else
+  do=1
+fi
+if [ "$1" == "" ]; then
+	echo
+	echo "Syntax: $0 [-d] {new_version} [commit message]"
+	echo
+	echo "  -d : dry run, generate json and update properties but do not run git commands"
+	echo ""
+	echo "  Current version: $current_version"
+	echo
+else
+	echo "Current version: ($current_version)"
+	echo "New version    : ($1)"
+	echo -n "Do you want to proceed ? "
+	read a
+	if [ "$a" == "y" ]; then
+		echo "Doing this..."
+		grep $current_version library.properties
+		if [ "$?" == "0" ]; then
+			sed -i "s/$current_version/$1/" library.properties
+
+      cp library.json.skeleton library.json
+      while ifs= read -r line; do
+        name=$(echo "$line" | sed "s/=.*//g")
+        value=$(echo "$line" | cut -d= -f 2 | sed 's/"//g')
+        echo "  Replacing $name in json"
+        if [ "$name" == "depends" ]; then
+          depends=$(echo "$value" | sed "s/,/ /g")
+          echo "  Depends=$depends"
+        fi
+        sed -i "s@#$name@$value@g" library.json
+      done < library.properties
+      deps=""
+      for depend in $depends; do
+        if [ "$deps" != "" ]; then
+          deps="$deps, "
+        fi
+        deps="$deps'$depend' : '*'"
+      done
+      sed -i "s@#dependencies@$deps@g" library.json
+      sed -i "s/'/\"/g" library.json
+      if [ "$do" == "1" ]; then
+        echo "Pushing all"
+        git tag $1
+        git add library.properties
+        git add library.json
+        git commit -m "Release $1 $2"
+        git push
+        git push --tags
+      fi
+		else
+			echo "Current version does not match library.property version, aborting"
+		fi
+	fi
+fi
--- a/examples/advanced/mqtt_class_binder/mqtt_class_binder.ino
+++ b/examples/advanced/mqtt_class_binder/mqtt_class_binder.ino
@@ -0,0 +1,134 @@
+#include <TinyMqtt.h>   // https://github.com/hsaturn/TinyMqtt
+#include <MqttClassBinder.h>
+
+/**
+  * Example on how to bind a class:onPublish function
+  *
+  * 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
+  *      - can still report to a 'main' broker (TODO see documentation that have to be written)
+  *      - accepts external clients
+  *      - MqttClassBinder allows to mix together many mqtt sources
+  *
+  * cons - Takes more memory (24 more bytes for the one MqttClassBinder<Class>
+  *      - a bit hard to understand
+  *
+  */
+
+const char *ssid     = "";
+const char *password = "";
+
+std::string topic_b="sensor/btemp";
+std::string topic_sender= "sensor/counter";
+
+MqttBroker broker(1883);
+
+MqttClient mqtt_a(&broker);
+MqttClient mqtt_b(&broker);
+MqttClient mqtt_sender(&broker);
+
+class MqttReceiver: public MqttClassBinder<MqttReceiver>
+{
+  public:
+
+    void onPublish(const MqttClient* source, const Topic& topic, const char* payload, size_t /* length */)
+    {
+      Serial
+        << "   * MqttReceiver received topic (" << topic.c_str() << ")"
+        << " from (" << source->id() << "), "
+        << " payload: (" << payload << ')' << endl;
+    }
+};
+
+void setup()
+{
+  Serial.begin(115200);
+  delay(500);
+  Serial << "Clients with wifi " << endl;
+
+  WiFi.mode(WIFI_STA);
+  WiFi.begin(ssid, password);
+
+  while (WiFi.status() != WL_CONNECTED)
+  {
+    Serial << '-'; delay(500);
+  	if (strlen(ssid)==0)
+	  	Serial << "****** PLEASE EDIT THE EXAMPLE AND MODIFY ssid/password *************" << endl;
+  }
+
+  Serial << "Connected to " << ssid << "IP address: " << WiFi.localIP() << endl;
+
+  broker.begin();
+
+  MqttReceiver* receiver = new MqttReceiver;
+
+  // receiver will receive both publication from two MqttClient
+  // (that could be connected to two different brokers)
+  MqttClassBinder<MqttReceiver>::onPublish(&mqtt_a, receiver);
+  MqttClassBinder<MqttReceiver>::onPublish(&mqtt_b, receiver);
+
+  mqtt_a.id("mqtt_a");
+  mqtt_b.id("mqtt_b");
+  mqtt_sender.id("sender");
+
+  mqtt_a.subscribe(topic_b);
+  mqtt_b.subscribe(topic_sender);
+
+}
+
+void loop()
+{
+  broker.loop();  // Don't forget to add loop for every broker and clients
+
+  mqtt_a.loop();
+  mqtt_b.loop();
+  mqtt_sender.loop();
+
+  // ============= client A publish ================
+  {
+    static const int interval = 5000;  // publishes every 5s (please avoid usage of delay())
+    static uint32_t timer = millis() + interval;
+
+    if (millis() > timer)
+    {
+      static int counter = 0;
+      Serial << "Sender is publishing " << topic_sender.c_str() << endl;
+      timer += interval;
+      mqtt_sender.publish(topic_sender, "sent by Sender, message #"+std::string(String(counter++).c_str()));
+    }
+  }
+
+  // ============= client B publish ================
+  {
+    static const int interval = 7000;	// will send topic each 7s
+    static uint32_t timer = millis() + interval;
+    static int temperature;
+
+    if (millis() > timer)
+    {
+      Serial << "B is publishing " << topic_b.c_str() << endl;
+      timer += interval;
+      mqtt_b.publish(topic_b, "sent by B: temp="+std::string(String(16+temperature++%6).c_str()));
+    }
+  }
+}
--- a/examples/simple-broker/simple-broker.ino
+++ b/examples/simple-broker/simple-broker.ino
@@ -1,7 +1,9 @@
 #include "TinyMqtt.h"   // https://github.com/hsaturn/TinyMqtt

-#define PORT 1883
-MqttBroker broker(PORT);
+const uint16_t PORT 1883;
+const uint8_t  RETAIN = 10;  // Max retained messages
+
+MqttBroker broker(PORT, RETAIN);

 /** Basic Mqtt Broker
  *
@@ -16,6 +18,8 @@ MqttBroker broker(PORT);
  *  Your ESP will become a MqttBroker.
 	*  You can test it with any client such as mqtt-spy for example
 	*
+	* Messages are retained *only* if retain > 0
+	*
  */

 const char* ssid = "";
@@ -26,7 +30,7 @@ void setup()
  Serial.begin(115200);

 	if (strlen(ssid)==0)
-		Serial << "****** PLEASE MODIFY ssid/password *************" << endl;
+		Console << TinyConsole::red << "****** PLEASE MODIFY ssid/password *************" << endl;

  WiFi.mode(WIFI_STA);
  WiFi.begin(ssid, password);
@@ -35,10 +39,10 @@ void setup()
    Serial << '.';
    delay(500);
  }
-  Serial << "Connected to " << ssid << "IP address: " << WiFi.localIP() << endl;  
+  Console << TinyConsole::green << "Connected to " << ssid << "IP address: " << WiFi.localIP() << endl;

  broker.begin();
-  Serial << "Broker ready : " << WiFi.localIP() << " on port " << PORT << endl;
+  Console << "Broker ready : " << WiFi.localIP() << " on port " << PORT << endl;
 }

 void loop()
--- a/examples/simple-client/simple-client.ino
+++ b/examples/simple-client/simple-client.ino
@@ -1,6 +1,7 @@
 #include "TinyMqtt.h"    // https://github.com/hsaturn/TinyMqtt
+#include "TinyStreaming.h" // https://github.com/hsaturn/TinyConsole

-/** Simple Client (The simplest configuration)
+/** Simple Client (The simplest configuration, client only sends topics)
  *
  *
  *                   +--------+
@@ -55,7 +56,7 @@ void setup()

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

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

 void loop()
--- a/examples/tinymqtt-test/tinymqtt-test.ino
+++ b/examples/tinymqtt-test/tinymqtt-test.ino
--- a/library.json
+++ b/library.json
@@ -0,0 +1,20 @@
+{
+    "name": "TinyMqtt",
+    "keywords": "ethernet, mqtt, m2m, iot",
+    "description": "MQTT is a lightweight messaging protocol. This library allows to host a broker or to use a mqtt client in your ESP 8266 or 32 WROOM. It does support MQTT 3.1.1 with QoS",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/hsaturn/TinyMqtt.git"
+    },
+    "dependencies":
+    { "hsaturn/TinyConsole" : "*" },
+    "version": "0.9.19",
+    "exclude": "",
+    "examples": "examples/*/*.ino",
+    "frameworks": "arduino",
+    "platforms": [
+        "atmelavr",
+        "espressif8266",
+        "espressif32"
+    ]
+}
--- a/library.json.skeleton
+++ b/library.json.skeleton
@@ -0,0 +1,20 @@
+{
+    "name": "#name",
+    "keywords": "ethernet, mqtt, m2m, iot",
+    "description": "#paragraph",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/hsaturn/TinyMqtt.git"
+    },
+    "dependencies":
+    { #dependencies },
+    "version": "#version",
+    "exclude": "",
+    "examples": "examples/*/*.ino",
+    "frameworks": "arduino",
+    "platforms": [
+        "atmelavr",
+        "espressif8266",
+        "espressif32"
+    ]
+}
--- a/library.properties
+++ b/library.properties
@@ -1,11 +1,11 @@
 name=TinyMqtt
-version=0.8.0
+version=0.9.19
 author=Francois BIOT, HSaturn, <hsaturn@gmail.com>
-maintainer=Francois BIOT, HSaturn, <hsaturn@gmail.com>
+maintainer=Francois BIOT <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 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.
+paragraph=MQTT is a lightweight messaging protocol. This library allows to host a broker or to use a mqtt client in your ESP 8266 or 32 WROOM. It does support MQTT 3.1.1 with QoS=0, and is intented to be as smallest as possible, keeping a good efficiency (about 1k msg per second on ESP8266 12F).
 category=Communication
 url=https://github.com/hsaturn/TinyMqtt
 architectures=*
+depends=hsaturn/TinyConsole
 includes=TinyMqtt.h
-depends=AsyncTCP
--- a/src/MqttClassBinder.h
+++ b/src/MqttClassBinder.h
@@ -0,0 +1,72 @@
+// MqttReceiver must implement onPublish(...)
+template <class MqttReceiver>
+class MqttClassBinder
+{
+  public:
+    MqttClassBinder()
+    {
+      unregister(this);
+    }
+    ~MqttClassBinder() { unregister(this); }
+
+    static void onUnpublished(MqttClient::CallBack handler)
+    {
+      unrouted_handler = handler;
+    }
+
+    static void onPublish(MqttClient* client, MqttReceiver* dest)
+    {
+      routes.insert(std::pair<MqttClient*, MqttReceiver*>(client, dest));
+      client->setCallback(onRoutePublish);
+    }
+
+    void onPublish(const MqttClient* client, const Topic& topic, const char* payload, size_t length)
+    {
+      static_cast<MqttReceiver*>(this)->MqttReceiver::onPublish(client, topic, payload, length);
+    }
+
+    static size_t size() { return routes.size(); }
+
+    static void reset() { routes.clear(); }
+
+  private:
+
+    static void onRoutePublish(const MqttClient* client, const Topic& topic, const char* payload, size_t length)
+    {
+      bool unrouted = true;
+      auto receivers = routes.equal_range(client);
+      for(auto it = receivers.first; it != receivers.second; ++it)
+      {
+        it->second->onPublish(client, topic, payload, length);
+        unrouted = false;
+      }
+
+      if (unrouted and unrouted_handler)
+      {
+        unrouted_handler(client, topic, payload, length);
+      }
+    }
+
+  private:
+    void unregister(MqttClassBinder<MqttReceiver>* which)
+    {
+      if (routes.size()==0) return;   // bug in map stl
+      for(auto it=routes.begin(); it!=routes.end(); it++)
+        if (it->second == which)
+        {
+          routes.erase(it);
+          return;
+        }
+    }
+
+  static std::multimap<const MqttClient*, MqttClassBinder<MqttReceiver>*> routes;
+  static MqttClient::CallBack unrouted_handler;
+
+};
+
+template<class MqttReceiver>
+std::multimap<const MqttClient*, MqttClassBinder<MqttReceiver>*> MqttClassBinder<MqttReceiver>::routes;
+
+template<class MqttReceiver>
+MqttClient::CallBack MqttClassBinder<MqttReceiver>::unrouted_handler = nullptr;
+
--- a/src/MqttStreaming.h
+++ b/src/MqttStreaming.h
@@ -1,413 +0,0 @@
-/* MqttStreaming.h - Fork of Streaming.h adding std::string and with some minor fixes
- * (I have to speek to the author in order to include my changes to his library if possible)
- **/
-
-/*
-  Streaming.h - Arduino library for supporting the << streaming operator
-  Copyright (c) 2010-2012 Mikal Hart.  All rights reserved.
-
-  This library is free software; you can redistribute it and/or
-  modify it under the terms of the GNU Lesser General Public
-  License as published by the Free Software Foundation; either
-  version 2.1 of the License, or (at your option) any later version.
-
-  This library is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-  Lesser General Public License for more details.
-
-  You should have received a copy of the GNU Lesser General Public
-  License along with this library; if not, write to the Free Software
-  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
-*/
-
-/*
-  Version 6 library changes
-    Copyright (c) 2019 Gazoodle. All rights reserved.
-
-  1.  _BASED moved to template to remove type conversion to long and
-      sign changes which break int8_t and int16_t negative numbers. 
-      The print implementation still upscales to long for it's internal
-      print routine.
-
-  2.  _PAD added to allow padding & filling of characters to the stream
-
-  3.  _WIDTH & _WIDTHZ added to allow width printing with space padding
-      and zero padding for numerics
-
-  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) || defined(EPOXY_DUINO)
-#include "Arduino.h"
-#else
-#ifndef STREAMING_CONSOLE
-#include "WProgram.h"
-#endif
-#endif
-
-#include <string>
-
-#if defined(ARDUINO_ARCH_AVR) || defined(ARDUINO_ARCH_MEGAAVR)
-// No stl library, so need trivial version of std::is_signed ...
-namespace std {
-template<typename T>
-  struct is_signed { static const bool value = false; };
-  template<>
-  struct is_signed<int8_t> { static const bool value = true; };
-  template<>
-  struct is_signed<int16_t> { static const bool value = true; };
-  template<>
-  struct is_signed<int32_t> { static const bool value = true; };
-};
-#else
-#include <type_traits>
-#endif
-
-#define STREAMING_LIBRARY_VERSION 6
-
-#if !defined(typeof)
-#define typeof(x) __typeof__(x)
-#endif
-
-// PrintBuffer implementation of Print, a small buffer to print in
-// see its use with pad_float()
-template <size_t N>
-class PrintBuffer : public Print
-{
-  size_t  pos = 0;
-  char    str[N] {};
-public:
-  inline const char *operator() () 
-  { return str; };
-  
-  // inline void clear() 
-  // { pos = 0; str[0] = '\0'; };
-  
-  inline size_t write(uint8_t c) 
-  { return write(&c, 1); };
-  
-  inline size_t write(const uint8_t *buffer, size_t size)
-  {
-    size_t s = std::min(size, N-1 - pos); // need a /0 left
-    if (s)
-    {
-      memcpy(&str[pos], buffer, s);
-      pos += s;
-    }
-    return s;
-  };
-};
-
-// Generic template
-template<class T>
-inline Print &operator <<(Print &stream, const T &arg)
-{ stream.print(arg); return stream; }
-
-// TODO sfinae maybe could do the trick ?
-inline Print &operator <<(Print &stream, const std::string &str)
-{ stream.print(str.c_str()); return stream; }
-
-template<typename T>
-struct _BASED
-{
-  T val;
-  int base;
-  _BASED(T v, int b): val(v), base(b)
-  {}
-};
-
-#if ARDUINO >= 100
-
-struct _BYTE_CODE
-{
-  byte val;
-  _BYTE_CODE(byte v) : val(v)
-  {}
-};
-#define _BYTE(a)    _BYTE_CODE(a)
-
-inline Print &operator <<(Print &obj, const _BYTE_CODE &arg)
-{ obj.write(arg.val); return obj; }
-
-#else
-
-#define _BYTE(a)    _BASED<typeof(a)>(a, BYTE)
-
-#endif
-
-#define _HEX(a)     _BASED<typeof(a)>(a, HEX)
-#define _DEC(a)     _BASED<typeof(a)>(a, DEC)
-#define _OCT(a)     _BASED<typeof(a)>(a, OCT)
-#define _BIN(a)     _BASED<typeof(a)>(a, BIN)
-
-// Specialization for class _BASED
-// Thanks to Arduino forum user Ben Combee who suggested this
-// clever technique to allow for expressions like
-//   Serial << _HEX(a);
-
-template<typename T>
-inline Print &operator <<(Print &obj, const _BASED<T> &arg)
-{ obj.print(arg.val, arg.base); return obj; }
-
-#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
-// feature like this:
-//   Serial << _FLOAT(gps_latitude, 6); // 6 digits of precision
-
-struct _FLOAT
-{
-  double val; // only Print::print(double)
-  int digits;
-  _FLOAT(double v, int d): val(v), digits(d)
-  {}
-};
-
-inline Print &operator <<(Print &obj, const _FLOAT &arg)
-{ obj.print(arg.val, arg.digits); return obj; }
-#endif
-
-// Specialization for enum _EndLineCode
-// Thanks to Arduino forum user Paul V. who suggested this
-// clever technique to allow for expressions like
-//   Serial << "Hello!" << endl;
-
-enum _EndLineCode { endl };
-
-inline Print &operator <<(Print &obj, _EndLineCode)
-{ obj.println(); return obj; }
-
-// Specialization for padding & filling, mainly utilized
-// by the width printers
-//
-//  Use like 
-//    Serial << _PAD(10,' ');   // Will output 10 spaces
-//    Serial << _PAD(4, '0');   // Will output 4 zeros
-struct _PAD
-{
-  int8_t width;
-  char   chr;
-  _PAD(int8_t w, char c) : width(w), chr(c) {}
-};
-
-inline Print &operator <<(Print& stm, const _PAD &arg)
-{
-  for(int8_t i = 0; i < arg.width; i++)
-    stm.print(arg.chr);
-  return stm;
-}
-
-// Specialization for width printing
-//
-//    Use like                            Result
-//    --------                            ------
-//    Serial << _WIDTH(1,5)               "    1"
-//    Serial << _WIDTH(10,5)              "   10"
-//    Serial << _WIDTH(100,5)             "  100"
-//    Serial << _WIDTHZ(1,5)              "00001"
-//
-//  Great for times & dates, or hex dumps
-//
-//    Serial << _WIDTHZ(hour,2) << ':' << _WIDTHZ(min,2) << ':' << _WIDTHZ(sec,2)
-//
-//    for(int index=0; index<byte_array_size; index++)
-//      Serial << _WIDTHZ(_HEX(byte_array[index]))
-
-template<typename T>
-struct __WIDTH
-{
-  const T val;
-  int8_t width;
-  char pad;
-  __WIDTH(const T& v, int8_t w, char p) : val(v), width(w), pad(p) {}
-};
-
-//  Count digits in an integer of specific base
-template<typename T>
-inline uint8_t digits(T v, int8_t base = 10)
-{
-  uint8_t digits = 0;
-  if ( std::is_signed<T>::value )
-  {
-    if ( v < 0 )
-    {
-      digits++;
-      v = -v; // v needs to be postive for the digits counter to work
-    }
-  }
-  do
-  {
-    v /= base;
-    digits++;
-  } while( v > 0 );
-  return digits;
-}
-
-// Generic get the width of a value in base 10
-template<typename T>
-inline uint8_t get_value_width(T val)
-{ return digits(val); }
-
-inline uint8_t get_value_width(const char * val)
-{ return strlen(val); }
-
-#ifdef ARDUINO
-inline uint8_t get_value_width(const __FlashStringHelper * val)
-{ return strlen_P(reinterpret_cast<const char *>(val)); }
-#endif
-
-// _BASED<T> get the width of a value
-template<typename T>
-inline uint8_t get_value_width(_BASED<T> b)
-{ return digits(b.val, b.base); }
-
-// Constructor wrapper to allow automatic template parameter deduction
-template<typename T>
-__WIDTH<T> _WIDTH(T val, int8_t width) { return __WIDTH<T>(val, width, ' '); }
-template<typename T>
-__WIDTH<T> _WIDTHZ(T val, int8_t width) { return __WIDTH<T>(val, width, '0'); }
-
-
-// Operator overload to handle width printing.
-template<typename T>
-inline Print &operator <<(Print &stm, const __WIDTH<T> &arg)
-{ stm << _PAD(arg.width - get_value_width(arg.val), arg.pad) << arg.val; return stm; }
-
-// explicit Operator overload to handle width printing of _FLOAT, double and float
-template<typename T>
-inline Print &pad_float(Print &stm, const __WIDTH<T> &arg, const double val, const int digits = 2) // see Print::print(double, int = 2)
-{
-  PrintBuffer<32> buf; // it's only ~45B on the stack, no allocation, leak or fragmentation
-  size_t size = buf.print(val, digits); // print in buf
-  return stm << _PAD(arg.width - size, arg.pad) << buf(); // pad and concat what's in buf
-}
-
-inline Print &operator <<(Print &stm, const __WIDTH<float>  &arg) 
-{ return pad_float(stm, arg, arg.val); }
-
-inline Print &operator <<(Print &stm, const __WIDTH<double> &arg) 
-{ return pad_float(stm, arg, arg.val); } 
-
-inline Print &operator <<(Print &stm, const __WIDTH<_FLOAT> &arg) 
-{ auto& f = arg.val; return pad_float(stm, arg, f.val, f.digits); }
-
-// a less verbose _FLOATW for _WIDTH(_FLOAT)
-#define _FLOATW(val, digits, width) _WIDTH<_FLOAT>(_FLOAT((val), (digits)), (width))
-
-// Specialization for replacement formatting
-//
-//  Designed to be similar to printf that everyone knows and loves/hates. But without
-//  the internal buffers and type agnosticism. This version only has placeholders in
-//  the format string, the actual values are supplied using the stream safe operators
-//  defined in this library.
-//
-//  Use like this:
-//
-//      Serial << FMT(F("Replace % with %"), 1, 2 )
-//      Serial << FMT("Time is %:%:%", _WIDTHZ(hours,2), _WIDTHZ(minutes,2), _WIDTHZ(seconds,2))
-//      Serial << FMT("Your score is %\\%", score);   // Note the \\ to escape the % sign
-
-// Ok, hold your hats. This is a foray into C++11's variadic template engine ...
-
-inline char get_next_format_char(const char *& format_string)
-{
-  char format_char = *format_string;
-  if ( format_char > 0 ) format_string++;
-  return format_char;
-}
-
-#ifdef ARDUINO
-inline char get_next_format_char(const __FlashStringHelper*& format_string)
-{
-  char format_char = pgm_read_byte(format_string);
-  if ( format_char > 0 ) format_string = reinterpret_cast<const __FlashStringHelper*>(reinterpret_cast<const char *>(format_string)+1);
-  return format_char;
-}
-#endif
-
-template<typename Ft>
-inline bool check_backslash(char& format_char, Ft& format_string)
-{
-  if ( format_char == '\\')
-  {
-    format_char = get_next_format_char(format_string);
-    return true;
-  }
-  return false;
-}
-
-// The template tail printer helper
-template<typename Ft, typename... Ts>
-struct __FMT
-{
-  Ft format_string;
-  __FMT(Ft f, Ts ... args) : format_string(f) {}
-  inline void tstreamf(Print& stm, Ft format) const
-  {
-    while(char c = get_next_format_char(format))
-    {
-      check_backslash(c, format);
-      if ( c )
-        stm.print(c);
-    }
-  }
-};
-
-// The variadic template helper
-template<typename Ft, typename T, typename... Ts>
-struct __FMT<Ft, T, Ts...> : __FMT<Ft, Ts...>
-{
-  T val;
-  __FMT(Ft f, T t, Ts... ts) : __FMT<Ft, Ts...>(f, ts...), val(t) {}
-  inline void tstreamf(Print& stm, Ft format) const
-  {
-    while(char c = get_next_format_char(format))
-    {
-      if (!check_backslash(c, format))
-      {
-        if ( c == '%')
-        {
-          stm << val;
-          // Variadic recursion ... compiler rolls this out during 
-          // template argument pack expansion
-          __FMT<Ft, Ts...>::tstreamf(stm, format);
-          return;
-        }
-      }
-      if (c)
-        stm.print(c);
-    }
-  }
-};
-
-// The actual operator should you only instanciate the FMT 
-// helper with a format string and no parameters
-template<typename Ft, typename... Ts>
-inline Print& operator <<(Print &stm, const __FMT<Ft, Ts...> &args)
-{
-    args.tstreamf(stm, args.format_string);
-    return stm;
-}
-
-// The variadic stream helper
-template<typename Ft, typename T, typename... Ts>
-inline Print& operator <<(Print &stm, const __FMT<Ft, T, Ts...> &args)
-{
-    args.tstreamf(stm, args.format_string);
-    return stm;
-}
-
-// As we don't have C++17, we can't get a constructor to use
-// automatic argument deduction, but ... this little trick gets
-// around that ...
-template<typename Ft, typename... Ts>
-__FMT<Ft, Ts...> _FMT(Ft format, Ts ... args) { return __FMT<Ft, Ts...>(format, args...); }
-
-#endif
--- a/src/StringIndexer.cpp
+++ b/src/StringIndexer.cpp
@@ -1,3 +1,4 @@
 #include "StringIndexer.h"

-std::map<StringIndexer::index_t, StringIndexer::StringCounter> StringIndexer::strings;
+StringIndexer::Strings StringIndexer::strings;
+
--- a/src/StringIndexer.h
+++ b/src/StringIndexer.h
@@ -1,17 +1,25 @@
+// vim: ts=2 sw=2 expandtab
 #pragma once
+#include <assert.h>
 #include <map>
+#include <unordered_map>
+#include "TinyConsole.h"
 #include <string>
 #include <string.h>

+using string = TinyConsole::string;
+
 /***
 * Allows to store up to 255 different strings with one byte class
 * very memory efficient when one string is used many times.
 */
 class StringIndexer
 {
+  private:
+
  class StringCounter
  {
-    std::string str;
+    string str;
    uint8_t used=0;
    friend class StringIndexer;

@@ -28,32 +36,9 @@ class StringIndexer
  public:
    using index_t = uint8_t;

-    static index_t strToIndex(const char* str, uint8_t len)
+   static const string& str(const index_t& index)
   {
-      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=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 const std::string& str(const index_t& index)
-    {
-      static std::string dummy;
+     static string dummy;
     const auto& it=strings.find(index);
     if (it == strings.end()) return dummy;
     return it->second.str;
@@ -82,7 +67,35 @@ class StringIndexer
    static uint16_t count() { return strings.size(); }

  private:
-    static std::map<index_t, StringCounter> strings;
+    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 = 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
+    }
+
+    using Strings = std::unordered_map<index_t, StringCounter>;
+
+    static Strings strings;
 };

 class IndexedString
@@ -94,12 +107,14 @@ class IndexedString
      index = source.index;
    }

+    IndexedString(IndexedString&& i) : index(i.index) {}
+
    IndexedString(const char* str, uint8_t len)
    {
      index=StringIndexer::strToIndex(str, len);
    }

-    IndexedString(const std::string& str) : IndexedString(str.c_str(), str.length()) {};
+    IndexedString(const string& str) : IndexedString(str.c_str(), str.length()) {};

    ~IndexedString() { StringIndexer::release(index); }

@@ -120,7 +135,7 @@ class IndexedString
      return i1.index == i2.index;
    }

-    const std::string& str() const { return StringIndexer::str(index); }
+    const string& str() const { return StringIndexer::str(index); }

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

--- a/src/TinyMqtt.cpp
+++ b/src/TinyMqtt.cpp
@@ -1,14 +1,26 @@
+// vim: ts=2 sw=2 expandtab
 #include "TinyMqtt.h"
 #include <sstream>

+#if TINY_MQTT_DEBUG
+static auto cyan = TinyConsole::cyan;
+static auto white = TinyConsole::white;
+static auto red = TinyConsole::red;
+static auto yellow = TinyConsole::yellow;
+
+int TinyMqtt::debug=2;
+#endif
+
 #ifdef EPOXY_DUINO
  std::map<MqttMessage::Type, int> MqttClient::counters;
 #endif

-MqttBroker::MqttBroker(uint16_t port)
+MqttBroker::MqttBroker(uint16_t port, uint8_t max_retain_size)
 {
+  debug("New broker" << port);
+  retain_size = max_retain_size;
  server = new TcpServer(port);
-#ifdef TCP_ASYNC
+#ifdef TINY_MQTT_ASYNC
  server->onClient(onClient, this);
 #endif
 }
@@ -17,22 +29,30 @@ MqttBroker::~MqttBroker()
 {
  while(clients.size())
  {
-    delete clients[0];
+    auto client = clients[0];
+    client->local_broker = nullptr;
+    if (client->cltFlags & MqttClient::CltFlags::CltFlagToDelete)
+    {
+      // std::cout << "Deleting client" << std::endl;
+      delete client;
+    }
+    clients.erase(clients.begin());
  }
  delete server;
 }

 // private constructor used by broker only
-MqttClient::MqttClient(MqttBroker* parent, TcpClient* new_client)
-  : parent(parent)
+MqttClient::MqttClient(MqttBroker* local_broker, TcpClient* new_client)
+  : local_broker(local_broker)
 {
-#ifdef TCP_ASYNC
-  client = new_client;
-  client->onData(onData, this);
+  debug("MqttClient private with broker");
+#ifdef TINY_MQTT_ASYNC
+  tcp_client = new_client;
+  tcp_client->onData(onData, this);
  // client->onConnect() TODO
  // client->onDisconnect() TODO
 #else
-  client = new WiFiClient(*new_client);
+  tcp_client = new WiFiClient(*new_client);
 #endif
 #ifdef EPOXY_DUINO
  alive = millis()+500000;
@@ -41,82 +61,95 @@ MqttClient::MqttClient(MqttBroker* parent, TcpClient* new_client)
 #endif
 }

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

-    if (parent) parent->addClient(this);
+  if (local_broker) local_broker->addClient(this);
 }

 MqttClient::~MqttClient()
 {
  close();
-  delete client;
+  delete tcp_client;
+  debug("*** MqttClient delete()");
 }

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

-  if (parent)
+  if (local_broker)
  {
-    parent->removeClient(this);
-    parent = nullptr;
+    local_broker->removeClient(this);
+    local_broker = nullptr;
  }
 }

-void MqttClient::connect(MqttBroker* parentBroker)
+void MqttClient::connect(MqttBroker* local)
 {
+  debug("MqttClient::connect_local");
  close();
-  parent = parentBroker;
+  local_broker = local;
+  local_broker->addClient(this);
 }

-void MqttClient::connect(std::string broker, uint16_t port, uint16_t ka)
+void MqttClient::connect(string broker, uint16_t port, uint16_t ka)
 {
-  debug("MqttClient::connect");
+  debug("MqttClient::connect_to_host " << broker << ':' << port);
  keep_alive = ka;
  close();
-  if (client) delete client;
-  client = new TcpClient;
+  if (tcp_client) delete tcp_client;
+  tcp_client = new TcpClient;

-  debug("Trying to connect to " << broker.c_str() << ':' << port);
-#ifdef TCP_ASYNC
-  client->onData(onData, this);
-  client->onConnect(onConnect, this);
-  client->connect(broker.c_str(), port);
+#ifdef TINY_MQTT_ASYNC
+  tcp_client->onData(onData, this);
+  tcp_client->onConnect(onConnect, this);
+  tcp_client->connect(broker.c_str(), port);
 #else
-  if (client->connect(broker.c_str(), port))
+  if (tcp_client->connect(broker.c_str(), port))
  {
-    onConnect(this, client);
+    debug("link established");
+    onConnect(this, tcp_client);
+  }
+  else
+  {
+    debug("unable to connect.");
  }
 #endif
 }

 void MqttBroker::addClient(MqttClient* client)
 {
+  debug("MqttBroker::addClient");
  clients.push_back(client);
 }

-void MqttBroker::connect(const std::string& host, uint16_t port)
+void MqttBroker::connect(const string& host, uint16_t port)
 {
-  if (broker == nullptr) broker = new MqttClient;
-  broker->connect(host, port);
-  broker->parent = this;  // Because connect removed the link
+  debug("MqttBroker::connect");
+  if (remote_broker == nullptr) remote_broker = new MqttClient;
+  remote_broker->connect(host, port);
+  remote_broker->local_broker = this;  // Because connect removed the link
+  // TODO shouldn't we resubscribe to all client subscriptions ?
 }

 void MqttBroker::removeClient(MqttClient* remove)
 {
+  debug("removeClient");
  for(auto it=clients.begin(); it!=clients.end(); it++)
  {
    auto client=*it;
@@ -133,47 +166,47 @@ void MqttBroker::removeClient(MqttClient* remove)
      return;
    }
  }
-  debug("Error cannot remove client");  // TODO should not occur
+  debug(red << "Error cannot remove client");  // TODO should not occur
 }

 void MqttBroker::onClient(void* broker_ptr, TcpClient* client)
 {
+  debug("MqttBroker::onClient");
  MqttBroker* broker = static_cast<MqttBroker*>(broker_ptr);

-  broker->addClient(new MqttClient(broker, client));
+  MqttClient* mqtt = new MqttClient(broker, client);
+  mqtt->setFlag(MqttClient::CltFlags::CltFlagToDelete);
+  broker->addClient(mqtt);
  debug("New client");
 }

 void MqttBroker::loop()
 {
-#ifndef TCP_ASYNC
-  WiFiClient client = server->available();
+#ifndef TINY_MQTT_ASYNC
+  WiFiClient client = server->accept();

  if (client)
  {
    onClient(this, &client);
  }
 #endif
-  if (broker)
+  if (remote_broker)
  {
    // TODO should monitor broker's activity.
    // 1 When broker disconnect and reconnect we have to re-subscribe
-    broker->loop();
+    remote_broker->loop();
  }

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

-MqttError MqttBroker::subscribe(const Topic& topic, uint8_t qos)
+// Obvioulsy called when the broker is connected to another broker.
+MqttError MqttBroker::subscribe(MqttClient* client, const Topic& topic, uint8_t qos)
 {
-  if (broker && broker->connected())
+  debug("MqttBroker::subscribe to " << topic.str() << ", retained=" << retained.size() );
+  for(auto& [retained_topic, retain]: retained)
  {
-    return broker->subscribe(topic, qos);
+    debug("  retained: " << retained_topic.str());
+    if (topic.matches(retained_topic))
+    {
+      debug("  -> sending");
+      client->publishIfSubscribed(retained_topic, retain.msg);
+    }
+  }
+  if (remote_broker && remote_broker->connected())
+  {
+    return remote_broker->subscribe(topic, qos);
  }
  return MqttNowhereToSend;
 }

-MqttError MqttBroker::publish(const MqttClient* source, const Topic& topic, MqttMessage& msg) const
+MqttError MqttBroker::publish(const MqttClient* source, const Topic& topic, MqttMessage& msg)
 {
  MqttError retval = MqttOk;

-  debug("publish ");
+  retain(topic, msg);
+
+  debug("MqttBroker::publish");
  int i=0;
  for(auto client: clients)
  {
    i++;
-#ifdef TINY_MQTT_DEBUG
-    Serial << "brk_" << (broker && broker->connected() ? "con" : "dis") <<
+#if TINY_MQTT_DEBUG
+    Console << __LINE__ << " broker:" << (remote_broker && remote_broker->connected() ? "linked" : "alone") <<
       "  srce=" << (source->isLocal() ? "loc" : "rem") << " clt#" << i << ", local=" << client->isLocal() << ", con=" << client->connected() << endl;
 #endif
    bool doit = false;
-    if (broker && broker->connected())  // this (MqttBroker) is connected (to a external broker)
+    if (remote_broker && remote_broker->connected())  // this (MqttBroker) is connected (to a external broker)
    {
      // ext_broker -> clients or clients -> ext_broker
-      if (source == broker)  // external broker -> internal clients
+      if (source == remote_broker)  // external broker -> internal clients
        doit = true;
      else                  // external clients -> this broker
      {
        // As this broker is connected to another broker, simply forward the msg
-        MqttError ret = broker->publishIfSubscribed(topic, msg);
+        MqttError ret = remote_broker->publishIfSubscribed(topic, msg);
        if (ret != MqttOk) retval = ret;
      }
    }
@@ -220,8 +266,8 @@ MqttError MqttBroker::publish(const MqttClient* source, const Topic& topic, Mqtt
    {
      doit = true;
    }
-#ifdef TINY_MQTT_DEBUG
-    Serial << ", doit=" << doit << ' ';
+#if TINY_MQTT_DEBUG
+    Console << ", doit=" << doit << ' ';
 #endif

    if (doit) retval = client->publishIfSubscribed(topic, msg);
@@ -242,16 +288,17 @@ bool MqttBroker::compareString(

 void MqttMessage::getString(const char* &buff, uint16_t& len)
 {
-  len = (buff[0]<<8)|(buff[1]);
+  len = getSize(buff);
  buff+=2;
 }

 void MqttClient::clientAlive(uint32_t more_seconds)
 {
+  debug("MqttClient::clientAlive");
  if (keep_alive)
  {
 #ifdef EPOXY_DUINO
-    alive=millis()+500000;
+    alive=millis()+500000+0*more_seconds;
 #else
    alive=millis()+1000*(keep_alive+more_seconds);
 #endif
@@ -262,29 +309,30 @@ void MqttClient::clientAlive(uint32_t more_seconds)

 void MqttClient::loop()
 {
-  if (alive && (millis() > alive))
+  if (keep_alive && (millis() >= alive - 5000))
  {
-    if (parent)
-    {
-      debug("timeout client");
-      close();
-      debug("closed");
-    }
-    else if (client && client->connected())
+    if (tcp_client && tcp_client->connected())
    {
      debug("pingreq");
-      uint16_t pingreq = MqttMessage::Type::PingReq;
-      client->write((const char*)(&pingreq), 2);
+      static MqttMessage pingreq(MqttMessage::Type::PingReq);
+      pingreq.sendTo(this);
      clientAlive(0);

      // TODO when many MqttClient passes through a local broker
      // there is no need to send one PingReq per instance.
    }
-  }
-#ifndef TCP_ASYNC
-  while(client && client->available()>0)
+    else if (local_broker)
    {
-    message.incoming(client->read());
+      debug(red << "timeout client");
+      close();
+      debug(red << "closed");
+    }
+  }
+
+#ifndef TINY_MQTT_ASYNC
+  while(tcp_client && tcp_client->available()>0)
+  {
+    message.incoming(tcp_client->read());
    if (message.type())
    {
      processMessage(&message);
@@ -297,24 +345,24 @@ void MqttClient::loop()
 void MqttClient::onConnect(void *mqttclient_ptr, TcpClient*)
 {
  MqttClient* mqtt = static_cast<MqttClient*>(mqttclient_ptr);
-  debug("cnx: connecting");
+  debug("MqttClient::onConnect");
  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((char)(mqtt->keep_alive >> 8));   // keep_alive
+  msg.add((char)(mqtt->keep_alive & 0xFF));
  msg.add(mqtt->clientId);
  debug("cnx: mqtt connecting");
  msg.sendTo(mqtt);
  msg.reset();
-  debug("cnx: mqtt sent " << (dbg_ptr)mqtt->parent);
+  debug("cnx: mqtt sent " << (dbg_ptr)mqtt->local_broker);

  mqtt->clientAlive(0);
 }

-#ifdef TCP_ASYNC
+#ifdef TINY_MQTT_ASYNC
 void MqttClient::onData(void* client_ptr, TcpClient*, void* data, size_t len)
 {
  char* char_ptr = static_cast<char*>(data);
@@ -354,29 +402,30 @@ void MqttClient::resubscribe()

 MqttError MqttClient::subscribe(Topic topic, uint8_t qos)
 {
-  debug("subsribe(" << topic.c_str() << ")");
+  debug("MqttClient::subsribe(" << topic.c_str() << ")");
  MqttError ret = MqttOk;

  subscriptions.insert(topic);

-  if (parent==nullptr) // remote broker
+  if (local_broker==nullptr) // connected to a remote broker
  {
    return sendTopic(topic, MqttMessage::Type::Subscribe, qos);
  }
  else
  {
-    return parent->subscribe(topic, qos);
+    return local_broker->subscribe(this, topic, qos);
  }
  return ret;
 }

 MqttError MqttClient::unsubscribe(Topic topic)
 {
+  debug("MqttClient::unsubscribe");
  auto it=subscriptions.find(topic);
  if (it != subscriptions.end())
  {
    subscriptions.erase(it);
-    if (parent==nullptr) // remote broker
+    if (local_broker==nullptr) // remote broker
    {
      return sendTopic(topic, MqttMessage::Type::UnSubscribe, 0);
    }
@@ -386,6 +435,7 @@ MqttError MqttClient::unsubscribe(Topic topic)

 MqttError MqttClient::sendTopic(const Topic& topic, MqttMessage::Type type, uint8_t qos)
 {
+  debug("MqttClient::sendTopic");
  MqttMessage msg(type, 2);

  // TODO manage packet identifier
@@ -401,17 +451,8 @@ MqttError MqttClient::sendTopic(const Topic& topic, MqttMessage::Type type, uint

 void MqttClient::processMessage(MqttMessage* mesg)
 {
-#ifdef TINY_MQTT_DEBUG
-if (mesg->type() != MqttMessage::Type::PingReq && mesg->type() != MqttMessage::Type::PingResp)
-{
-  #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");
+#if TINY_MQTT_DEBUG
  mesg->hexdump("Incoming");
-}
 #endif
  auto header = mesg->getVHeader();
  const char* payload;
@@ -425,14 +466,14 @@ if (mesg->type() != MqttMessage::Type::PingReq && mesg->type() != MqttMessage::T
  switch(mesg->type())
  {
    case MqttMessage::Type::Connect:
-      if (mqtt_connected)
+      if (mqtt_connected())
      {
        debug("already connected");
        break;
      }
      payload = header+10;
      mqtt_flags = header[7];
-      keep_alive = (header[8]<<8)|(header[9]);
+      keep_alive = MqttMessage::getSize(header+8);
      if (strncmp("MQTT", header+2,4))
      {
        debug("bad mqtt header");
@@ -440,13 +481,13 @@ if (mesg->type() != MqttMessage::Type::PingReq && mesg->type() != MqttMessage::T
      }
      if (header[6]!=0x04)
      {
-        debug("unknown level");
+        debug("Unsupported MQTT version (" << (int) header[6] << "), only version=4 supported" << endl);
        break;  // Level 3.1.1
      }

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

      if (mqtt_flags & FlagWill)  // Will topic
@@ -461,21 +502,21 @@ if (mesg->type() != MqttMessage::Type::PingReq && mesg->type() != MqttMessage::T
      if (mqtt_flags & FlagUserName)
      {
        mesg->getString(payload, len);
-        if (!parent->checkUser(payload, len)) break;
+        if (not local_broker->checkUser(payload, len)) break;
        payload += len;
      }
      if (mqtt_flags & FlagPassword)
      {
        mesg->getString(payload, len);
-        if (!parent->checkPassword(payload, len)) break;
+        if (not local_broker->checkPassword(payload, len)) break;
        payload += len;
      }

-      #ifdef TINY_MQTT_DEBUG
-        Serial << "Connected client:" << clientId.c_str() << ", keep alive=" << keep_alive << '.' << endl;
+      #if TINY_MQTT_DEBUG
+        Console << yellow << "Client " << clientId << " connected : keep alive=" << keep_alive << '.' << white << endl;
      #endif
      bclose = false;
-      mqtt_connected=true;
+      setFlag(CltFlagConnected);
      {
        MqttMessage msg(MqttMessage::Type::ConnAck);
        msg.add(0);  // Session present (not implemented)
@@ -485,14 +526,14 @@ if (mesg->type() != MqttMessage::Type::PingReq && mesg->type() != MqttMessage::T
      break;

    case MqttMessage::Type::ConnAck:
-      mqtt_connected = true;
+      setFlag(CltFlagConnected);
      bclose = false;
      resubscribe();
      break;

    case MqttMessage::Type::SubAck:
    case MqttMessage::Type::PubAck:
-      if (!mqtt_connected) break;
+      if (not mqtt_connected()) break;
      // Ignore acks
      bclose = false;
      break;
@@ -503,31 +544,32 @@ if (mesg->type() != MqttMessage::Type::PingReq && mesg->type() != MqttMessage::T
      break;

    case MqttMessage::Type::PingReq:
-      if (!mqtt_connected) break;
-      if (client)
+      if (not mqtt_connected()) break;
+      if (tcp_client)
      {
        uint16_t pingreq = MqttMessage::Type::PingResp;
-        client->write((const char*)(&pingreq), 2);
+        debug(cyan << "Ping response to client ");
+        tcp_client->write((const char*)(&pingreq), 2);
        bclose = false;
      }
      else
      {
-        debug("internal pingreq ?");
+        debug(red << "internal pingreq ?");
      }
      break;

    case MqttMessage::Type::Subscribe:
    case MqttMessage::Type::UnSubscribe:
      {
-        if (!mqtt_connected) break;
+        if (not mqtt_connected()) break;
        payload = header+2;

        debug("un/subscribe loop");
-        std::string qoss;
+        string qoss;
        while(payload < mesg->end())
        {
          mesg->getString(payload, len);  // Topic
-          debug( "  topic (" << std::string(payload, len) << ')');
+          debug( "  topic (" << string(payload, len) << ')');
          // subscribe(Topic(payload, len));
          Topic topic(payload, len);

@@ -542,7 +584,7 @@ if (mesg->type() != MqttMessage::Type::PingReq && mesg->type() != MqttMessage::T
            }
            else
              qoss.push_back(qos);
-            subscriptions.insert(topic);
+            subscribe(topic);
          }
          else
          {
@@ -563,43 +605,48 @@ if (mesg->type() != MqttMessage::Type::PingReq && mesg->type() != MqttMessage::T
      break;

    case MqttMessage::Type::UnSuback:
-      if (!mqtt_connected) break;
+      if (not mqtt_connected()) break;
      bclose = false;
      break;

    case MqttMessage::Type::Publish:
-      #ifdef TINY_MQTT_DEBUG
-        Serial << "publish " << mqtt_connected << '/' << (long) client << endl;
+      #if TINY_MQTT_DEBUG
+        Console << "publish " << mqtt_connected() << '/' << (long) tcp_client << endl;
      #endif
-      if (mqtt_connected or client == nullptr)
+      if (mqtt_connected() or tcp_client == nullptr)
      {
        uint8_t qos = mesg->flags();
        payload = header;
        mesg->getString(payload, len);
        Topic published(payload, len);
        payload += len;
-        // Serial << "Received Publish (" << published.str().c_str() << ") size=" << (int)len
-        // << '(' << std::string(payload, len).c_str() << ')'  << " msglen=" << mesg->length() << endl;
+        #if TINY_MQTT_DEBUG
+          Console << "Received Publish (" << published.str().c_str() << ") size=" << (int)len << endl;
+        #endif
+        // << '(' << 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==nullptr or client==nullptr)  // internal MqttClient receives publish
+        if (local_broker==nullptr or tcp_client==nullptr)  // internal MqttClient receives publish
        {
-          #ifdef TINY_MQTT_DEBUG
-            Serial << (isSubscribedTo(published) ? "not" : "") << " subscribed.\n";
-            Serial << "has " << (callback ? "" : "no ") << " callback.\n";
+          #if TINY_MQTT_DEBUG
+            if (TinyMqtt::debug >= 2)
+            {
+              Console << (isSubscribedTo(published) ? "not" : "") << " subscribed.\r\n";
+              Console << "has " << (callback ? "" : "no ") << " callback.\r\n";
+            }
          #endif
          if (callback and isSubscribedTo(published))
          {
-            callback(this, published, payload, len);  // TODO send the real payload
+            callback(this, published, payload, len);
          }
        }
-        else if (parent) // from outside to inside
+        else if (local_broker) // from outside to inside
        {
-          debug("publishing to parent");
-          parent->publish(this, published, *mesg);
+          debug("publishing to local_broker");
+          local_broker->publish(this, published, *mesg);
        }
        bclose = false;
      }
@@ -607,8 +654,8 @@ if (mesg->type() != MqttMessage::Type::PingReq && mesg->type() != MqttMessage::T

    case MqttMessage::Type::Disconnect:
      // TODO should discard any will msg
-      if (!mqtt_connected) break;
-      mqtt_connected = false;
+      if (not mqtt_connected()) break;
+      resetFlag(CltFlagConnected);
      close(false);
      bclose=false;
      break;
@@ -619,40 +666,96 @@ if (mesg->type() != MqttMessage::Type::PingReq && mesg->type() != MqttMessage::T
  };
  if (bclose)
  {
-    #ifdef TINY_MQTT_DEBUG
-      Serial << "*************** Error msg 0x" << _HEX(mesg->type());
+    #if TINY_MQTT_DEBUG
+      Console << red << "*************** Error msg 0x" << _HEX(mesg->type());
      mesg->hexdump("-------ERROR ------");
      dump();
-      Serial << endl;
+      Console << white << endl;
    #endif
    close();
  }
  else
  {
-    clientAlive(parent ? 5 : 0);
+    clientAlive(local_broker ? 5 : 0);
  }
 }

 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)
+MqttError MqttClient::publish(const Topic& topic, const char* payload, size_t pay_length, bool retain)
 {
-  MqttMessage msg(MqttMessage::Publish);
+  MqttMessage msg(MqttMessage::Publish, retain ? 1 : 0);
  msg.add(topic);
  msg.add(payload, pay_length, false);
  msg.complete();

-  if (parent)
+  if (local_broker)
  {
-    return parent->publish(this, topic, msg);
+    return local_broker->publish(this, topic, msg);
  }
-  else if (client)
+  else if (tcp_client)
    return msg.sendTo(this);
  else
    return MqttNowhereToSend;
@@ -663,17 +766,17 @@ MqttError MqttClient::publishIfSubscribed(const Topic& topic, MqttMessage& msg)
 {
  MqttError retval=MqttOk;

-  debug("mqttclient publish " << subscriptions.size());
+  debug("mqttclient publishIfSubscribed " << topic.c_str() << ' ' << subscriptions.size());
  if (isSubscribedTo(topic))
  {
-    if (client)
+    if (tcp_client)
      retval = msg.sendTo(this);
    else
    {
      processMessage(&msg);

-      #ifdef TINY_MQTT_DEBUG
-        Serial << "Should call the callback ?\n";
+      #if TINY_MQTT_DEBUG
+        Console << "Should call the callback ?\n";
      #endif
      // callback(this, topic, nullptr, 0);  // TODO Payload
    }
@@ -741,8 +844,8 @@ void MqttMessage::incoming(char in_byte)
      break;
    case Complete:
    default:
-      #ifdef TINY_MQTT_DEBUG
-        Serial << "Spurious " << _HEX(in_byte) << endl;
+      #if TINY_MQTT_DEBUG
+        Console << red << "Spurious " << _HEX(in_byte) << white << endl;
        hexdump("spurious");
      #endif
      reset();
@@ -768,6 +871,7 @@ void MqttMessage::add(const char* p, size_t len, bool addLength)

 void MqttMessage::encodeLength()
 {
+  debug("encodingLength");
  if (state != Complete)
  {
    int length = buffer.size()-3;  // 3 = 1 byte for header + 2 bytes for pre-reserved length field.
@@ -793,43 +897,98 @@ MqttError MqttMessage::sendTo(MqttClient* client)
 {
  if (buffer.size())
  {
-    debug("sending " << buffer.size() << " bytes");
+    debug(cyan << "sending " << buffer.size() << " bytes to " << client->id());
    encodeLength();
-    // hexdump("snd");
+    hexdump("Sending ");
    client->write(&buffer[0], buffer.size());
  }
  else
  {
-    debug("??? Invalid send");
+    debug(red << "??? Invalid send");
    return MqttInvalidMessage;
  }
  return MqttOk;
 }

+void MqttBroker::retainDrop()
+{
+  if (retained.size() >= retain_size)
+  {
+    std::map<Topic, Retain>::iterator oldest = retained.begin();
+    auto it = oldest;
+    while(++it != retained.end())
+    {
+      if (oldest->second.timestamp > it->second.timestamp)
+        oldest = it;
+    }
+    retained.erase(oldest);
+  }
+}
+
+void MqttBroker::retain(const Topic& topic, const MqttMessage& msg)
+{
+  debug("MqttBroker::retain msg_type=" << _HEX(msg.type()));
+  if (retain_size==0 or msg.type() != MqttMessage::Publish) return;
+  if (msg.flags() & 1)  // flag RETAIN
+  {
+    debug("  retaining " << topic.str());
+    if (retained.find(topic) == retained.end()) retainDrop();
+    // FIXME if payload size == 0 remove message from retained
+    Retain r(micros(), msg);
+    retained.insert({ topic, std::move(r)});
+  }
+}
+
 void MqttMessage::hexdump(const char* prefix) const
 {
  (void)prefix;
-#ifdef TINY_MQTT_DEBUG
+#if TINY_MQTT_DEBUG
+  if (TinyMqtt::debug<2) return;
+  static std::map<Type, string> tts={
+    { Connect, "Connect" },
+    { ConnAck, "Connack" },
+    { Publish, "Publish" },
+    { PubAck,  "Puback" },
+    { Subscribe, "Subscribe" },
+    { SubAck,   "Suback" },
+    { UnSubscribe, "Unsubscribe" },
+    { UnSuback, "Unsuback" },
+    { PingReq, "Pingreq" },
+    { PingResp, "Pingresp" },
+    { Disconnect, "Disconnect" }
+  };
+  string t("Unknown");
+  Type typ=static_cast<Type>(buffer[0] & 0xF0);
+  if (tts.find(typ) != tts.end())
+    t=tts[typ];
+  Console.fg(cyan);
+#ifdef NOT_ESP_CORE
+  Console << "---> MESSAGE " << t << ' ' << _HEX(typ) << ' ' << " mem=???" << endl;
+#else
+  Console << "---> MESSAGE " << t << ' ' << _HEX(typ) << ' ' << " mem=" << ESP.getFreeHeap() << endl;
+#endif
+  Console.fg(white);
+
  uint16_t addr=0;
  const int bytes_per_row = 8;
  const char* hex_to_str = " | ";
  const char* separator = hex_to_str;
  const char* half_sep = " - ";
-  std::string ascii;
+  string ascii;

-  Serial << prefix << " size(" << buffer.size() << "), state=" << state << endl;
+  Console << prefix << " size(" << buffer.size() << "), state=" << state << endl;

  for(const char chr: buffer)
  {
    if ((addr % bytes_per_row) == 0)
    {
-      if (ascii.length()) Serial << hex_to_str << ascii << separator << endl;
-      if (prefix) Serial << prefix << separator;
+      if (ascii.length()) Console << hex_to_str << ascii << separator << endl;
+      if (prefix) Console << prefix << separator;
      ascii.clear();
    }
    addr++;
-    if (chr<16) Serial << '0';
-    Serial << _HEX(chr) << ' ';
+    if (chr<16) Console << '0';
+    Console << _HEX(chr) << ' ';

    ascii += (chr<32 ? '.' : chr);
    if (ascii.length() == (bytes_per_row/2)) ascii += half_sep;
@@ -838,12 +997,12 @@ void MqttMessage::hexdump(const char* prefix) const
  {
    while(ascii.length() < bytes_per_row+strlen(half_sep))
    {
-      Serial << "   ";  // spaces per hexa byte
+      Console << "   ";  // spaces per hexa byte
      ascii += ' ';
    }
-    Serial << hex_to_str << ascii << separator;
+    Console << hex_to_str << ascii << separator;
  }

-  Serial << endl;
+  Console << endl;
 #endif
 }
--- a/src/TinyMqtt.h
+++ b/src/TinyMqtt.h
@@ -1,17 +1,22 @@
+// vim: ts=2 sw=2 expandtab
 #pragma once

-// TODO Should add a AUnit with both TCP_ASYNC and not TCP_ASYNC
-// #define TCP_ASYNC  // Uncomment this to use ESPAsyncTCP instead of normal cnx
+#ifndef TINY_MQTT_DEBUG
+#define TINY_MQTT_DEBUG 0
+#endif
+
+// 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 TCP_ASYNC
+  #ifdef TINY_MQTT_ASYNC
    #include <ESPAsyncTCP.h>
  #else
    #include <ESP8266WiFi.h>
  #endif
 #elif defined(ESP32)
  #include <WiFi.h>
-  #ifdef TCP_ASYNC
+  #ifdef TINY_MQTT_ASYNC
    #include <AsyncTCP.h> // https://github.com/me-no-dev/AsyncTCP
  #endif
 #endif
@@ -20,21 +25,35 @@
 #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>

-// #define TINY_MQTT_DEBUG
+#define TINY_MQTT_DEFAULT_CLIENT_ID "Tiny"

-#ifdef TINY_MQTT_DEBUG
-  #define debug(what) { Serial << (int)__LINE__ << ' ' << what << endl; delay(100); }
+#include <TinyStreaming.h>
+#if TINY_MQTT_DEBUG
+  #include <TinyConsole.h>    // https://github.com/hsaturn/TinyConsole
+  struct TinyMqtt
+  {
+    static int debug;
+  };
+
+  #define debug(what) { if (TinyMqtt::debug>=1) Console << (int)__LINE__ << ' ' << what << TinyConsole::white << endl; delay(100); }
 #else
  #define debug(what) {}
 #endif

-#ifdef TCP_ASYNC
+#ifdef TINY_MQTT_ASYNC
  using TcpClient = AsyncClient;
  using TcpServer = AsyncServer;
 #else
@@ -49,12 +68,15 @@ enum __attribute__((packed)) MqttError
  MqttInvalidMessage=2,
 };

+using string = TinyConsole::string;
+
 class Topic : public IndexedString
 {
  public:
+    Topic(const string& m) : IndexedString(m){}
    Topic(const char* s, uint8_t len) : IndexedString(s,len){}
    Topic(const char* s) : Topic(s, strlen(s)) {}
-    Topic(const std::string s) : Topic(s.c_str(), s.length()){};
+    // Topic(const string s) : Topic(s.c_str(), s.length()){};

    const char* c_str() const { return str().c_str(); }

@@ -81,6 +103,7 @@ class MqttMessage
      PingResp    = 0xD0,
      Disconnect  = 0xE0
    };
+
    enum __attribute__((packed)) State
    {
      FixedHeader=0,
@@ -92,12 +115,20 @@ class MqttMessage
      Create=6
    };

+    static inline uint32_t getSize(const char* buffer)
+    {
+      const unsigned char* bun = (const unsigned char*)buffer;
+      return (*bun << 8) | bun[1]; }
+
    MqttMessage() { reset(); }
-    MqttMessage(Type t, uint8_t bits_d3_d0=0) { create(t); buffer[0] |= bits_d3_d0; }
+    MqttMessage(Type t, uint8_t bits_d3_d0=0) { create(t); buffer[0] |= (bits_d3_d0 & 0xF); }
+    MqttMessage(const MqttMessage& m)
+      : buffer(m.buffer), vheader(m.vheader), size(m.size), state(m.state) {}
+
    void incoming(char byte);
    void add(char byte) { incoming(byte); }
    void add(const char* p, size_t len, bool addLength=true );
-    void add(const std::string& s) { add(s.c_str(), s.length()); }
+    void add(const string& s) { add(s.c_str(), s.length()); }
    void add(const Topic& t) { add(t.str()); }
    const char* end() const { return &buffer[0]+buffer.size(); }
    const char* getVHeader() const { return &buffer[vheader]; }
@@ -128,10 +159,19 @@ class MqttMessage
    MqttError sendTo(MqttClient*);
    void hexdump(const char* prefix=nullptr) const;

+    MqttMessage& operator = (MqttMessage&& m)
+    {
+      buffer = std::move(m.buffer);
+      vheader = m.vheader;
+      size = m.size;
+      state = m.state;
+      return *this;
+    }
+
  private:
    void encodeLength();

-    std::string buffer;
+    string buffer;
    uint8_t vheader;
    uint16_t size;  // bytes left to receive
    State state;
@@ -140,7 +180,6 @@ class MqttMessage
 class MqttBroker;
 class MqttClient
 {
-  using CallBack = void (*)(const MqttClient* source, const Topic& topic, const char* payload, size_t payload_length);
  enum __attribute__((packed)) Flags
  {
    FlagUserName = 128,
@@ -151,27 +190,44 @@ class MqttClient
    FlagCleanSession = 2,  // unsupported
    FlagReserved = 1
  };
+
+  enum __attribute__((packed)) CltFlags
+  {
+    CltFlagNone = 0,
+    CltFlagConnected = 1,
+    CltFlagToDelete = 2
+  };
  public:
-    /** Constructor. If broker is not null, this is the adress of a local broker.
+
+    using CallBack = void (*)(const MqttClient* source, const Topic& topic, const char* payload, size_t payload_length);
+
+    /** Constructor. Broker is the adress of a local broker if not null
        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(MqttBroker* broker = nullptr, const string& id = TINY_MQTT_DEFAULT_CLIENT_ID);
+    MqttClient(const string& id) : MqttClient(nullptr, id){}

    ~MqttClient();

-    void connect(MqttBroker* parent);
-    void connect(std::string broker, uint16_t port, uint16_t keep_alive = 10);
+    void connect(MqttBroker* local_broker);
+    void connect(string broker, uint16_t port, uint16_t keep_alive = 10);
+    void connect(const IPAddress& ip, uint16_t port, uint16_t keep_alive = 10)
+    { connect(ip.toString().c_str(), port, keep_alive); }

    // 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()); }
-    void write(const char* buf, size_t length)
-    { if (client) client->write(buf, length); }
+    // no negociation occurred
+    bool connected()
+    {
+      return (local_broker!=nullptr and tcp_client==nullptr)
+           or (tcp_client and tcp_client->connected());
+    }

-    const std::string& id() const { return clientId; }
-    void id(std::string& new_id) { clientId = new_id; }
+    void write(const char* buf, size_t length)
+    {
+      if (tcp_client) tcp_client->write(buf, length);
+    }
+
+    const string& id() const { return clientId; }
+    void id(const string& new_id) { clientId = new_id; }

    /** Should be called in main loop() */
    void loop();
@@ -179,18 +235,18 @@ class MqttClient
    void setCallback(CallBack fun)
    {
      callback=fun;
-      #ifdef TINY_MQTT_DEBUG
-        Serial << "Callback set to " << (long)fun << endl;
+      #if TINY_MQTT_DEBUG
+        Console << TinyConsole::magenta << "Callback set to " << (long)fun << TinyConsole::white << 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 publish(const Topic&, const char* payload, size_t pay_length, bool retain=false);
+    MqttError publish(const Topic& t, const char* payload, bool retain=false) { return publish(t, payload, strlen(payload), retain); }
+    MqttError publish(const Topic& t, const String& s, bool retain=false) { return publish(t, s.c_str(), s.length(), retain); }
+    MqttError publish(const Topic& t, const string& s, bool retain=false) { return publish(t,s.c_str(),s.length(), retain);}
+    MqttError publish(const Topic& t, bool retain=false) { return publish(t, nullptr, 0, retain);};

    MqttError subscribe(Topic topic, uint8_t qos=0);
    MqttError unsubscribe(Topic topic);
@@ -198,99 +254,107 @@ class MqttClient

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

-    void dump(std::string indent="")
+    void dump(string indent="")
    {
      (void)indent;
-      #ifdef TINY_MQTT_DEBUG
+      #if TINY_MQTT_DEBUG
        uint32_t ms=millis();
-        Serial << indent << "+-- " << '\'' << clientId.c_str() << "' " << (connected() ? " ON " : " OFF");
-        Serial << ", alive=" << alive << '/' << ms << ", ka=" << keep_alive << ' ';
-        Serial << (client && client->connected() ? "" : "dis") << "connected";
+        Console << indent << "+-- " << '\'' << clientId.c_str() << "' " << (connected() ? " ON " : " OFF");
+        Console << ", alive=" << alive << '/' << ms << ", ka=" << keep_alive << ' ';
+        if (tcp_client)
+        {
+          if (tcp_client->connected())
+            Console << TinyConsole::green << "connected";
+          else
+            Console << TinyConsole::red << "disconnected";
+          Console << TinyConsole::white;
+        }
        if (subscriptions.size())
        {
          bool c = false;
-          Serial << " [";
+          Console << " [";
          for(auto s: subscriptions)
-            (void)indent;
          {
-            if (c) Serial << ", ";
-            Serial << s.str().c_str();
+            if (c) Console << ", ";
+            Console << s.str().c_str();
            c=true;
          }
-          Serial << ']';
+          Console << ']';
        }
-        Serial << endl;
+        Console << TinyConsole::erase_to_end << endl;
      #endif
    }

 #ifdef EPOXY_DUINO
    static std::map<MqttMessage::Type, int> counters;  // Number of processed messages
 #endif
+    uint32_t keepAlive() const { return keep_alive; }

  private:
+    bool mqtt_connected() const { return cltFlags & CltFlagConnected; }
+    void setFlag(CltFlags f) { cltFlags |= f; }
+    void resetFlag(CltFlags f) { cltFlags &= ~f; }

    // event when tcp/ip link established (real or fake)
    static void onConnect(void * client_ptr, TcpClient*);
-#ifdef TCP_ASYNC
+#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, TcpClient* client);
+    MqttClient(MqttBroker* local_broker, TcpClient* client);
    // republish a received publish if topic matches any in subscriptions
    MqttError publishIfSubscribed(const Topic& topic, MqttMessage& msg);

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

-    bool mqtt_connected = false;
+    uint8_t cltFlags = CltFlagNone;
    char mqtt_flags;
-    uint32_t keep_alive = 60;
+    uint32_t keep_alive = 30;
    uint32_t alive;
    MqttMessage message;

-    // TODO  having a pointer on MqttBroker may produce larger binaries
-    // due to unecessary function linked if ever parent is not used
-    // (this is the case when MqttBroker isn't used except here)
-    MqttBroker* parent=nullptr;    // connection to local broker
+    // connection to local broker, or link to the parent
+    // when MqttBroker uses MqttClient for each external connexion
+    MqttBroker* local_broker=nullptr;

-    TcpClient* client=nullptr;    // connection to remote broker
+    TcpClient* tcp_client=nullptr;    // connection to remote broker
    std::set<Topic>  subscriptions;
-    std::string clientId;
+    string clientId;
    CallBack callback = nullptr;
 };

 class MqttBroker
 {
-  enum __attribute__((packed)) State
-  {
-    Disconnected,  // Also the initial state
-    Connecting,    // connect and sends a fake publish to avoid circular cnx
-    Connected,    // this->broker is connected and circular cnx avoided
-  };
  public:
    // TODO limit max number of clients
-    MqttBroker(uint16_t port);
+    MqttBroker(uint16_t port, uint8_t retain_size=0);
    ~MqttBroker();

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

-    void connect(const std::string& host, uint16_t port=1883);
-    bool connected() const { return state == Connected; }
+    /** Connect the broker to a parent broker */
+    void connect(const string& host, uint16_t port=1883);
+    /** returns true if connected to another broker */
+    bool connected() const { return remote_broker ? remote_broker->connected() : false; }

    size_t clientsCount() const { return clients.size(); }
+    void retain(uint8_t size) { retain_size = size; }

-    void dump(std::string indent="")
+    void dump(string indent="")
    {
      for(auto client: clients)
        client->dump(indent);
    }

+    const std::vector<MqttClient*>  getClients() const { return clients; }
+
  private:
    friend class MqttClient;

@@ -301,22 +365,43 @@ class MqttBroker
    bool checkPassword(const char* password, uint8_t len) const
    { 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(MqttClient*, const Topic& topic, uint8_t qos);

-    MqttError subscribe(const Topic& topic, uint8_t qos);
-
-    // For clients that are added not by the broker itself
+    // For clients that are added not by the broker itself (local clients)
    void addClient(MqttClient* client);
    void removeClient(MqttClient* client);

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

    const char* auth_user = "guest";
    const char* auth_password = "guest";
-    State state = Disconnected;
+    MqttClient* remote_broker = nullptr;

-    MqttClient* broker = nullptr;
+    void retain(const Topic& topic, const MqttMessage& msg);
+    void retainDrop();
+
+    struct Retain
+    {
+      Retain(unsigned long ts, const MqttMessage& m) : timestamp(ts), msg(m) {}
+      Retain(Retain&& r) : timestamp(r.timestamp), msg(std::move(r.msg)) {}
+
+      Retain& operator=(Retain&& r)
+      {
+        timestamp = r.timestamp;
+        msg = std::move(r.msg);
+        return *this;
+      }
+
+      unsigned long timestamp;
+      MqttMessage msg;
+    };
+
+    std::map<Topic, Retain> retained;
+    uint8_t retain_size;
 };
--- a/src/my_credentials.h
+++ b/src/my_credentials.h
@@ -1,2 +0,0 @@
-const char *ssid     = "YOUR-SSID-HERE";
-const char *password = "YOUR-PASSWORD-HERE";
--- a/tests/Makefile
+++ b/tests/Makefile
@@ -1,20 +1,40 @@
+SUB=
+
+all:runtests
+
 tests:
-	set -e; \
-	for i in *-tests/Makefile; do \
+	@set -e; \
+	for i in $(SUB)*-tests/Makefile; do \
 		echo '==== Making:' $$(dirname $$i); \
 		$(MAKE) -C $$(dirname $$i) -j; \
 	done
+	$(MAKE) -C compile-test

-runtests: tests
-	set -e; \
-	for i in *-tests/Makefile; do \
+valgrind:
+	@set -e; \
+	$(MAKE) tests; \
+	for i in $(SUB)*-tests/Makefile; do \
+		echo '==== Running:' $$(dirname $$i); \
+		valgrind $$(dirname $$i)/$$(dirname $$i).out; \
+	done
+
+debugtest:
+	@set -e; \
+	$(MAKE) clean; \
+	$(MAKE) -C debug-mode -j; \
+	debug-mode/debug-tests.out
+
+runtests:
+	@set -e; \
+	$(MAKE) tests; \
+	for i in $(SUB)*-tests/Makefile; do \
 		echo '==== Running:' $$(dirname $$i); \
 		$$(dirname $$i)/$$(dirname $$i).out; \
 	done

 clean:
-	set -e; \
-	for i in *-tests/Makefile; do \
+	@set -e; \
+	for i in $(SUB)*-tests/Makefile; do \
 		echo '==== Cleaning:' $$(dirname $$i); \
 		$(MAKE) -C $$(dirname $$i) clean; \
 	done
--- a/tests/Makefile.opts
+++ b/tests/Makefile.opts
@@ -0,0 +1,11 @@
+
+# GCC
+# CXXFLAGS = -Wextra -Wall -std=gnu++11 -fno-exceptions -fno-threadsafe-statics
+EXTRA_CXXFLAGS=-g3 -O0 -std=c++17
+
+CXXFLAGS=-D_GNU_SOURCE -Werror=return-type -std=gnu++17 -Wall -g3 -O0
+
+# CLANG SANITIZE
+# CXX=clang
+# EXTRA_CXXFLAGS=-g3 -O0 -fsanitize=memory
+# LDFLAGS = -lpthread -lstdc++
--- a/tests/classbind-tests/Makefile
+++ b/tests/classbind-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 -DTINY_MQTT_TESTS
+
+APP_NAME := classbind-tests
+ARDUINO_LIBS := AUnit AceCommon AceTime TinyMqtt EspMock ESP8266WiFi  ESPAsyncTCP TinyConsole
+ARDUINO_LIB_DIRS := ../../../EspMock/libraries
+EPOXY_CORE := EPOXY_CORE_ESP8266
+include ../../../EpoxyDuino/EpoxyDuino.mk
--- a/tests/classbind-tests/classbind-tests.ino
+++ b/tests/classbind-tests/classbind-tests.ino
@@ -0,0 +1,353 @@
+// vim: ts=2 sw=2 expandtab
+#include <Arduino.h>
+#include <AUnit.h>
+#include <TinyMqtt.h>
+#include <MqttClassBinder.h>
+#include <map>
+#include <iostream>
+#include <iomanip>
+#include <sstream>
+#include <string>
+#include <iostream>
+
+// --------------------- CUT HERE - MQTT MESSAGE ROUTER FILE ----------------------------
+
+class TestReceiver : public MqttClassBinder<TestReceiver>
+{
+  public:
+    TestReceiver(const char* name) : MqttClassBinder(), name_(name) {}
+
+    void onPublish(const MqttClient* /* source */, const Topic& topic, const char* /* payload */, size_t /* length */)
+    {
+      (void) topic;
+      // Serial << "--> routed message received by " << name_ << ':' << topic.c_str() << " = " << payload << endl;
+      messages[name_]++;
+    }
+
+  private:
+    const std::string name_;
+
+  public:
+    static std::map<std::string, int> messages;
+};
+
+std::map<std::string, int> TestReceiver::messages;
+
+static int unrouted = 0;
+void onUnrouted(const MqttClient*, const Topic& topic, const char*, size_t)
+{
+  (void) topic;
+  // Serial << "--> unrouted: " << topic.c_str() << endl;
+  unrouted++;
+}
+
+
+static std::string topic="sensor/temperature";
+
+/**
+  * 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);
+
+void reset_and_start_servers(int n, bool early_accept = true)
+{
+  MqttClassBinder<TestReceiver>::reset();
+  TestReceiver::messages.clear();
+  unrouted = 0;
+
+  ESP8266WiFiClass::resetInstances();
+  ESP8266WiFiClass::earlyAccept = early_accept;
+  while(n)
+  {
+    ESP8266WiFiClass::selectInstance(n--);
+    WiFi.mode(WIFI_STA);
+    WiFi.begin("fake_ssid", "fake_pwd");
+  }
+}
+
+test(classbind_one_client_receives_the_message)
+{
+  reset_and_start_servers(2, true);
+  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());
+
+  TestReceiver receiver("receiver");
+  MqttClassBinder<TestReceiver>::onPublish(&client, &receiver);
+
+  client.subscribe("a/b");
+  client.publish("a/b", "ab");
+
+  for (int i =0; i<10; i++)
+  {
+    client.loop();
+    broker.loop();
+  }
+
+  assertEqual(TestReceiver::messages["receiver"], 1);
+  assertEqual(unrouted, 0);
+}
+
+test(classbind_routes_should_be_empty_when_receiver_goes_out_of_scope)
+{
+  reset_and_start_servers(2, true);
+  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());
+
+  // Make a receiver going out of scope
+  {
+    TestReceiver receiver("receiver");
+    MqttClassBinder<TestReceiver>::onPublish(&client, &receiver);
+    assertEqual(MqttClassBinder<TestReceiver>::size(), (size_t)1);
+  }
+
+  client.subscribe("a/b");
+  client.publish("a/b", "ab");
+
+  for (int i =0; i<10; i++)
+  {
+    client.loop();
+    broker.loop();
+  }
+
+  assertEqual(TestReceiver::messages["receiver"], 0);
+  assertEqual(MqttClassBinder<TestReceiver>::size(), (size_t)0);
+}
+
+test(classbind_publish_should_be_dispatched_to_many_receivers)
+{
+  reset_and_start_servers(2, true);
+  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());
+
+  TestReceiver receiver_1("receiver_1");
+  TestReceiver receiver_2("receiver_2");
+
+  MqttClassBinder<TestReceiver>::onPublish(&client, &receiver_1);
+  MqttClassBinder<TestReceiver>::onPublish(&client, &receiver_2);
+  client.subscribe("a/b");
+  client.publish("a/b", "ab");
+
+  for (int i =0; i<10; i++)
+  {
+    client.loop();
+    broker.loop();
+  }
+
+  assertEqual(TestReceiver::messages["receiver_1"], 1);
+  assertEqual(TestReceiver::messages["receiver_2"], 1);
+}
+
+test(classbind_register_to_many_clients)
+{
+  reset_and_start_servers(2, true);
+  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_1;
+  client_1.connect(ip_broker.toString().c_str(), 1883);
+  broker.loop();
+
+  MqttClient client_2;
+  client_2.connect(ip_broker.toString().c_str(), 1883);
+  broker.loop();
+
+  assertTrue(client_1.connected());
+  assertTrue(client_2.connected());
+
+  TestReceiver receiver("receiver");
+
+  MqttClassBinder<TestReceiver>::onPublish(&client_1, &receiver);
+  MqttClassBinder<TestReceiver>::onPublish(&client_2, &receiver);
+
+  auto loop = [&client_1, &client_2, &broker]()
+  {
+    client_1.loop();
+    client_2.loop();
+    broker.loop();
+  };
+
+  client_1.subscribe("a/b");
+  client_2.subscribe("a/b");
+
+  // Ensure subscribptions are passed
+  for (int i =0; i<5; i++) loop();
+
+  client_1.publish("a/b", "from 1");
+  client_2.publish("a/b", "from 2");
+
+  // Ensure publishes are processed
+  for (int i =0; i<5; i++) loop();
+
+  assertEqual(TestReceiver::messages["receiver"], 4);
+}
+
+test(classbind_unrouted_fallback)
+{
+  reset_and_start_servers(2, true);
+  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());
+
+  MqttClassBinder<TestReceiver>::onUnpublished(onUnrouted);
+  {
+    TestReceiver receiver("receiver");
+    MqttClassBinder<TestReceiver>::onPublish(&client, &receiver);
+  }
+
+  client.subscribe("a/b");
+  client.publish("a/b", "from 2");
+
+  // Ensure subscribptions are passed
+  for (int i =0; i<5; i++)
+  {
+    client.loop();
+    broker.loop();
+  }
+
+  assertEqual(TestReceiver::messages["receiver"], 0);
+  assertEqual(unrouted, 1);
+}
+
+test(classbind_should_cleanup_when_MqttClient_dies)
+{
+  reset_and_start_servers(2, true);
+  TestReceiver receiver("receiver");
+
+  {
+    MqttClient client;
+
+    MqttClassBinder<TestReceiver>::onPublish(&client, &receiver);
+    assertEqual(MqttClassBinder<TestReceiver>::size(), (size_t)1);
+  }
+  assertEqual(MqttClassBinder<TestReceiver>::size(), (size_t)1);
+
+}
+
+//----------------------------------------------------------------------------
+// setup() and loop()
+void setup() {
+  /* delay(1000);
+  Serial.begin(115200);
+  while(!Serial);
+  */
+
+  Serial.println("=============[ TinyMqtt class-bind TESTS       ]========================");
+
+  WiFi.mode(WIFI_STA);
+  WiFi.begin("network", "password");
+}
+
+void loop() {
+  aunit::TestRunner::run();
+
+  if (Serial.available()) ESP.reset();
+}
--- a/tests/compile-test/Makefile
+++ b/tests/compile-test/Makefile
@@ -0,0 +1,11 @@
+# See https://github.com/bxparks/EpoxyDuino for documentation about this
+# Makefile to compile and run Arduino programs natively on Linux or MacOS.
+
+include ../Makefile.opts
+
+APP_NAME := tinymqtt-test
+ARDUINO_LIBS := AUnit AceCommon AceTime TinyMqtt EspMock ESP8266WiFi  ESPAsync ESP8266mDNS TinyConsole
+ARDUINO_LIB_DIRS := ../../../EspMock/libraries
+EPOXY_CORE := EPOXY_CORE_ESP8266
+DUMMY := 1
+include ../../../EpoxyDuino/EpoxyDuino.mk
--- a/tests/compile-test/tinymqtt-test.ino
+++ b/tests/compile-test/tinymqtt-test.ino
@@ -0,0 +1,848 @@
+// vim: ts=2 sw=2 expandtab smartindent
+#include <TinyConsole.h>
+#include <TinyMqtt.h>       // https://github.com/hsaturn/TinyMqtt
+#include <TinyStreaming.h>
+
+#include <sstream>
+#include <string>
+#include <map>
+
+using string = TinyConsole::string;
+
+bool echo_on = true;
+auto green = TinyConsole::green;
+auto red = TinyConsole::red;
+auto white = TinyConsole::white;
+auto cyan = TinyConsole::cyan;
+auto yellow = TinyConsole::yellow;
+auto magenta = TinyConsole::magenta;
+auto save_cursor = TinyConsole::save_cursor;
+auto restore_cursor = TinyConsole::restore_cursor;
+auto erase_to_end = TinyConsole::erase_to_end;
+
+const char* ssid = "";
+const char* password = "";
+
+struct free_broker
+{
+  public:
+    free_broker(const char* s, uint16_t p, const char* /* comment */) : url(s), port(p) {}
+
+    string url;
+    uint16_t port;
+};
+
+const std::map<string, free_broker> list =
+{
+  { "mqtthq", { "public.mqtthq.com" , 8083, "publish/subscribe" }},
+  { "hivemq", { "broker.hivemq.com", 1883, "" }}
+};
+
+/** Very complex example
+  * Console allowing to make any kind of test,
+  * even some stress tests.
+  *
+  * Upload the sketch, the use the terminal.
+  * Press H for mini help.
+  *
+  * tested with mqtt-spy-0.5.4
+  * TODO examples of scripts
+  */
+
+void onPublish(const MqttClient* srce, const Topic& topic, const char* payload, size_t length)
+{
+  Console << cyan << "--> " << srce->id().c_str() << ": received " << topic.c_str() << white;
+  if (payload)
+  {
+    Console << ", payload[" << length << "]=[";
+    while(length--)
+    {
+      const char c=*payload++;
+      if (c<32)
+        Console << '?';
+      else
+        Console << c;
+    }
+    Console << ']' << endl;
+  }
+}
+
+std::map<string, MqttClient*> clients;
+std::map<string, MqttBroker*> brokers;
+std::map<string, string> vars;
+
+void eval(string& cmd);
+
+void replace(const char* d, string& str, string srch, string to)
+{
+  if (d[0] && d[1])
+  {
+    srch=d[0]+srch+d[1];
+    to=d[0]+to+d[1];
+
+    size_t pos = 0;
+    while((pos=str.find(srch, pos)) != string::npos)
+    {
+      str.erase(pos, srch.length());
+      str.insert(pos, to);
+      pos += to.length()-1;
+    }
+  }
+}
+
+void replaceVars(string& cmd)
+{
+  cmd = ' '+cmd+' ';
+
+  for(auto it: vars)
+  {
+    replace("..", cmd, it.first, it.second);
+    replace(". ", cmd, it.first, it.second);
+    replace(" .", cmd, it.first, it.second);
+    replace("  ", cmd, it.first, it.second);
+  }
+  cmd.erase(0, cmd.find_first_not_of(' '));
+  cmd.erase(cmd.find_last_not_of(' ')+1);
+
+}
+
+void onCommand(const string& command)
+{
+  Console << endl;
+  string cmd=command;
+  if (cmd.substr(0,3)!="set") replaceVars(cmd);
+  eval(cmd);
+  Console << endl;
+  Console.prompt();
+}
+
+void setup()
+{
+  Serial.begin(115200);
+  Console.begin(Serial);
+  Console.setPrompt("> ");
+  Console.setCallback(onCommand);
+  delay(500);
+
+  Console.cls();
+  Console << endl << endl;
+  Console << yellow
+          << "***************************************************************" << endl;
+  Console << "*  Welcome to the TinyMqtt console" << endl;
+  Console << "*  The console allows to test all features of the libraries." << endl;
+  Console << "*  Enter help to view the list of commands." << endl;
+  Console << "***************************************************************" << endl;
+  Console << endl;
+  if (strlen(ssid)==0)
+    Console << red << "*  ERROR: You must modify ssid/password in order" << endl
+                   << "          to be able to connect to your Wifi network." << endl;
+  Console << endl << white;
+
+  Console << "Connecting to '" << ssid << "' ";
+
+  WiFi.mode(WIFI_STA);
+  WiFi.begin(ssid, password);
+  WiFi.mode(WIFI_STA);
+  WiFi.begin(ssid, password);
+
+  while (WiFi.status() != WL_CONNECTED)
+  { Console << '-'; delay(500); }
+
+  Console << endl << "Connected to " << ssid << "IP address: " << WiFi.localIP() << endl;
+
+  const char* name="tinytest";
+  Console << "Starting MDNS, name= " << name;
+
+  MqttBroker* broker = new MqttBroker(1883);
+  broker->begin();
+  brokers["broker"] = broker;
+
+  if (Console.isTerm()) onCommand("every 333 view");
+}
+
+string getword(string& str, const char* if_empty=nullptr, char sep=' ');
+
+int getint(string& str, const int if_empty=0)
+{
+  string str2=str;
+  string sword = getword(str);
+  if (sword[0] and isdigit(sword[0]))
+  {
+    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;
+  }
+  str=str2;
+  return if_empty;
+}
+
+string getword(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);
+  string sword;
+  while(str.length() and (str[0]!=sep or quote))
+  {
+    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]!=')') Console << "Missing ')'" << endl;
+      }
+      else
+      {
+        to=from;
+        from=0;
+      }
+      return String(random(from,to)).c_str();
+    }
+    else
+    {
+      Console << "Missing '('" << endl;
+    }
+  }
+  while(str[0]==' ') str.erase(0,1);
+  return sword;
+}
+
+bool isaddr(string s)
+{
+  if (s.length()==0 or s.length()>3) return false;
+  for(char c: s)
+    if (c<'0' or c>'9') return false;
+  return true;
+}
+
+string getip(string& str, const char* if_empty=nullptr, char sep=' ')
+{
+  string addr=getword(str, if_empty, sep);
+  string ip=addr;
+  std::vector<string> build;
+  while(ip.length())
+  {
+    string b=getword(ip,nullptr,'.');
+    if (isaddr(b) && build.size()<4)
+    {
+      build.push_back(b);
+    }
+    else
+      return addr;
+  }
+  IPAddress local=WiFi.localIP();
+  addr.clear();
+  while(build.size()!=4)
+  {
+    std::stringstream b;
+    b << (int)local[3-build.size()];
+    build.insert(build.begin(), b.str().c_str());
+  }
+  for(string s: build)
+  {
+    if (addr.length()) addr += '.';
+    addr += s;
+  }
+  Console << "connect address: " << addr << endl;
+  return addr;
+}
+
+std::set<string> commands = {
+  "broker", "blink", "client", "connect",
+  "create", "delete", "debug", "help", "interval",
+  "list", "ls", "ip", "off", "on", "set",
+  "publish", "reset", "subscribe", "unsubscribe", "view", "echo", "every"
+};
+
+void convertToCommand(string& search)
+{
+  while(search[0]==' ') search.erase(0,1);
+  if (search.length()==0) return;
+  string matches;
+  int count=0;
+  for(string cmd: commands)
+  {
+    if (cmd.substr(0, search.length()) == search)
+    {
+      if (count) matches +=", ";
+      count++;
+      matches += cmd;
+    }
+  }
+  if (count==1)
+    search = matches;
+  else if (count>1)
+  {
+    Console << "Ambiguous command: " << matches << endl;
+    search.clear();
+  }
+}
+
+bool compare(string s, const char* cmd)
+{
+  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(*)(string& cmd, MqttClient* publish);
+
+struct Every
+{
+  string cmd;
+  uint32_t ms;
+  uint32_t next;
+  uint32_t underrun=0;
+  bool active=true;
+
+  void dump()
+  {
+    if (active)
+      Console << green << "enabled";
+    else
+      Console << red << "disabled";
+
+    auto mill=millis();
+    Console << white << ms << "ms [" << cmd << "] next in ";
+    if (mill > next)
+      Console << "now";
+    else
+      Console << next-mill << "ms";
+  }
+};
+
+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 clientConnect(MqttClient* client, string& cmd)
+{
+  string remote = getword(cmd);
+  uint16_t port;
+  auto it=list.find(remote);
+  if (it != list.end())
+  {
+    Console << "Connecting to free broker: " << remote << endl;
+    remote = it->second.url;
+    port=it->second.port;
+  }
+  else
+    port=getint(cmd);
+
+  client->connect(remote.c_str(), port, getint(cmd, 60));
+  Console << (client->connected() ? "connected." : "not connected") << endl;
+}
+
+void eval(string& cmd)
+{
+  while(cmd.length())
+  {
+    MqttError retval = MqttOk;
+
+    string s;
+    MqttBroker* broker = nullptr;
+    MqttClient* client = nullptr;
+
+    // client.function notation
+    if (cmd.find('.') != string::npos &&
+        cmd.find('.') < cmd.find(' '))
+    {
+      s=getword(cmd, nullptr, '.');
+
+      if (s.length())
+      {
+        if (clients.find(s) != clients.end())
+        {
+          client = clients[s];
+        }
+        else if (brokers.find(s) != brokers.end())
+        {
+          broker = brokers[s];
+        }
+        else
+        {
+          Console << red << "Unknown class (" << s.c_str() << ")" << white << endl;
+          cmd.clear();
+        }
+      }
+    }
+
+    s = getword(cmd);
+    if (s.length()) convertToCommand(s);
+    if (s.length()==0)
+    {}
+    else if (compare(s, "debug"))
+    {
+#if TINY_MQTT_DEBUG
+      TinyMqtt::debug = getint(cmd);
+#else
+      Console << red << "TinyMqtt not compiled in debug" << endl;
+#endif
+    }
+    else if (compare(s, "list"))
+    {
+      Console << "List of free servers" << endl;
+      for(const auto& fb: list)
+      {
+        Console << "  " << fb.first << " : " << fb.second.url << ":" << fb.second.port << endl;
+      }
+    }
+    else if (compare(s, "delete"))
+    {
+      if (client==nullptr && broker==nullptr)
+      {
+        s = getword(cmd);
+        if (clients.find(s) != clients.end())
+        {
+          client = clients[s];
+        }
+        else if (brokers.find(s) != brokers.end())
+        {
+          broker = brokers[s];
+        }
+        else
+          Console << red << "Unable to find (" << s.c_str() << ")" << white << endl;
+      }
+      if (client)
+      {
+        for (auto it: clients)
+        {
+          if (it.second != client) continue;
+          Console << "deleted" << endl;
+          delete (it.second);
+          clients.erase(it.first);
+          break;
+        }
+        cmd += " ls";
+      }
+      else if (broker)
+      {
+        for(auto it: brokers)
+        {
+          if (broker != it.second) continue;
+          Console << "deleted" << endl;
+          delete (it.second);
+          brokers.erase(it.first);
+          break;
+        }
+        cmd += " ls";
+      }
+      else
+        Console << "Nothing to delete" << endl;
+    }
+    else if (broker)
+    {
+      if (compare(s,"connect"))
+      {
+        Console << "NYI" << endl;
+      }
+      else if (compare(s, "view"))
+      {
+        broker->dump();
+      }
+      else
+      {
+        Console << "Unknown broker command (" << s << ")" << endl;
+        s.clear();
+      }
+    }
+    else if (client)
+    {
+      if (compare(s,"connect"))
+      {
+        clientConnect(client, cmd);
+      }
+      else if (compare(s,"publish"))
+      {
+        retval = client->publish(getword(cmd), getword(cmd));
+      }
+      else if (compare(s,"subscribe"))
+      {
+        client->subscribe(getword(cmd));
+      }
+      else if (compare(s, "unsubscribe"))
+      {
+        client->unsubscribe(getword(cmd));
+      }
+      else if (compare(s, "view"))
+      {
+        client->dump();
+      }
+      else
+      {
+        Console << "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
+      {
+        Console << s << ' ';
+        while(cmd.length())
+        {
+          Console << 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();
+          Console << 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)
+            {
+              Console << "every #" << count << (active ? " on" :" off") << endl;
+              every.active = active;
+              every.underrun = 0;
+            }
+          }
+          count++;
+        }
+      }
+      else if (compare(cmd, "list") or cmd.length()==0)
+      {
+        getword(cmd);
+        Console << "List of everies (ms=" << millis() << ")" << endl;
+        uint8_t count=0;
+        for(auto& every: everies)
+        {
+          Console << count << ": ";
+          every.dump();
+          Console << endl;
+          count++;
+        }
+      }
+      else if (compare(cmd, "remove"))
+      {
+        Console << "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
+          Console << "Bad colmmand" << endl;
+      }
+      else
+        Console << "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();
+        Console << "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, "broker"))
+    {
+      string id=getword(cmd);
+      if (clients.find(id) != clients.end())
+      {
+        Console << "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)
+        {
+          MqttBroker* broker = new MqttBroker(port);
+          broker->begin();
+
+          brokers[id] = broker;
+          Console << "new broker (" << id.c_str() << ")" << endl;
+        }
+        else
+        {
+          Console << "Missing port" << endl;
+          cmd.clear();
+        }
+      }
+      else
+      {
+        Console << "Missing or existing broker name (" << id.c_str() << ")" << endl;
+        cmd.clear();
+      }
+    }
+    else if (compare(s, "client"))
+    {
+      string id=getword(cmd);
+      if (brokers.find(id) != brokers.end())
+      {
+        Console << "A broker have that name" << endl;
+        cmd.clear();
+      }
+      else if (id.length() or clients.find(id)!=clients.end())
+      {
+        s=getword(cmd);  // broker
+        if (s=="" or brokers.find(s) != brokers.end() or list.find(s) != list.end())
+        {
+          MqttBroker* broker = nullptr;
+          if (s.length()) broker = brokers[s];
+          MqttClient* client = new MqttClient(broker, id);
+          clients[id]=client;
+          client->setCallback(onPublish);
+          if (list.find(s) != list.end())
+          {
+            cmd=s+' '+cmd;
+            clientConnect(client, cmd);
+          }
+          Console << "new client (" << id.c_str() << ", " << s.c_str() << ')' << endl;
+        }
+        else if (s.length())
+        {
+          Console << " not found." << endl;
+          cmd.clear();
+        }
+      }
+      else
+      {
+        Console << "Missing or existing client name" << endl;
+        cmd.clear();
+      }
+    }
+    else if (compare(s, "set"))
+    {
+      string name(getword(cmd));
+      if (name.length()==0)
+      {
+        for(auto it: vars)
+        {
+          Console << "  " << it.first << " -> " << it.second << endl;
+        }
+      }
+      else if (commands.find(name) != commands.end())
+      {
+        Console << "Reserved keyword (" << name << ")" << endl;
+        cmd.clear();
+      }
+      else
+      {
+        if (cmd.length())
+        {
+          vars[name] = cmd;
+          cmd.clear();
+        }
+        else if (vars.find(name) != vars.end())
+          vars.erase(vars.find(name));
+      }
+    }
+    else if (compare(s, "ls") or compare(s, "view"))
+    {
+      bool view = compare(s, "view");
+      if (view)
+      {
+        Console << save_cursor << magenta;
+        Console.gotoxy(1,1);
+      }
+      Console << "--< " << '/' << clients.size() << " client/s. >--" << erase_to_end << endl;
+      for(auto it: clients)
+      {
+        it.second->dump("  ");
+      }
+
+      Console << "--< " << brokers.size() << " brokers/s. >--" << erase_to_end << endl;
+      for(auto it: brokers)
+      {
+        Console << "  +-- '" << it.first.c_str() << "' " << it.second->clientsCount() << " client/s."<< erase_to_end << endl;
+        it.second->dump("     ");
+      }
+      if (view)
+      {
+        Console.bg(white);
+        Console << erase_to_end << restore_cursor;
+      }
+    }
+    else if (compare(s, "reset"))
+      ESP.restart();
+    else if (compare(s, "ip"))
+      Console << "IP: " << WiFi.localIP() << endl;
+    else if (compare(s,"help"))
+    {
+      Console << "syntax:" << endl;
+      Console << "  MqttBroker:" << endl;
+      Console << "    broker {broker_name} {port} : create a new broker" << endl;
+      Console << "      broker_name can be one of 'list'" << endl;
+      Console << "      broker_name.delete : delete a broker (buggy)" << endl;
+      Console << "      broker_name.view   : dump a broker" << endl;
+      Console << endl;
+      Console << "  MqttClient:" << endl;
+      Console << "    client {name} {broker} : create a client then" << endl;
+      Console << "      name.connect  [ip] [port] [alive]" << endl;
+      Console << "      name.[un]subscribe topic" << endl;
+      Console << "      name.publish topic [payload]" << endl;
+      Console << "      name.view" << endl;
+      Console << "      name.delete" << endl;
+      Console << endl;
+      Console << "  list : list of free brokers (debug 1 advised)" << endl;
+      Console << "  debug #" << endl;
+      Console << "  list : get list of free brokers" << endl;
+      Console << "  blink [Dx on_ms off_ms]    : make pin blink" << endl;
+      Console << "  ls / ip / reset" << endl;
+      Console << "  set [name][value]" << endl;
+      Console << "  !  repeat last command" << endl;
+      Console << endl;
+      Console << "  echo [on|off] or strings" << endl;
+      Console << "  every ms [command]; every list; every remove [nr|all]; every (on|off) [#]" << endl;
+      Console << "  on {output}; off {output}" << endl;
+      Console << "  $id : name of the client." << endl;
+      Console << "  rnd[(min[,max])] random number." << endl;
+      Console << endl;
+    }
+    else
+    {
+      while(s[0]==' ') s.erase(0,1);
+      if (s.length())
+        Console << "Unknown command (" << s.c_str() << ")" << endl;
+    }
+
+    if (retval != MqttOk)
+    {
+      Console << "# 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)
+    {
+      string cmd(every.cmd);
+      eval(cmd);
+      every.next += every.ms;
+      if (ms > every.next and ms > every.underrun)
+      {
+        every.next += every.ms;
+        Console << yellow << "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++;
+  }
+
+#if defined(ESP9266)
+  MDNS.update();
+#endif
+
+  for(auto it: brokers)
+    it.second->loop();
+
+  for(auto it: clients)
+    it.second->loop();
+
+  Console.loop();
+}
--- 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 TinyConsole
+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/length-tests.todo/Makefile
+++ b/tests/length-tests.todo/Makefile
@@ -1,8 +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_LIBS := AUnit AceCommon AceTime TinyMqtt EspMock ESP8266WiFi  ESPAsyncTCP TinyConsole
 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
@@ -1,3 +1,4 @@
+// vim: ts=2 sw=2 expandtab
 #include <AUnit.h>
 #include <TinyMqtt.h>
 #include <map>
--- a/tests/local-tests/Makefile
+++ b/tests/local-tests/Makefile
@@ -1,13 +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
-
-# Remove flto flag from EpoxyDuino (too many <optimized out>)
-CXXFLAGS = -Wextra -Wall -std=gnu++11 -fno-exceptions -fno-threadsafe-statics
+include ../Makefile.opts

 APP_NAME := local-tests
-ARDUINO_LIBS := AUnit AceCommon AceTime TinyMqtt EspMock ESP8266WiFi  ESPAsyncTCP
+ARDUINO_LIBS := AUnit AceCommon AceTime TinyMqtt EspMock ESP8266WiFi  ESPAsyncTCP TinyConsole
 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
@@ -12,23 +12,32 @@
  * Also, this will allow to mock and thus run Action on github
  **/

-using namespace std;
+using string = TinyConsole::string;

 MqttBroker broker(1883);

-std::map<std::string, std::map<Topic, int>>	published;		// map[client_id] => map[topic] = count
+std::map<string, std::map<Topic, int>>  published;    // map[client_id] => map[topic] = count

-const char* lastPayload;
+std::string 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;
+  lastPayload = std::string(payload, length);
  lastLength = length;
 }

+test(local_not_connected_by_default)
+{
+  MqttClient client;
+  assertEqual(client.connected(), false);
+
+  MqttBroker broker(1883);
+  assertEqual(broker.connected(), false);
+}
+
 test(local_client_should_unregister_when_destroyed)
 {
  assertEqual(broker.clientsCount(), (size_t)0);
@@ -40,27 +49,70 @@ test(local_client_should_unregister_when_destroyed)
  assertEqual(broker.clientsCount(), (size_t)0);
 }

-#if 0
+test(local_client_do_not_disconnect_after_publishing_and_long_inactivity)
+{
+  published.clear();
+  EpoxyTest::set_millis(0);
+  MqttBroker broker(1883);
+  MqttClient client(&broker, "client");
+  MqttClient sender(&broker, "sender");
+  broker.loop();
+
+  client.subscribe("#");
+  client.subscribe("test");
+  client.setCallback(onPublish);
+  assertEqual(broker.clientsCount(), (size_t)2);
+
+  sender.publish("test", "value");
+  broker.loop();
+
+  EpoxyTest::add_seconds(600);
+  client.loop();
+  sender.loop();
+  broker.loop();
+
+  sender.publish("test", "value");
+  broker.loop();
+  sender.loop();
+  broker.loop();
+
+  assertEqual(broker.clientsCount(), (size_t)2);
+  assertEqual(sender.connected(), true);
+  assertEqual(client.connected(), true);
+
+  assertEqual(published.size(), (size_t)1);  // client has received something
+}
+
 test(local_connect)
 {
  assertEqual(broker.clientsCount(), (size_t)0);

-	MqttClient client;
+  MqttClient client(&broker);
  assertTrue(client.connected());
  assertEqual(broker.clientsCount(), (size_t)1);
 }

+test(local_publish_to_nowhere)
+{
+  published.clear();
+  assertEqual(broker.clientsCount(), (size_t)0);
+
+  MqttClient publisher;
+  MqttError status = publisher.publish("a/b");
+  assertEqual(status, MqttError::MqttNowhereToSend);
+}
+
 test(local_publish_should_be_dispatched)
 {
  published.clear();
  assertEqual(broker.clientsCount(), (size_t)0);

-	MqttClient subscriber;
+  MqttClient subscriber(&broker, "");
  subscriber.subscribe("a/b");
  subscriber.subscribe("a/c");
  subscriber.setCallback(onPublish);

-	MqttClient publisher;
+  MqttClient publisher(&broker);
  publisher.publish("a/b");
  publisher.publish("a/c");
  publisher.publish("a/c");
@@ -70,21 +122,40 @@ test(local_publish_should_be_dispatched)
  assertEqual(published[""]["a/c"], 2);
 }

+test(hudge_payload)
+{
+  published.clear();
+  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);
+  assertEqual(broker.clientsCount(), (size_t)1);
+  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.c_str());
+  assertEqual(lastLength, strlen(payload));
+  assertEqual(strncmp(payload, lastPayload.c_str(), lastLength), 0);
+}
+
 test(local_publish_should_be_dispatched_to_local_clients)
 {
  published.clear();
  assertEqual(broker.clientsCount(), (size_t)0);

-	MqttClient subscriber_a("A");
+  MqttClient subscriber_a(&broker, "A");
  subscriber_a.setCallback(onPublish);
  subscriber_a.subscribe("a/b");
  subscriber_a.subscribe("a/c");

-	MqttClient subscriber_b("B");
+  MqttClient subscriber_b(&broker, "B");
  subscriber_b.setCallback(onPublish);
  subscriber_b.subscribe("a/b");

-	MqttClient publisher;
+  MqttClient publisher(&broker);
  publisher.publish("a/b");
  publisher.publish("a/c");

@@ -100,11 +171,11 @@ test(local_unsubscribe)
  published.clear();
  assertEqual(broker.clientsCount(), (size_t)0);

-	MqttClient subscriber;
+  MqttClient subscriber(&broker, "");
  subscriber.setCallback(onPublish);
  subscriber.subscribe("a/b");

-	MqttClient publisher;
+  MqttClient publisher(&broker);
  publisher.publish("a/b");

  subscriber.unsubscribe("a/b");
@@ -120,9 +191,9 @@ test(local_nocallback_when_destroyed)
  published.clear();
  assertEqual(broker.clientsCount(), (size_t)0);

-	MqttClient publisher;
+  MqttClient publisher(&broker);
  {
-		MqttClient subscriber;
+    MqttClient subscriber(&broker);
    subscriber.setCallback(onPublish);
    subscriber.subscribe("a/b");
    publisher.publish("a/b");
@@ -132,7 +203,6 @@ test(local_nocallback_when_destroyed)

  assertEqual(published.size(), (size_t)1);  // Only one publish has been received
 }
-#endif

 //----------------------------------------------------------------------------
 // setup() and loop()
--- a/tests/network-tests/Makefile
+++ b/tests/network-tests/Makefile
@@ -1,13 +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
+include ../Makefile.opts

 # Remove flto flag from EpoxyDuino (too many <optimized out>)
-CXXFLAGS = -Wextra -Wall -std=gnu++11 -fno-exceptions -fno-threadsafe-statics
+# 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_LIBS := AUnit AceCommon AceTime TinyMqtt EspMock ESP8266WiFi  ESPAsyncTCP TinyConsole
 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
@@ -1,3 +1,4 @@
+// vim: ts=2 sw=2 expandtab
 #include <Arduino.h>
 #include <AUnit.h>
 #include <TinyMqtt.h>
@@ -6,6 +7,7 @@
 #include <iomanip>
 #include <sstream>
 #include <string>
+#include <iostream>

 /**
  * TinyMqtt network unit tests.
@@ -14,6 +16,8 @@
  * Checks with a local broker. Clients must connect to the local broker
  **/

+using string = TinyConsole::string;
+
 // 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)
 {
@@ -76,12 +80,12 @@ String toString(const IPAddress& ip)

 MqttBroker broker(1883);

-std::map<std::string, std::map<Topic, int>>	published;		// map[client_id] => map[topic] = count
+std::map<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)
+void start_many_wifi_esp(int n, bool early_accept = true)
 {
    ESP8266WiFiClass::resetInstances();
    ESP8266WiFiClass::earlyAccept = early_accept;
@@ -103,7 +107,7 @@ void onPublish(const MqttClient* srce, const Topic& topic, const char* payload,
  lastLength = length;
 }

-test(network_single_broker_begin)
+test(single_broker_begin)
 {
  assertEqual(WiFi.status(), WL_CONNECTED);

@@ -115,7 +119,7 @@ test(network_single_broker_begin)

 test(suback)
 {
-  start_servers(2, true);
+  start_many_wifi_esp(2, true);
  assertEqual(WiFi.status(), WL_CONNECTED);

  MqttBroker broker(1883);
@@ -140,9 +144,151 @@ test(suback)
  assertEqual(MqttClient::counters[MqttMessage::Type::SubAck], 1);
 }

-test(network_client_to_broker_connexion)
+test(client_keep_alive_high)
 {
-  start_servers(2, true);
+  const uint32_t keep_alive=1000;
+  start_many_wifi_esp(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, keep_alive);
+  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);
+
+  uint32_t sz = broker.getClients().size();
+  assertEqual(sz , (uint32_t)1);
+
+  uint32_t ka = broker.getClients()[0]->keepAlive();
+  assertEqual(ka, keep_alive);
+
+}
+
+test(retained_message)
+{
+  published.clear();
+
+  start_many_wifi_esp(2, true);
+  assertEqual(WiFi.status(), WL_CONNECTED);
+
+  MqttBroker broker(1883);
+  broker.begin();
+  broker.retain(10);
+  IPAddress broker_ip = WiFi.localIP();
+
+  MqttClient local_client(&broker);
+
+  // Send a retained message
+  // No remote client connected
+  local_client.publish("topic", "retained", true);
+
+  for(int i=0; i<2; i++)
+  {
+    broker.loop();
+    local_client.loop();
+  };
+
+  // No connect a client from 2nd Esp
+  ESP8266WiFiClass::selectInstance(2);
+  MqttClient remote_client;
+  remote_client.connect(broker_ip, 1883);
+  remote_client.setCallback(onPublish);
+
+  assertTrue(remote_client.connected());
+  for(int i=0; i<4; i++) { broker.loop(); local_client.loop(); remote_client.loop(); };
+  assertEqual(broker.clientsCount(), (size_t) 2);
+
+  // Should not have received anything yet
+  assertEqual(published.size(), (size_t)0);
+
+  // Now, remote client subscribes to topic
+  remote_client.subscribe("topic");
+  for(int i=0; i<4; i++) { broker.loop(); local_client.loop(); remote_client.loop(); };
+
+  // Check that the retained message is published
+  assertEqual(published.size(), (size_t)1);
+
+  // FIXME we should check that
+  // 1 - Retained message has the retain flag set
+  // 2 - Published retained messages that are send normally have their retain flag off
+
+  // The next part of this test does not pass yet (due to remote_client.close()
+  // that does not work well.
+  return;
+
+  // Now remove the retained message
+  remote_client.close();
+  for(int i=0; i<4; i++) { broker.loop(); local_client.loop(); remote_client.loop(); };
+  assertFalse(remote_client.connected());
+  assertEqual(broker.clientsCount(), (size_t) 1);
+
+  // Disconnect / reconnect the remote clien that should receive again the message
+  remote_client.connect(broker_ip, 1883);
+  remote_client.subscribe("topic");
+  assertTrue(remote_client.connected());
+  for(int i=0; i<4; i++) { broker.loop(); local_client.loop(); remote_client.loop(); };
+  assertEqual(broker.clientsCount(), (size_t) 2);
+  assertEqual(published.size(), (size_t)2);
+
+  // Remove the retained message now
+  local_client.publish("topic", "", true);
+  assertEqual(published.size(), (size_t)1);
+
+  // And reconnect the remote client
+  remote_client.connect(broker_ip, 1883);
+  for(int i=0; i<4; i++) { broker.loop(); local_client.loop(); remote_client.loop(); };
+  assertEqual(broker.clientsCount(), (size_t) 2);
+
+  // check that the message was received
+  assertEqual(published.size(), (size_t)2);
+}
+
+test(remote_client_disconnect_reconnect)
+{
+  published.clear();
+  start_many_wifi_esp(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, 1883);
+
+  for(int i=0; i<4; i++) { broker.loop(); client.loop(); };
+  assertEqual(broker.clientsCount(), (size_t) 1);
+
+  // Disconnect the client
+  client.close();
+  for(int i=0; i<4; i++) { broker.loop(); client.loop(); };
+  assertEqual(broker.clientsCount(), (size_t) 0);
+
+  // Reconnect the client
+  client.connect(broker_ip, 1883);
+  for(int i=0; i<4; i++) { broker.loop(); client.loop(); };
+  assertEqual(broker.clientsCount(), (size_t) 1);
+}
+
+test(client_to_broker_connexion)
+{
+  start_many_wifi_esp(2, true);
  assertEqual(WiFi.status(), WL_CONNECTED);

  MqttBroker broker(1883);
@@ -158,9 +304,9 @@ test(network_client_to_broker_connexion)
  assertTrue(client.connected());
 }

-test(network_one_client_one_broker_publish_and_subscribe_through_network)
+test(one_client_one_broker_publish_and_subscribe)
 {
-  start_servers(2, true);
+  start_many_wifi_esp(2, true);
  published.clear();
  assertEqual(WiFi.status(), WL_CONNECTED);

@@ -189,9 +335,9 @@ test(network_one_client_one_broker_publish_and_subscribe_through_network)
  assertEqual((int)lastLength, (int)2); // sizeof(ab)
 }

-test(network_one_client_one_broker_hudge_publish_and_subscribe_through_network)
+test(one_client_one_broker_hudge_payload)
 {
-  start_servers(2, true);
+  start_many_wifi_esp(2, true);
  published.clear();
  assertEqual(WiFi.status(), WL_CONNECTED);

@@ -208,8 +354,8 @@ test(network_one_client_one_broker_hudge_publish_and_subscribe_through_network)

  std::string sent;

-  for(int i=0; i<200; i++)
-    sent += char('0'+i%10);
+  for(int i=0; i<400; i++)
+    sent += char('a'+i%26);

  client.setCallback(onPublish);
  client.subscribe("a/b");
@@ -225,7 +371,7 @@ test(network_one_client_one_broker_hudge_publish_and_subscribe_through_network)
  assertEqual((unsigned int)lastLength, (unsigned int)sent.size());
 }

-test(network_client_should_unregister_when_destroyed)
+test(client_should_unregister_when_destroyed)
 {
  assertEqual(broker.clientsCount(), (size_t)0);
  {
@@ -239,7 +385,7 @@ test(network_client_should_unregister_when_destroyed)
 // THESE TESTS ARE IN LOCAL MODE
 // WE HAVE TO CONVERT THEM TO WIFI MODE (pass through virtual TCP link)

-test(network_connect)
+test(connect)
 {
  assertEqual(broker.clientsCount(), (size_t)0);

@@ -248,7 +394,7 @@ test(network_connect)
  assertEqual(broker.clientsCount(), (size_t)1);
 }

-test(network_publish_should_be_dispatched)
+test(publish_should_be_dispatched)
 {
  published.clear();
  assertEqual(broker.clientsCount(), (size_t)0);
@@ -264,11 +410,11 @@ test(network_publish_should_be_dispatched)
  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);
+  assertEqual(published[TINY_MQTT_DEFAULT_CLIENT_ID]["a/b"], 1);
+  assertEqual(published[TINY_MQTT_DEFAULT_CLIENT_ID]["a/c"], 2);
 }

-test(network_publish_should_be_dispatched_to_clients)
+test(publish_should_be_dispatched_to_clients)
 {
  published.clear();
  assertEqual(broker.clientsCount(), (size_t)0);
@@ -293,7 +439,7 @@ test(network_publish_should_be_dispatched_to_clients)
  assertEqual(published["B"]["a/c"], 0);
 }

-test(network_unsubscribe)
+test(unsubscribe)
 {
  published.clear();
  assertEqual(broker.clientsCount(), (size_t)0);
@@ -310,10 +456,10 @@ test(network_unsubscribe)
  publisher.publish("a/b");    // Those one, no (unsubscribed)
  publisher.publish("a/b");

-	assertEqual(published[""]["a/b"], 1);	// Only one publish has been received
+  assertEqual(published[TINY_MQTT_DEFAULT_CLIENT_ID]["a/b"], 1);  // Only one publish has been received
 }

-test(network_nocallback_when_destroyed)
+test(nocallback_when_destroyed)
 {
  published.clear();
  assertEqual(broker.clientsCount(), (size_t)0);
@@ -332,7 +478,7 @@ test(network_nocallback_when_destroyed)
  assertEqual(published.size(), (size_t)1);  // Only one publish has been received
 }

-test(network_small_payload)
+test(small_payload)
 {
  published.clear();

@@ -350,7 +496,7 @@ test(network_small_payload)
  assertEqual(lastLength, (size_t)4);
 }

-test(network_hudge_payload)
+test(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 !";

@@ -367,6 +513,20 @@ test(network_hudge_payload)
  assertEqual(strcmp(payload, lastPayload), 0);
 }

+test(disconnected_when_broker_is_deleted)
+{
+  MqttBroker* broker = new MqttBroker(1883);
+  broker->begin();
+
+  MqttClient client;
+  client.connect(broker);
+  assertEqual(client.connected(), true);
+  client.publish("a", "b");
+
+  delete broker;
+  assertEqual(client.connected(), false);
+}
+
 test(connack)
 {
  const bool view = false;
@@ -383,7 +543,7 @@ test(connack)
    }
  );

-  start_servers(2, true);
+  start_many_wifi_esp(2, true);
  assertEqual(WiFi.status(), WL_CONNECTED);

  MqttBroker broker(1883);
@@ -416,7 +576,7 @@ void setup() {
  while(!Serial);
  */

-	Serial.println("=============[ FAKE NETWORK TinyMqtt TESTS       ]========================");
+  Serial.println("=============[ NETWORK TinyMqtt TESTS       ]========================");

  WiFi.mode(WIFI_STA);
  WiFi.begin("network", "password");
@@ -426,4 +586,5 @@ void loop() {
  aunit::TestRunner::run();

  if (Serial.available()) ESP.reset();
+  published.clear();  // Avoid crash in unit tests due to exit handlers
 }
--- a/tests/nowifi-tests/Makefile
+++ b/tests/nowifi-tests/Makefile
@@ -1,13 +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
-
-# Remove flto flag from EpoxyDuino (too many <optimized out>)
-CXXFLAGS = -Wextra -Wall -std=gnu++11 -fno-exceptions -fno-threadsafe-statics
+include ../Makefile.opts

 APP_NAME := nowifi-tests
-ARDUINO_LIBS := AUnit AceCommon AceTime TinyMqtt EspMock ESP8266WiFi  ESPAsyncTCP
+ARDUINO_LIBS := AUnit AceCommon AceTime TinyMqtt EspMock ESP8266WiFi  ESPAsyncTCP TinyConsole
 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
@@ -1,3 +1,4 @@
+// vim: ts=2 sw=2 expandtab
 #include <Arduino.h>
 #include <AUnit.h>
 #include <TinyMqtt.h>
@@ -10,11 +11,11 @@
  * Checks with a local broker. Clients must connect to the local broker
  **/

-using namespace std;
+using string = TinyConsole::string;

 MqttBroker broker(1883);

-std::map<std::string, std::map<Topic, int>>	published;		// map[client_id] => map[topic] = count
+std::map<string, std::map<Topic, int>>  published;    // map[client_id] => map[topic] = count

 char* lastPayload = nullptr;
 size_t lastLength;
@@ -64,8 +65,8 @@ test(nowifi_publish_should_be_dispatched)
  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);
+  assertEqual(published[TINY_MQTT_DEFAULT_CLIENT_ID]["a/b"], 1);
+  assertEqual(published[TINY_MQTT_DEFAULT_CLIENT_ID]["a/c"], 2);
 }

 test(nowifi_publish_should_be_dispatched_to_clients)
@@ -93,6 +94,104 @@ test(nowifi_publish_should_be_dispatched_to_clients)
  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();
@@ -110,7 +209,7 @@ test(nowifi_unsubscribe)
  publisher.publish("a/b");    // Those one, no (unsubscribed)
  publisher.publish("a/b");

-	assertEqual(published[""]["a/b"], 1);	// Only one publish has been received
+  assertEqual(published[TINY_MQTT_DEFAULT_CLIENT_ID]["a/b"], 1);  // Only one publish has been received
 }

 test(nowifi_nocallback_when_destroyed)
@@ -180,4 +279,5 @@ void loop() {
  aunit::TestRunner::run();

  if (Serial.available()) ESP.reset();
+  published.clear();  // Avoid crash at exit handlers
 }
--- a/tests/string-indexer-tests/Makefile
+++ b/tests/string-indexer-tests/Makefile
@@ -1,8 +1,10 @@
 # See https://github.com/bxparks/EpoxyDuino for documentation about this
 # Makefile to compile and run Arduino programs natively on Linux or MacOS.

+include ../Makefile.opts
+
 APP_NAME := string-indexer-tests
-ARDUINO_LIBS := AUnit AceCommon AceTime TinyMqtt EspMock ESP8266WiFi  ESPAsync
+ARDUINO_LIBS := AUnit AceCommon AceTime TinyMqtt EspMock ESP8266WiFi  ESPAsync TinyConsole
 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
@@ -1,3 +1,4 @@
+// vim: ts=2 sw=2 expandtab
 #include <Arduino.h>
 #include <AUnit.h>
 #include <StringIndexer.h>
@@ -8,7 +9,7 @@
  *
  **/

-using namespace std;
+using string = TinyConsole::string;

 test(indexer_empty)
 {
@@ -62,6 +63,14 @@ test(indexer_same_strings_should_equal)
  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");
@@ -75,7 +84,7 @@ test(indexer_indexed_operator_eq)

 test(indexer_get_string)
 {
-	std::string sone("one");
+  string sone("one");
  IndexedString one(sone);

  assertTrue(sone==one.str());
--- 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.
+
+include ../Makefile.opts
+
+APP_NAME := topic-tests
+ARDUINO_LIBS := AUnit AceCommon AceTime TinyMqtt EspMock ESP8266WiFi  ESPAsync TinyConsole
+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,82 @@
+// vim: ts=2 sw=2 expandtab
+#include <Arduino.h>
+#include <AUnit.h>
+#include <TinyMqtt.h>
+#include <map>
+#include <iostream>
+
+/**
+  * TinyMqtt / StringIndexer unit tests.
+  *
+  **/
+
+bool testTopicMatch(const char* a, const char* b, bool expected)
+{
+  Topic ta(a);
+  Topic tb(b);
+  bool match(ta.matches(tb));
+  std::cout << "  " << ta.c_str() << ' ';
+  if (match != expected)
+    std::cout << (expected ? " should match " : " should not match ");
+  else
+    std::cout << (expected ? " matches " : " unmatches ");
+  std::cout << tb.c_str() << std::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	5d07294fde	Merge branch 'main' into timeout	2023-03-23 13:46:02 +01:00
hsaturn	088071d17f	[readme] Words about retain	2023-03-23 13:44:48 +01:00
Francois BIOT	e41452edf0	[fixes] Timeout and broker to broker modifications	2023-03-23 13:42:09 +01:00
hsaturn	f8a2e35dd9	[readme] Words about retain	2023-03-22 20:37:28 +01:00
hsaturn	43dbea1f17	[test] Fix payload bug in test + moved huge paylod from network to here	2023-03-22 20:31:41 +01:00
hsaturn	02496bef73	[test] Test added for retain	2023-03-22 20:31:05 +01:00
hsaturn	e4ad27c805	[MqttClient] Added connect(IPAddress)	2023-03-22 20:29:52 +01:00
hsaturn	37fb46ec3b	[TinyMqtt.cpp] Removed obsolete comment	2023-03-22 20:29:25 +01:00
hsaturn	245e74666e	[examples] Little modification for RETAIN	2023-03-22 20:28:58 +01:00
hsaturn	294657f2ca	[bump_version] Added a commit message for bump version	2023-03-22 09:43:04 +01:00
Francois BIOT	bf84e29831	retain is coming git status!	2023-03-22 00:29:55 +01:00
Francois BIOT	0c7c830a26	Release 0.9.19	2023-03-11 18:51:08 +01:00
hsaturn	6e601228e6	Added compatibility with me-no-dev/ESPAsyncTCP@^1.2.2	2023-03-11 18:49:51 +01:00
hsaturn	46798ff0de	Fix bug with Async Tcp	2023-03-11 18:47:41 +01:00
Francois BIOT	45fedf84c9	tinymqtt-tests.ino fix bad color after underrun	2023-02-24 00:18:34 +01:00
Francois BIOT	f9c8dca1e5	tinymqtt-tests fix prompt bug	2023-02-23 23:56:22 +01:00
Francois BIOT	7e1586c0b5	platformio, make tiny-tests example compilation ok	2023-02-23 23:08:30 +01:00
hsaturn	123c5a8fa5	Release 0.9.18	2023-02-23 20:43:27 +01:00
hsaturn	21fb01848d	Release 0.9.17	2023-02-23 20:42:26 +01:00
hsaturn	66b1e71ee2	Fix depends	2023-02-23 20:36:10 +01:00
hsaturn	e5115087ea	Release 0.9.16	2023-02-23 20:15:38 +01:00
hsaturn	cc004875b5	Release 0.9.16	2023-02-23 20:12:49 +01:00
Francois BIOT	58ae2436d3	Release 0.9.15	2023-02-23 19:41:47 +01:00
Francois BIOT	cda94368a7	Change bump version script	2023-02-23 19:37:11 +01:00
Francois BIOT	0126a39327	Release 0.9.14	2023-02-23 19:36:51 +01:00
Francois BIOT	2587371457	Minor typo changes and add comments	2023-02-23 19:24:27 +01:00
hsaturn	a880a1ff2f	Minor updates	2023-02-23 19:22:40 +01:00
hsaturn	143d57db2d	Re-enabled lot of local unit tests	2023-02-22 07:40:12 +01:00
hsaturn	2a8dbd09c5	Memory deletion fixes	2023-02-20 05:24:35 +01:00
Francois BIOT	00333ed805	[TinyMqtt] Fix obsolete warning	2023-02-20 03:22:50 +01:00
hsaturn	9228408f57	[tests] Added -Wall and use TinyConsole::string	2023-02-20 02:39:43 +01:00
hsaturn	1653b2e386	[tests] Added a compilation test (based on example tiny-tests)	2023-02-20 02:28:22 +01:00
Francois BIOT	775fbc14ee	[tests] Use TinyConsole::string instead of any	2023-02-20 02:24:39 +01:00
hsaturn	c21b7b63fb	[tests] Removed warning and using namespace std	2023-02-20 02:21:33 +01:00
hsaturn	e45af112c2	Update README.md	2023-02-19 09:16:35 +01:00
hsaturn	f9c539ff6a	Added TinyConsole aunit test and dependency	2023-02-19 09:16:10 +01:00
hsaturn	7dc23d322c	TinyString moved to TinyConsole	2023-02-19 08:38:11 +01:00
Francois BIOT	4fb632ce3d	[TinyString] change size_t to be more tolerant with signed ints	2023-02-19 06:04:54 +01:00
hsaturn	c9130c7a24	[TinyString] Added size_t, added find(char)	2023-02-19 05:21:55 +01:00
hsaturn	31c51aeaff	[aunit] Use my git repo instead of bxpark's	2023-02-15 07:57:25 +01:00
hsaturn	2eeda4ecab	[makefiles] Added missing Makefile.opt	2023-02-15 05:39:17 +01:00
hsaturn	787cb77a26	String indexer std::string removed	2023-02-15 05:37:23 +01:00
hsaturn	d324a913ec	Merge pull request #59 from richievos/clearer-version-error More informative error on version mismatch	2023-02-13 09:00:39 +01:00
Richie Vos	ac1eedd72a	More informative error on version mismatch I spent a lot of time debugging my arduino, trying to figure out why my calls were all failing. Turned out to be due to the mqtt cli using v5, while this library only supports v4. By mqtt cli I mean the [hivemq one](https://hivemq.github.io/mqtt-cli/), which is the first one that shows up on google searches. Being new to mqtt this burned me for awhile, so I'm hoping this helps the next person. Both by having this PR show up if they search, and making the error more informative.	2023-02-12 21:37:17 -08:00
hsaturn	0900e799a9	Update README.md	2023-02-02 03:15:57 +01:00
hsaturn	2086c7f0e7	Added auint test to unit tests array	2023-02-02 03:14:25 +01:00
hsaturn	72382bf351	Added missing dependency to bxparks AceRoutine	2023-02-02 03:02:03 +01:00
hsaturn	3fec7b87a8	Unit tests of dependencies projects added	2023-02-02 02:21:59 +01:00
hsaturn	8641627742	Re-added flto in makefile	2023-01-15 16:04:16 +01:00
hsaturn	3b2460572b	Fix unit tests	2023-01-14 14:26:30 +01:00
hsaturn	a0435b2cfb	Release 0.9.12 unit test build upgrade	2023-01-03 04:33:47 +01:00
hsaturn	bda041417d	Release 0.9.12	2023-01-03 04:32:14 +01:00
hsaturn	baffda8a6d	MqttClient - fix local disconnect after pulish + ka	2023-01-03 04:25:26 +01:00
Francois BIOT	09e3a3e45f	Rename MqttBroker to remote_broker	2022-12-29 13:39:34 +01:00
Francois BIOT	f17ece3376	MqttClient::client renamed to tcp_client	2022-12-29 12:58:08 +01:00
hsaturn	0db07df27b	Remove useless comment	2022-12-29 12:54:58 +01:00
hsaturn	292592c3dd	Added missing Makefile for unit test of MqttClassBinder	2022-12-29 02:17:54 +01:00
Francois BIOT	1f267c135b	fix erroneous sizeof multimap comment	2022-12-29 02:15:18 +01:00
Francois BIOT	2b92833ea5	Remove spaces to end of lines	2022-12-28 21:22:19 +01:00
Francois BIOT	42fc054c94	release 0.9.11	2022-12-28 20:30:41 +01:00
hsaturn	7f12ecfd6d	Update mqtt_class_binder.ino	2022-12-28 20:29:33 +01:00
Francois BIOT	3ae1afec27	Release 0.9.10	2022-12-28 20:23:58 +01:00
Francois BIOT	9608ed9fdf	Added example for MqttClassBinder	2022-12-28 20:22:31 +01:00
hsaturn	220e904ae9	Add MqttClassBinder	2022-12-28 19:34:29 +01:00
hsaturn	49b696315c	Fix TINY_MQTT_DEBUG compilation	2022-12-28 19:30:16 +01:00
hsaturn	a9ebf31e6f	Version 0.9.9	2022-12-24 02:01:27 +01:00
hsaturn	4b4eb0b684	Fix compilation error when not in debug	2022-12-23 18:06:35 +01:00
HSaturn	18ce34c458	:xDefault client is no more empty	2022-12-17 18:36:32 +01:00
Francois BIOT	70ca3787bb	Better debugging code	2022-12-04 02:41:11 +01:00
Francois BIOT	396e3fde95	Moved MqttStreaming to TinyConsole	2022-12-04 02:30:37 +01:00
Francois BIOT	c913bc61bb	tinymqtt-test : new commands	2022-12-04 02:03:28 +01:00
Francois BIOT	7af8e46b59	simple-client typo	2022-12-04 02:00:50 +01:00
Francois BIOT	0569bc6000	[tinytest] Removed auto commands and default topic	2022-12-04 00:25:43 +01:00
Francois BIOT	708a2b41dc	tinymqtt-test enhancements	2022-12-03 23:09:20 +01:00
Francois BIOT	c4edfb6e40	fix bug in simple-broker example	2022-12-03 21:27:03 +01:00
Francois BIOT	cf724507e9	fix typo	2022-12-03 21:03:05 +01:00
Francois BIOT	744a590467	Replaced tabs by spaces	2022-12-03 20:47:02 +01:00
Francois BIOT	5a3e9bd90e	Fix reboot bugs due to TinyConsole	2022-12-03 20:34:59 +01:00
hsaturn	d8b24adef7	[MqttClient] Fix compilation warnings	2022-12-03 20:25:03 +01:00
hsaturn	4726ff293c	[MqttClient] Fix keep_alive decoding	2022-12-03 20:23:15 +01:00
hsaturn	2a4e84d827	[TinyMqtt.h] rework code	2022-12-01 08:07:25 +01:00
hsaturn	9ef47fa6a4	[MqttClient] Renamed parent to local_broker	2022-12-01 07:49:56 +01:00
hsaturn	3358340319	Fix unit tests	2022-11-30 20:52:29 +01:00
Francois BIOT	1fff9fd0e1	Use TinyConsole instead of Serial	2022-11-30 20:06:15 +01:00
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