Change bump version script

More informative error on version mismatch

.github/workflows/aunit.yml

@@ -0,0 +1,35 @@
+# See https://docs.github.com/en/actions/guides for documentation about GitHub
+# Actions.
+
+name: AUnit Tests
+
+# Run on all branches.
+on: [push]
+
+jobs:
+  build:
+
+    runs-on: ubuntu-20.04
+
+    steps:
+    - uses: actions/checkout@v2
+
+    - name: Setup
+      run: |
+        cd ..
+        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/hsaturn/AUnit
+        git clone https://github.com/bxparks/AceCommon
+        git clone https://github.com/hsaturn/EspMock
+    - name: Verify tests
+      run: |
+        # Run tests for ESP8266
+        make -C tests ESP_LIBS="ESP8266WiFi ESPAsyncTCP" tests
+        make -C tests runtests
+        make -C tests clean
+        # Run tests for ESP32
+        #make -C tests ESP_LIBS="ESP8266WiFi ESPAsyncTCP" tests
+        #make -C tests runtests
+        #make -C tests clean

.github/workflows/ci.yml

@@ -0,0 +1,18 @@
+name: "CI"
+on:
+
+jobs:
+  ci:
+    runs-on: ubuntu-20.04
+    steps:
+    - name: Checkout this repository
+      uses: actions/checkout@v2.3.4
+    - name: Cache for arduino-ci
+      uses: actions/cache@v2.1.3
+      with:
+        path: |
+          ~/.arduino15
+        key: ${{ runner.os }}-arduino
+    - name: Install nix
+      uses: cachix/install-nix-action@v12
+    - run: nix-shell -I nixpkgs=channel:nixpkgs-unstable -p arduino-ci --run "arduino-ci"

.github/workflows/superlinter.yml

@@ -0,0 +1,52 @@
+---
+#################################
+#################################
+## Super Linter GitHub Actions ##
+#################################
+#################################
+name: Lint Code Base
+
+#
+# Documentation:
+# https://docs.github.com/en/actions/learn-github-actions/workflow-syntax-for-github-actions
+#
+
+#############################
+# Start the job on all push #
+#############################
+on: push
+
+###############
+# Set the Job #
+###############
+jobs:
+  build:
+    # Name the Job
+    name: Lint Code Base
+    # Set the agent to run on
+    runs-on: ubuntu-latest
+
+    ##################
+    # Load all steps #
+    ##################
+    steps:
+      ##########################
+      # Checkout the code base #
+      ##########################
+      - name: Checkout Code
+        uses: actions/checkout@v3
+        with:
+          # Full git history is needed to get a proper
+          # list of changed files within `super-linter`
+          fetch-depth: 0
+
+      ################################
+      # Run Linter against code base #
+      ################################
+      - name: Lint Code Base
+        uses: github/super-linter/slim@v4
+        env:
+          VALIDATE_ALL_CODEBASE: false
+          # Change to 'master' if your main branch differs
+          DEFAULT_BRANCH: main
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.gitignore

@@ -1 +0,0 @@
-*~

README.md

@@ -1,2 +1,89 @@
 # TinyMqtt
-ESP 8266 Small footprint Mqtt Broker and Client
+
+[![Release](https://img.shields.io/github/v/release/hsaturn/TinyMqtt)](https://github.com/hsaturn/TinyMqtt/releases)
+[![AUnit Tests](https://github.com/hsaturn/TinyMqtt/actions/workflows/aunit.yml/badge.svg)](https://github.com/hsaturn/TinyMqtt/actions/workflows/aunit.yml)
+[![Issues](https://img.shields.io/github/issues/hsaturn/TinyMqtt)](https://github.com/hsaturn/TinyMqtt/issues)
+[![Esp8266](https://img.shields.io/badge/platform-ESP8266-green)](https://www.espressif.com/en/products/socs/esp8266)
+[![Esp32](https://img.shields.io/badge/platform-ESP32-green)](https://www.espressif.com/en/products/socs/esp32)
+[![Gpl 3.0](https://img.shields.io/github/license/hsaturn/TinyMqtt)](https://www.gnu.org/licenses/gpl-3.0.fr.html)
+[![Mqtt 3.1.1](https://img.shields.io/badge/Mqtt-%203.1.1-yellow)](https://docs.oasis-open.org/mqtt/mqtt/v3.1.1/errata01/os/mqtt-v3.1.1-errata01-os-complete.html#_Toc442180822)
+
+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
+
+- 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
+
+* install [TinyMqtt library](https://github.com/hsaturn/TinyMqtt)
+  (you can use the Arduino library manager and search for TinyMqtt)
+* modify <libraries/TinyMqtt/src/my_credentials.h> (wifi setup)
+
+## Examples
+
+| Example             | Description                                |
+| ------------------- | ------------------------------------------ |
+| [client-with-wifi](https://github.com/hsaturn/TinyMqtt/tree/main/examples/client-with-wifi/client-with-wifi.ino) | standalone example                         |
+| [client-without-wifi](https://github.com/hsaturn/TinyMqtt/tree/main/examples/client-without-wifi/client-without-wifi.ino) | standalone example                         |
+| [simple-client](https://github.com/hsaturn/TinyMqtt/tree/main/examples/simple-client/simple-client.ino)       | Connect the ESP to an external Mqtt broker |
+| [simple-broker](https://github.com/hsaturn/TinyMqtt/tree/main/examples/simple-broker/simple-broker.ino)       | Simple Mqtt broker with your ESP           |
+| [tinymqtt-test](https://github.com/hsaturn/TinyMqtt/tree/main/examples/tinymqtt-test/tinymqtt-test.ino)       | Complex console example                    |
+
+- tinymqtt-test : This is a complex sketch with a terminal console
+  that allows to add clients publish, connect etc with interpreted commands.
+
+## Standalone mode (zeroconf)
+-> The zeroconf mode is not yet implemented
+zeroconf clients to connect to broker on local network.
+
+In Zeroconf mode, each ESP is a a broker and scans the local network.
+After a while one ESP naturally becomes a 'master' and all ESP are connected together.
+No problem if the master dies, a new master will be choosen soon.
+
+## TODO List
+* ~~Use [Async library](https://github.com/me-no-dev/ESPAsyncTCP)~~
+* Implement zeroconf mode (needs async)
+* Add a max_clients in MqttBroker. Used with zeroconf, there will be
+no need for having tons of clients (also RAM is the problem with many clients)
+* Why not a 'global' TinyMqtt::loop() instead of having to call loop for all broker/clients instances
+* Test what is the real max number of clients for broker. As far as I saw, 1k is needed per client which would make more than 30 clients critical.
+* ~~MqttClient auto re-subscribe (::resubscribe works bad on broker.emqx.io)~~
+* MqttClient auto reconnection
+* MqttClient user/password
+* ~~Wildcards (I may implement only # as I'm not interrested by a clever and cpu consuming matching)~~
+* I suspect that MqttClient::parent could be removed and replaced with a simple boolean
+  (this'll need to rewrite a few functions)
+
+## License
+Gnu GPL 3.0, see [LICENSE](https://github.com/hsaturn/TinyMqtt/blob/main/LICENSE).

bump_version.sh

@@ -0,0 +1,30 @@
+#!/bin/bash
+current_version=$(git describe --tags --abbrev=0)
+if [ "$1" == "" ]; then
+	echo
+	echo "Syntax: $0 {new_version}"
+	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
+			sed -i "s/$current_version/$1/" library.json
+			git tag $1
+			git add library.properties
+			git add library.json
+			git commit -m "Release $1"
+			git push
+			git push --tags
+		else
+			echo "Current version does not match library.property version, aborting"
+		fi
+	fi
+fi

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()));
+    }
+  }
+}

examples/client-with-wifi/client-with-wifi.ino

@@ -0,0 +1,104 @@
+#include <TinyMqtt.h>   // https://github.com/hsaturn/TinyMqtt
+
+/**
+  * 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
+  *
+  * cons - Takes more memory
+  *      - a bit hard to understand
+  *
+  */
+
+const char *ssid     = "";
+const char *password = "";
+
+std::string topic="sensor/temperature";
+
+MqttBroker broker(1883);
+
+MqttClient mqtt_a(&broker);
+MqttClient mqtt_b(&broker);
+
+void onPublishA(const MqttClient* /* source */, const Topic& topic, const char* payload, size_t /* length */)
+{ Serial << "--> client A received " << topic.c_str() << ", " << payload << endl; }
+
+void onPublishB(const MqttClient* /* source */, const Topic& topic, const char* payload, size_t /* length */)
+{ Serial << "--> client B Received " << topic.c_str() << ", " << payload << endl; }
+
+void setup()
+{
+  Serial.begin(115200);
+  delay(500);
+  Serial << "Clients with wifi " << endl;
+
+	if (strlen(ssid)==0)
+		Serial << "****** PLEASE EDIT THE EXAMPLE AND MODIFY ssid/password *************" << endl;
+
+  WiFi.mode(WIFI_STA);
+  WiFi.begin(ssid, password);
+
+  while (WiFi.status() != WL_CONNECTED) {   Serial << '-'; delay(500); }
+
+  Serial << "Connected to " << ssid << "IP address: " << WiFi.localIP() << endl;
+
+  broker.begin();
+
+  mqtt_a.setCallback(onPublishA);
+  mqtt_a.subscribe(topic);
+
+  mqtt_b.setCallback(onPublishB);
+  mqtt_b.subscribe(topic);
+}
+
+void loop()
+{
+  broker.loop();  // Don't forget to add loop for every broker and clients
+
+  mqtt_a.loop();
+  mqtt_b.loop();
+
+  // ============= client A publish ================
+  static const int intervalA = 5000;  // publishes every 5s (please avoid usage of delay())
+  static uint32_t timerA = millis() + intervalA;
+
+  if (millis() > timerA)
+  {
+    Serial << "A is publishing " << topic.c_str() << endl;
+    timerA += intervalA;
+    mqtt_a.publish(topic, " sent by A");
+  }
+
+  // ============= client B publish ================
+  static const int intervalB = 7000;	// will send topic each 7s
+  static uint32_t timerB = millis() + intervalB;
+
+  if (millis() > timerB)
+  {
+		static int temperature;
+    Serial << "B is publishing " << topic.c_str() << endl;
+    timerB += intervalB;
+    mqtt_b.publish(topic, " sent by B: "+std::string(String(16+temperature++%6).c_str()));
+  }
+}

examples/client-without-wifi/client-without-wifi.ino

@@ -0,0 +1,81 @@
+#include <TinyMqtt.h>   // https://github.com/hsaturn/TinyMqtt
+
+/** TinyMQTT allows a disconnected mode:
+  *
+  *  +-----------------------------+
+  *  | ESP                         |
+  *  |                 +--------+  |
+  *  |       +-------->| broker |  |
+  *  |       |         +--------+  |
+  *  |       |             ^       |
+  *  |       |             |       |
+  *  |       v             v       |
+  *  | +----------+  +----------+  |
+  *  | | internal |  | internal |  |
+  *  | | client   |  | client   |  |
+  *  | +----------+  +----------+  |
+  *  |                             |
+  *  +-----------------------------+
+  *
+  *  In this example, local clients A and B are talking together, no need to be connected.
+  *
+  *  A single ESP can use this to be able to comunicate with itself with the power
+  *  of MQTT, and once connected still continue to work with others.
+  *
+  *  The broker may still be conected if wifi is on.
+  *
+  */
+
+std::string topic="sensor/temperature";
+
+MqttBroker broker(1883);
+MqttClient mqtt_a(&broker);
+MqttClient mqtt_b(&broker);
+
+void onPublishA(const MqttClient* /* srce */, const Topic& topic, const char* payload, size_t /* length */)
+{ Serial << "--> Client A received msg on topic " << topic.c_str() << ", " << payload << endl; }
+
+void onPublishB(const MqttClient* /* srce */, const Topic& topic, const char* payload, size_t /* length */)
+{ Serial << "--> Client B received msg on topic " << topic.c_str() << ", " << payload << endl; }
+
+void setup()
+{
+  Serial.begin(115200);
+  delay(500);
+  Serial << "init" << endl;
+
+  mqtt_a.setCallback(onPublishA);
+  mqtt_a.subscribe(topic);
+
+  mqtt_b.setCallback(onPublishB);
+  mqtt_b.subscribe(topic);
+}
+
+void loop()
+{
+	broker.loop();	// Don't forget to call loop() for all brokers and clients
+  mqtt_a.loop();
+  mqtt_b.loop();
+
+  // ============= client A publish ================
+	static const int intervalA = 5000;
+	static uint32_t timerA = millis() + intervalA;
+	
+	if (millis() > timerA)
+	{
+		Serial << "A is publishing " << topic.c_str() << endl;
+		timerA += intervalA;
+		mqtt_a.publish(topic, "sent by A");
+	}
+
+  // ============= client B publish ================
+	static const int intervalB = 3000;	// will send topic each 5000 ms
+	static uint32_t timerB = millis() + intervalB;
+	
+	if (millis() > timerB)
+	{
+		Serial << "B is publishing " << topic.c_str() << endl;
+		timerB += intervalB;
+		mqtt_b.publish(topic, "sent by B");
+	}
+}

examples/simple-broker/simple-broker.ino

@@ -1,29 +1,44 @@
-#include <ESP8266WiFi.h>
 #include "TinyMqtt.h"   // https://github.com/hsaturn/TinyMqtt
-#include <Streaming.h>  // https://github.com/janelia-arduino/Streaming
-
-const char *ssid = ;      // Put here your wifi SSID ("ssid")
-const char *password = ;  // Put here your Wifi password ("pwd")
 
 #define PORT 1883
 MqttBroker broker(PORT);
 
-void setup() 
+/** Basic Mqtt Broker
+  *
+  *  +-----------------------------+
+  *  | ESP                         |
+  *  |       +--------+            |
+  *  |       | broker |            | 1883 <--- External client/s
+  *  |       +--------+            |
+  *  |                             |
+  *  +-----------------------------+
+  *
+  *  Your ESP will become a MqttBroker.
+	*  You can test it with any client such as mqtt-spy for example
+	*
+  */
+
+const char* ssid = "";
+const char* password = "";
+
+void setup()
 {
   Serial.begin(115200);
 
+	if (strlen(ssid)==0)
+		Console << TinyConsole::red << "****** PLEASE MODIFY ssid/password *************" << endl;
+
   WiFi.mode(WIFI_STA);
   WiFi.begin(ssid, password);
- 
+
-  while (WiFi.status() != WL_CONNECTED) {   
+  while (WiFi.status() != WL_CONNECTED) {
-    delay(500);
     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()

examples/simple-client/simple-client.ino

@@ -0,0 +1,88 @@
+#include "TinyMqtt.h"    // https://github.com/hsaturn/TinyMqtt
+#include "TinyStreaming.h" // https://github.com/hsaturn/TinyConsole
+
+/** Simple Client (The simplest configuration)
+  *
+  *
+  *                   +--------+
+  *           +------>| broker |<--- <  Other client
+  *           |       +--------+
+  *           |
+  *   +-----------------+
+  *   | ESP   |         |
+  *   | +----------+    |
+  *   | | internal |    |
+  *   | | client   |    |
+  *   | +----------+    |
+  *   |                 |
+  *   +-----------------+
+  *
+	* 1 - change the ssid/password
+	* 2 - change BROKER values (or keep emqx.io test broker)
+	* 3 - you can use mqtt-spy to connect to the same broker and
+	*     see the sensor/temperature updated by the client.
+	*
+	* pro  - small memory footprint (both ram and flash)
+	*      - very simple to setup and use
+	*
+	* cons - cannot work without wifi connection
+  *      - stop working if broker is down
+	*      - local publishes takes more time (because they go outside)
+	*/
+
+const char* BROKER = "broker.emqx.io";
+const uint16_t BROKER_PORT = 1883;
+
+const char* ssid = "";
+const char* password = "";
+
+static float temp=19;
+static MqttClient client;
+
+void setup()
+{
+  Serial.begin(115200);
+	delay(500);
+
+	Serial << "Simple clients with wifi " << endl;
+	if (strlen(ssid)==0)
+		Serial << "****** PLEASE MODIFY ssid/password *************" << endl;
+
+  WiFi.mode(WIFI_STA);
+  WiFi.begin(ssid, password);
+
+  while (WiFi.status() != WL_CONNECTED)
+	{ delay(500); Serial << '.'; }
+
+  Serial << "Connected to " << ssid << "IP address: " << WiFi.localIP() << endl;
+
+	client.connect(BROKER, BROKER_PORT);
+}
+
+void loop()
+{
+	client.loop();	// Don't forget to call loop() for each broker and client
+
+	// delay(1000);		please avoid usage of delay (see below how this done using next_send and millis())
+	static auto next_send = millis();
+	
+	if (millis() > next_send)
+	{
+		next_send += 1000;
+
+		if (not client.connected())
+		{
+			Serial << millis() << ": Not connected to broker" << endl;
+			return;
+		}
+
+		auto rnd=random(100);
+
+		if (rnd > 66) temp += 0.1;
+		else if (rnd < 33) temp -= 0.1;
+
+		Serial << "--> Publishing a new sensor/temperature value: " << temp << endl;
+
+		client.publish("sensor/temperature", String(temp));
+	}
+}

examples/tinymqtt-test/commands.txt

@@ -0,0 +1,39 @@
+// vim: ts=40
+Exemple of commands that can be sent via the serial monitor to tinymqtt-test
+----------------------------------------------------------------------------
+Commands can usually be abbreviated to their first letters.
+ex: cl for client, a / a.con / a.sub / a.p for publish.
+--------
+
+set name value	set variable name to value (later replaced)
+set name	if no value, then var is erased
+set	view all vars
+reserved keywords are forbidden
+
+
+client a	starts a client (not connected no internal broker)
+a.connect [server][port][alive]	connects the client, default port=1883
+a.publish topic [payload]	send a topic with a payload
+a.subscribe topic	subscribes to a topic
+delete a	destroy the client
+
+* note, if 'server' is a number, then it replaces the end of the local ip.
+i.e. if local ip is 192.168.1.10, connect 2.35 becomes 192.168.2.35
+
+--------
+example:
+--------
+
+client c
+c.connect broker.emqx.io
+set topic sensor/temperature
+
+c.subscribe topic
+c.publish topic 15
+c.publish topic 20
+
+macro exansion example
+----------------------
+
+set temp publish sensor/temperature
+c.temp 20	-> c.publish sensor/temperature 20

examples/tinymqtt-test/tinymqtt-test.ino

@@ -0,0 +1,861 @@
+// vim: ts=2 sw=2 expandtab smartindent
+#include <TinyConsole.h>
+#include <TinyMqtt.h>       // https://github.com/hsaturn/TinyMqtt
+#include <TinyStreaming.h>
+#if defined(ESP8266)
+  #include <ESP8266mDNS.h>
+#elif defined(ESP32)
+  #include <WiFi.h>
+  #include <ESPmDNS.h>
+#else
+  #error Unsupported platform
+#endif
+
+#include <sstream>
+#include <string>
+#include <map>
+
+using string = TinyString;
+
+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;
+
+void setup()
+{
+  WiFi.persistent(false); // https://github.com/esp8266/Arduino/issues/1054
+  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;
+  if (!MDNS.begin(name))
+    Console << "  error, not available." << endl;
+  else
+    Console << " ok." << endl;
+
+
+  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::map<string, string> vars;
+
+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();
+  }
+}
+
+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);
+
+}
+
+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 onCommand(const string& command)
+{
+  Console << endl;
+  string cmd=command;
+  if (cmd.substr(0,3)!="set") replaceVars(cmd);
+  eval(cmd);
+  Console << endl;
+  Console.prompt();
+}
+
+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();
+}

keywords.txt

@@ -3,16 +3,29 @@
 #######################################
 
 #######################################
-# Datatypes (KEYWORD1)
+# Datatypes and functions
 #######################################
 
-MqttBroker	KEYWORD1
+TinyMqtt    KEYWORD1
+
+MqttBroker  KEYWORD1
+connect		  KEYWORD2
+clientsCount KEYWORD2
+begin				KEYWORD2
+loop				KEYWORD2
+port				KEYWORD2
+
 MqttClient  KEYWORD1
+connect		  KEYWORD2
+connected	  KEYWORD2
+publish     KEYWORD2
+setCallback	KEYWORD2
+subscribe	  KEYWORD2
+unsubscribe	KEYWORD2
 
-#######################################
+Topic				KEYWORD1
-# Methods and Functions (KEYWORD2)
+matches			KEYWORD2
-#######################################
+c_str				KEYWORD2
-
 
 #######################################
 # Constants (LITERAL1)

library.json

@@ -1,18 +0,0 @@
-{
-    "name": "TinyMqtt",
-    "keywords": "ethernet, mqtt, m2m, iot",
-    "description": "MQTT is a lightweight messaging protocol ideal for small devices. This library allows you to send and receive MQTT messages. It does support MQTT 3.1.1 without any QOS.",
-    "repository": {
-        "type": "git",
-        "url": "https://github.com/hsaturn/TinyMqtt.git"
-    },
-    "version": "0.1",
-    "exclude": "",
-    "examples": "examples/*/*.ino",
-    "frameworks": "arduino",
-    "platforms": [
-        "atmelavr",
-        "espressif8266",
-        "espressif32"
-    ]
-}

library.properties

@@ -1,9 +1,11 @@
 name=TinyMqtt
-version=0.1
+version=0.9.14
-author=HSaturn <hsaturn@gmail.com>
+author=Francois BIOT, HSaturn, <hsaturn@gmail.com>
-maintainer=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 you to send and receive MQTT messages. It does support MQTT 3.1.1 without any QOS.
+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=TinyConsole
+includes=TinyMqtt.h

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;
+

src/StringIndexer.cpp

@@ -1,3 +1,4 @@
 #include "StringIndexer.h"
 
-std::map<StringIndexer::index_t, StringIndexer::StringCounter> StringIndexer::strings;
+StringIndexer::Strings StringIndexer::strings;
+

src/StringIndexer.h

@@ -1,9 +1,13 @@
+// vim: ts=2 sw=2 expandtab
 #pragma once
+#include <assert.h>
 #include <map>
+#include <unordered_map>
+#include "TinyConsole.h"
 #include <string>
 #include <string.h>
-#include <Streaming.h>
+
-#include <ESP8266WiFi.h>
+using string = TinyConsole::string;
 
 /***
  * Allows to store up to 255 different strings with one byte class
@@ -11,102 +15,128 @@
  */
 class StringIndexer
 {
-	class StringCounter
+  private:
-	{
-		std::string str;
-		uint8_t used=0;
-		friend class StringIndexer;
-	};
-	public:
-		using index_t=uint8_t;
 
-		static const index_t strToIndex(const char* str, uint8_t len)
+  class StringCounter
-		{
+  {
-			for(auto it=strings.begin(); it!=strings.end(); it++)
+    string str;
-			{
+    uint8_t used=0;
-				if (strncmp(it->second.str.c_str(), str, len)==0)
+    friend class StringIndexer;
-				{
-					it->second.used++;
-					return it->first;
-				}
-			}
-			for(index_t index=0; index<255; index++)
-			{
-				if (strings.find(index)==strings.end())
-				{
-					strings[index].str = std::string(str, len);
-					strings[index].used++;
-					Serial << "Creating index " << index << " for (" << strings[index].str.c_str() << ") len=" << len << endl;
-					return index;
-				}
-			}
-			return 0;	// TODO out of indexes
-		}
 
-		static const std::string& str(const index_t& index)
+    #if EPOXY_DUINO
-		{
+    public:
-			static std::string dummy;
+    // Workaround to avoid coredump in Indexer::release
-			const auto& it=strings.find(index);
+    // when destroying a Topic after the deletion of
-			if (it == strings.end()) return dummy;
+    // StringIndexer::strings map (which can occurs only with AUnit,
-			return it->second.str;
+    // never in the ESP itself, because ESP never ends)
-		}
+    // (I hate static vars)
+    ~StringCounter() { used=255; }
+    #endif
+  };
+  public:
+    using index_t = uint8_t;
 
-		static void use(const index_t& index)
+   static const string& str(const index_t& index)
-		{
+   {
-			auto it=strings.find(index);
+     static string dummy;
-			if (it != strings.end()) it->second.used++;
+     const auto& it=strings.find(index);
-		}
+     if (it == strings.end()) return dummy;
+     return it->second.str;
+   }
 
-		static void release(const index_t& index)
+    static void use(const index_t& index)
-		{
+    {
-			auto it=strings.find(index);
+      auto it=strings.find(index);
-			if (it != strings.end())
+      if (it != strings.end()) it->second.used++;
-			{
+    }
-				it->second.used--;
-				if (it->second.used == 0)
-				{
-					strings.erase(it);
-					Serial << "Removing string(" << it->second.str.c_str() << ") size=" << strings.size() << endl;
-				}
-			}
-		}
 
-	private:
+    static void release(const index_t& index)
-		static std::map<index_t, StringCounter> strings;
+    {
+      auto it=strings.find(index);
+      if (it != strings.end())
+      {
+        it->second.used--;
+        if (it->second.used == 0)
+        {
+          strings.erase(it);
+          // Serial << "Removing string(" << it->second.str.c_str() << ") size=" << strings.size() << endl;
+        }
+      }
+    }
+
+    static uint16_t count() { return strings.size(); }
+
+  private:
+    friend class IndexedString;
+
+    // increment use of str or create a new index
+    static index_t strToIndex(const char* str, uint8_t len)
+    {
+      for(auto it=strings.begin(); it!=strings.end(); it++)
+      {
+        if (it->second.str.length() == len && strcmp(it->second.str.c_str(), str)==0)
+        {
+          it->second.used++;
+          return it->first;
+        }
+      }
+      for(index_t index=1; index; index++)
+      {
+        if (strings.find(index)==strings.end())
+        {
+          strings[index].str = 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
 {
-	public:
+  public:
-		IndexedString(const IndexedString& source)
+    IndexedString(const IndexedString& source)
-		{
+    {
-			StringIndexer::use(source.index);
+      StringIndexer::use(source.index);
-			index = source.index;
+      index = source.index;
-		}
+    }
 
-		IndexedString(const char* str, uint8_t len)
+    IndexedString(const char* str, uint8_t len)
-		{
+    {
-			index=StringIndexer::strToIndex(str, len);
+      index=StringIndexer::strToIndex(str, len);
-		}
+    }
 
-		~IndexedString() { StringIndexer::release(index); }
+    IndexedString(const string& str) : IndexedString(str.c_str(), str.length()) {};
 
-		IndexedString& operator=(const IndexedString& source)
+    ~IndexedString() { StringIndexer::release(index); }
-		{
-			StringIndexer::use(source.index);
-			index = source.index;
-			return *this;
-		}
 
-		friend bool operator<(const IndexedString& i1, const IndexedString& i2)
+    IndexedString& operator=(const IndexedString& source)
-		{
+    {
-			return i1.index < i2.index;
+      StringIndexer::use(source.index);
-		}
+      index = source.index;
+      return *this;
+    }
 
-		const std::string& str() const { return StringIndexer::str(index); }
+    friend bool operator<(const IndexedString& i1, const IndexedString& i2)
+    {
+      return i1.index < i2.index;
+    }
 
-		const StringIndexer::index_t getIndex() const { return index; }
+    friend bool operator==(const IndexedString& i1, const IndexedString& i2)
+    {
+      return i1.index == i2.index;
+    }
 
-	private:
+    const string& str() const { return StringIndexer::str(index); }
-		StringIndexer::index_t index;
+
+    const StringIndexer::index_t& getIndex() const { return index; }
+
+  private:
+    StringIndexer::index_t index;
 };

src/TinyMqtt.h

@@ -1,160 +1,379 @@
-#include <ESP8266WiFi.h>
+// vim: ts=2 sw=2 expandtab
+#pragma once
+
+#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 TINY_MQTT_ASYNC
+    #include <ESPAsyncTCP.h>
+  #else
+    #include <ESP8266WiFi.h>
+  #endif
+#elif defined(ESP32)
+  #include <WiFi.h>
+  #ifdef TINY_MQTT_ASYNC
+    #include <AsyncTCP.h> // https://github.com/me-no-dev/AsyncTCP
+  #endif
+#endif
+#ifdef EPOXY_DUINO
+  #define dbg_ptr uint64_t
+#else
+  #define dbg_ptr uint32_t
+#endif
+
+#ifdef WIO_TERMINAL
+  // Uncommon board handling
+  // If you have a problem with this line, just remove it.
+  // Note: https://github.com/hsaturn/TinyMqtt/issues/41
+  #include <rpcWiFi.h>
+#endif
+
 #include <vector>
 #include <set>
 #include <string>
 #include "StringIndexer.h"
 
-#define MaxBufferLength 255
+#define TINY_MQTT_DEFAULT_CLIENT_ID "Tiny"
+
+#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 TINY_MQTT_ASYNC
+  using TcpClient = AsyncClient;
+  using TcpServer = AsyncServer;
+#else
+  using TcpClient = WiFiClient;
+  using TcpServer = WiFiServer;
+#endif
+
+enum __attribute__((packed)) MqttError
+{
+  MqttOk = 0,
+  MqttNowhereToSend=1,
+  MqttInvalidMessage=2,
+};
+
+using string = TinyConsole::string;
 
 class Topic : public IndexedString
 {
-	public:
+  public:
-		Topic(const char* s, uint8_t len) : IndexedString(s,len){}
+    Topic(const string& m) : IndexedString(m){}
-		Topic(const char* s) : Topic(s, strlen(s)) {}
+    Topic(const char* s, uint8_t len) : IndexedString(s,len){}
+    Topic(const char* s) : Topic(s, strlen(s)) {}
+    // Topic(const string s) : Topic(s.c_str(), s.length()){};
 
-		bool matches(const Topic&) const;
+    const char* c_str() const { return str().c_str(); }
+
+    bool matches(const Topic&) const;
 };
 
-class MqttCnx;
+class MqttClient;
 class MqttMessage
 {
-	public:
+  const uint16_t MaxBufferLength = 4096;  //hard limit: 16k due to size decoding
-		enum Type
+  public:
-		{
+    enum __attribute__((packed)) Type
-			Unknown   =    0,
+    {
-			Connect   = 0x10,
+      Unknown     =    0,
-			Connack   = 0x20,
+      Connect     = 0x10,
-			Publish   = 0x30,
+      ConnAck     = 0x20,
-			PubAck    = 0x40,
+      Publish     = 0x30,
-			Subscribe = 0x80,
+      PubAck      = 0x40,
-			PingReq   = 0xC0,
+      Subscribe   = 0x80,
-			PingResp  = 0xD0,
+      SubAck      = 0x90,
-		};
+      UnSubscribe = 0xA0,
-		enum State
+      UnSuback    = 0xB0,
-		{
+      PingReq     = 0xC0,
-			FixedHeader=0,
+      PingResp    = 0xD0,
-			Length=1,
+      Disconnect  = 0xE0
-			VariableHeader=2,
+    };
-			PayLoad=3,
-			Complete=4,
-			Error=5,
-			Create=6
-		};
 
-		MqttMessage() { reset(); }
+    enum __attribute__((packed)) State
-		MqttMessage(Type t) { create(t); }
+    {
-		void incoming(char byte);
+      FixedHeader=0,
-		void add(char byte) { incoming(byte); }
+      Length=1,
-		char* getVHeader() const { return vheader; }
+      VariableHeader=2,
-		char* end() const { return curr; }
+      PayLoad=3,
-		uint16_t length() const { return curr-buffer; }
+      Complete=4,
+      Error=5,
+      Create=6
+    };
 
-		void reset();
+    static inline uint32_t getSize(const char* buffer)
+    {
+      const unsigned char* bun = (const unsigned char*)buffer;
+      return (*bun << 8) | bun[1]; }
 
-		// buff is MSB/LSB/STRING
+    MqttMessage() { reset(); }
-		// output buff+=2, len=length(str)
+    MqttMessage(Type t, uint8_t bits_d3_d0=0) { create(t); buffer[0] |= bits_d3_d0; }
-		void getString(char* &buff, uint16_t& len);
+    void incoming(char byte);
+    void add(char byte) { incoming(byte); }
+    void add(const char* p, size_t len, bool addLength=true );
+    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]; }
+    void complete() { encodeLength(); }
 
+    void reset();
 
-		Type type() const
+    // buff is MSB/LSB/STRING
-		{
+    // output buff+=2, len=length(str)
-			return state == Complete ? static_cast<Type>(buffer[0]) : Unknown;
+    static void getString(const char* &buff, uint16_t& len);
-		}
 
-		void create(Type type)
+    Type type() const
-		{
+    {
-			buffer[0]=type;
+      return state == Complete ? static_cast<Type>(buffer[0] & 0xF0) : Unknown;
-			curr=buffer+2;
+    }
-			vheader=curr;
-			size=0;
-			state=Create;
-		}
-		void sendTo(MqttCnx*);
-		void hexdump(const char* prefix=nullptr) const;
 
-	private:
+    uint8_t flags() const { return static_cast<uint8_t>(buffer[0] & 0x0F); }
-		void encodeLength(char* msb, int length);
 
-	  char buffer[256];	// TODO 256 ?
+    void create(Type type)
-		char* vheader;
+    {
-		char* curr;
+      buffer=(decltype(buffer)::value_type)type;
-		uint16_t size;	// bytes left to receive
+      buffer+='\0';    // reserved for msg length byte 1/2
-		State state;
+      buffer+='\0';    // reserved for msg length byte 2/2 (fixed)
+      vheader=3;      // Should never change
+      size=0;
+      state=Create;
+    }
+    MqttError sendTo(MqttClient*);
+    void hexdump(const char* prefix=nullptr) const;
+
+  private:
+    void encodeLength();
+
+    string buffer;
+    uint8_t vheader;
+    uint16_t size;  // bytes left to receive
+    State state;
 };
 
 class MqttBroker;
-class MqttCnx
-{
-	enum Flags
-	{
-		FlagUserName = 128,
-		FlagPassword = 64,
-		FlagWillRetain = 32,	// unsupported
-		FlagWillQos = 16 | 8, // unsupported
-		FlagWill = 4,			// unsupported
-		FlagCleanSession = 2,	// unsupported
-		FlagReserved = 1
-	};
-	public:
-		MqttCnx(MqttBroker* parent, WiFiClient& client);
-
-		~MqttCnx();
-
-		bool connected() { return client && client->connected(); }
-		void write(const char* buf, size_t length)
-		{ if (client) client->write(buf, length); }
-
-		const std::string& id() const { return clientId; }
-
-		void loop();
-		void close();
-		void publish(const Topic& topic, MqttMessage& msg);
-
-	private:
-		void clientAlive();
-		void processMessage();
-
-		char flags;
-		uint32_t keep_alive;
-		uint32_t alive;
-		bool mqtt_connected;
-		WiFiClient* client;
-		MqttMessage message;
-		MqttBroker* parent;
-		std::set<Topic>	subscriptions;
-		std::string clientId;
-};
-
 class MqttClient
 {
-	public:
+  enum __attribute__((packed)) Flags
-		MqttClient(IPAddress broker) : broker_ip(broker) {}
+  {
+    FlagUserName = 128,
+    FlagPassword = 64,
+    FlagWillRetain = 32,   // unsupported
+    FlagWillQos = 16 | 8,  // unsupported
+    FlagWill = 4,          // unsupported
+    FlagCleanSession = 2,  // unsupported
+    FlagReserved = 1
+  };
 
-	protected:
+  enum __attribute__((packed)) CltFlags
-		IPAddress broker_ip;
+  {
+    CltFlagNone = 0,
+    CltFlagConnected = 1,
+    CltFlagToDelete = 2
+  };
+  public:
+
+    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 string& id = TINY_MQTT_DEFAULT_CLIENT_ID);
+    MqttClient(const string& id) : MqttClient(nullptr, id){}
+
+    ~MqttClient();
+
+    void connect(MqttBroker* local_broker);
+    void connect(string broker, uint16_t port, uint16_t keep_alive = 10);
+
+    // TODO it seems that connected returns true in tcp mode even if
+    // no negociation occurred
+    bool connected()
+    {
+      return (local_broker!=nullptr and tcp_client==nullptr)
+           or (tcp_client and tcp_client->connected());
+    }
+
+    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();
+    void close(bool bSendDisconnect=true);
+    void setCallback(CallBack fun)
+    {
+      callback=fun;
+      #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 string& s) { return publish(t,s.c_str(),s.length());}
+    MqttError publish(const Topic& t) { return publish(t, nullptr, 0);};
+
+    MqttError subscribe(Topic topic, uint8_t qos=0);
+    MqttError unsubscribe(Topic topic);
+    bool isSubscribedTo(const Topic& topic) const;
+
+    // connected to local broker
+    // TODO seems to be useless
+    bool isLocal() const { return tcp_client == nullptr; }
+
+    void dump(string indent="")
+    {
+      (void)indent;
+      #if TINY_MQTT_DEBUG
+        uint32_t ms=millis();
+        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;
+          Console << " [";
+          for(auto s: subscriptions)
+          {
+            if (c) Console << ", ";
+            Console << s.str().c_str();
+            c=true;
+          }
+          Console << ']';
+        }
+        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 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* 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);
+
+    uint8_t cltFlags = CltFlagNone;
+    char mqtt_flags;
+    uint32_t keep_alive = 30;
+    uint32_t alive;
+    MqttMessage message;
+
+    // connection to local broker, or link to the parent
+    // when MqttBroker uses MqttClient for each external connexion
+    MqttBroker* local_broker=nullptr;
+
+    TcpClient* tcp_client=nullptr;    // connection to remote broker
+    std::set<Topic>  subscriptions;
+    string clientId;
+    CallBack callback = nullptr;
 };
 
 class MqttBroker
 {
-	public:
+  enum __attribute__((packed)) State
-		MqttBroker(uint16_t port);
+  {
+    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();
 
-		void begin() { server.begin(); }
+    void begin() { server->begin(); }
-		void loop();
+    void loop();
 
-		bool checkUser(const char* user, uint8_t len) const
+    /** Connect the broker to a parent broker */
-		{ return compareString(auth_user, user, len); }
+    void connect(const string& host, uint16_t port=1883);
+    /** returns true if connected to another broker */
+    bool connected() const { return state == Connected; }
 
-		bool checkPassword(const char* password, uint8_t len) const
+    size_t clientsCount() const { return clients.size(); }
-		{ return compareString(auth_password, password, len); }
 
-		void publish(const Topic& topic, MqttMessage& msg);
+    void dump(string indent="")
+    {
+      for(auto client: clients)
+        client->dump(indent);
+    }
 
-	private:
+    const std::vector<MqttClient*>  getClients() const { return clients; }
-		bool compareString(const char* good, const char* str, uint8_t str_len) const;
-		std::vector<MqttCnx*>	clients;
-		WiFiServer server;
 
-		const char* auth_user = "guest";
+  private:
-		const char* auth_password = "guest";
+    friend class MqttClient;
+
+    static void onClient(void*, TcpClient*);
+    bool checkUser(const char* user, uint8_t len) const
+    { return compareString(auth_user, user, len); }
+
+    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) const;
+
+    MqttError subscribe(const Topic& topic, uint8_t qos);
+
+    // 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;
+
+  private:
+    TcpServer* server = nullptr;
+
+    const char* auth_user = "guest";
+    const char* auth_password = "guest";
+    MqttClient* remote_broker = nullptr;
+
+    State state = Disconnected;
 };

tests/Makefile

@@ -0,0 +1,40 @@
+SUB=
+
+all:runtests
+
+tests:
+	@set -e; \
+	for i in $(SUB)*-tests/Makefile; do \
+		echo '==== Making:' $$(dirname $$i); \
+		$(MAKE) -C $$(dirname $$i) -j; \
+	done
+	$(MAKE) -C compile-test
+
+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 $(SUB)*-tests/Makefile; do \
+		echo '==== Cleaning:' $$(dirname $$i); \
+		$(MAKE) -C $$(dirname $$i) clean; \
+	done

tests/Makefile.opts

@@ -0,0 +1,11 @@
+
+# GCC
+# CXXFLAGS = -Wextra -Wall -std=gnu++11 -fno-exceptions -fno-threadsafe-statics
+EXTRA_CXXFLAGS=-g3 -O0
+
+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++

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

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();
+}

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

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();
+}

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

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();
+}

tests/howto

@@ -0,0 +1,7 @@
+cd TinyMqtt/tests/../..
+git clone https://github.com/hsaturn/EspMock.git
+git clone https://github.com/bxparks/AUnit.git
+git clone https://github.com/bxparks/EpoxyDuino.git
+cd TinyMqtt/tests
+make
+make runtests

tests/length-tests.todo/Makefile

@@ -0,0 +1,10 @@
+# See https://github.com/bxparks/EpoxyDuino for documentation about this
+# Makefile to compile and run Arduino programs natively on Linux or MacOS.
+
+EXTRA_CXXFLAGS=-g3 -O0
+
+APP_NAME := length-tests
+ARDUINO_LIBS := AUnit AceCommon AceTime TinyMqtt EspMock ESP8266WiFi  ESPAsyncTCP TinyConsole
+ARDUINO_LIB_DIRS := ../../../EspMock/libraries
+EPOXY_CORE := EPOXY_CORE_ESP8266
+include ../../../EpoxyDuino/EpoxyDuino.mk

tests/length-tests.todo/length-tests.ino

@@ -0,0 +1,54 @@
+// vim: ts=2 sw=2 expandtab
+#include <AUnit.h>
+#include <TinyMqtt.h>
+#include <map>
+
+/**
+  * TinyMqtt local unit tests.
+  *
+  * Clients are connected to pseudo remote broker
+  * The remote should be 127.0.0.1:1883 <--- But this does not work due to Esp network limitations
+  * We are using 127.0.0.1 because this is simpler to test with a single ESP
+  * Also, this will allow to mock and thus run Action on github
+  **/
+
+using namespace std;
+
+MqttBroker broker(1883);
+
+std::map<std::string, std::map<Topic, int>>  published;    // map[client_id] => map[topic] = count
+
+const char* lastPayload;
+size_t lastLength;
+
+void onPublish(const MqttClient* srce, const Topic& topic, const char* payload, size_t length)
+{
+  if (srce)
+    published[srce->id()][topic]++;
+  lastPayload = payload;
+  lastLength = length;
+}
+
+test(length_decode_greater_than_127)
+{
+  // TODO WRITE THIS TEST
+  // The test should verify than a mqtt message with more than 127 bytes is correctly decoded
+  assertEqual(1,2);
+}
+
+
+//----------------------------------------------------------------------------
+// setup() and loop()
+void setup() {
+  delay(1000);
+  Serial.begin(115200);
+  while(!Serial);
+
+  Serial.println("=============[ NO WIFI CONNECTION TinyMqtt TESTS ]========================");
+}
+
+void loop() {
+  aunit::TestRunner::run();
+
+  if (Serial.available()) ESP.reset();
+}

tests/local-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 := local-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

tests/local-tests/local-tests.ino

@@ -0,0 +1,201 @@
+#include <Arduino.h>
+#include <AUnit.h>
+#include <TinyMqtt.h>
+#include <map>
+
+/**
+  * TinyMqtt local unit tests.
+  *
+  * Clients are connected to pseudo remote broker
+  * The remote should be 127.0.0.1:1883 <--- But this does not work due to Esp network limitations
+  * We are using 127.0.0.1 because this is simpler to test with a single ESP
+  * Also, this will allow to mock and thus run Action on github
+  **/
+
+using string = TinyConsole::string;
+
+MqttBroker broker(1883);
+
+std::map<string, std::map<Topic, int>>  published;    // map[client_id] => map[topic] = count
+
+const char* lastPayload;
+size_t lastLength;
+
+void onPublish(const MqttClient* srce, const Topic& topic, const char* payload, size_t length)
+{
+  if (srce)
+    published[srce->id()][topic]++;
+  lastPayload = payload;
+  lastLength = length;
+}
+
+test(local_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);
+  {
+    assertEqual(broker.clientsCount(), (size_t)0);  // Ensure client is not yet connected
+    MqttClient client(&broker);
+    assertEqual(broker.clientsCount(), (size_t)1);  // Ensure client is now connected
+  }
+  assertEqual(broker.clientsCount(), (size_t)0);
+}
+
+test(local_client_do_not_disconnect_after_publishing_and_long_inactivity)
+{
+  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(&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(&broker, "");
+  subscriber.subscribe("a/b");
+  subscriber.subscribe("a/c");
+  subscriber.setCallback(onPublish);
+
+  MqttClient publisher(&broker);
+  publisher.publish("a/b");
+  publisher.publish("a/c");
+  publisher.publish("a/c");
+
+  assertEqual(published.size(), (size_t)1);  // 1 client has received something
+  assertEqual(published[""]["a/b"], 1);
+  assertEqual(published[""]["a/c"], 2);
+}
+
+test(local_publish_should_be_dispatched_to_local_clients)
+{
+  published.clear();
+  assertEqual(broker.clientsCount(), (size_t)0);
+
+  MqttClient subscriber_a(&broker, "A");
+  subscriber_a.setCallback(onPublish);
+  subscriber_a.subscribe("a/b");
+  subscriber_a.subscribe("a/c");
+
+  MqttClient subscriber_b(&broker, "B");
+  subscriber_b.setCallback(onPublish);
+  subscriber_b.subscribe("a/b");
+
+  MqttClient publisher(&broker);
+  publisher.publish("a/b");
+  publisher.publish("a/c");
+
+  assertEqual(published.size(), (size_t)2);  // 2 clients have received something
+  assertEqual(published["A"]["a/b"], 1);
+  assertEqual(published["A"]["a/c"], 1);
+  assertEqual(published["B"]["a/b"], 1);
+  assertEqual(published["B"]["a/c"], 0);
+}
+
+test(local_unsubscribe)
+{
+  published.clear();
+  assertEqual(broker.clientsCount(), (size_t)0);
+
+  MqttClient subscriber(&broker, "");
+  subscriber.setCallback(onPublish);
+  subscriber.subscribe("a/b");
+
+  MqttClient publisher(&broker);
+  publisher.publish("a/b");
+
+  subscriber.unsubscribe("a/b");
+
+  publisher.publish("a/b");
+  publisher.publish("a/b");
+
+  assertEqual(published[""]["a/b"], 1);  // Only one publish has been received
+}
+
+test(local_nocallback_when_destroyed)
+{
+  published.clear();
+  assertEqual(broker.clientsCount(), (size_t)0);
+
+  MqttClient publisher(&broker);
+  {
+    MqttClient subscriber(&broker);
+    subscriber.setCallback(onPublish);
+    subscriber.subscribe("a/b");
+    publisher.publish("a/b");
+  }
+
+  publisher.publish("a/b");
+
+  assertEqual(published.size(), (size_t)1);  // Only one publish has been received
+}
+
+//----------------------------------------------------------------------------
+// setup() and loop()
+void setup() {
+  delay(1000);
+  Serial.begin(115200);
+  while(!Serial);
+
+  Serial.println("=============[ LOCAL TinyMqtt TESTS              ]========================");
+}
+
+void loop() {
+  aunit::TestRunner::run();
+
+  if (Serial.available()) ESP.reset();
+}

tests/network-tests/Makefile

@@ -0,0 +1,13 @@
+# See https://github.com/bxparks/EpoxyDuino for documentation about this
+# Makefile to compile and run Arduino programs natively on Linux or MacOS.
+
+include ../Makefile.opts
+
+# Remove flto flag from EpoxyDuino (too many <optimized out>)
+# CXXFLAGS = -Wextra -Wall -std=gnu++11 -fno-exceptions -fno-threadsafe-statics
+
+APP_NAME := network-tests
+ARDUINO_LIBS := AUnit AceCommon AceTime TinyMqtt EspMock ESP8266WiFi  ESPAsyncTCP TinyConsole
+ARDUINO_LIB_DIRS := ../../../EspMock/libraries
+EPOXY_CORE := EPOXY_CORE_ESP8266
+include ../../../EpoxyDuino/EpoxyDuino.mk

tests/network-tests/network-tests.ino

@@ -0,0 +1,483 @@
+// vim: ts=2 sw=2 expandtab
+#include <Arduino.h>
+#include <AUnit.h>
+#include <TinyMqtt.h>
+#include <map>
+#include <iostream>
+#include <iomanip>
+#include <sstream>
+#include <string>
+#include <iostream>
+
+/**
+  * TinyMqtt network unit tests.
+  *
+  * No wifi connection unit tests.
+  * 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)
+{
+  std::stringstream out;
+  std::string ascii;
+  std::string h("0123456789ABCDEF");
+  for(size_t i=0; i<length; i++)
+  {
+    uint8_t c = buffer[i];
+    out << h[ c >> 4] << h[ c & 0x0F ];
+    if (sep) out << sep;
+    if (ascii_pos)
+    {
+      if (c>=32)
+        ascii += c;
+      else
+        ascii +='.';
+    }
+  }
+  std::string ret(out.str());
+  if (ascii_pos)
+  {
+    while(ret.length() < ascii_pos)
+      ret += ' ';
+    ret +='[' + ascii + ']';
+  }
+  return ret;
+}
+
+void dumpMqttMessage(const uint8_t* buffer, size_t length)
+{
+  std::map<int, std::string> pkt =
+  { { MqttMessage::Unknown     , "Unknown     " },
+    { MqttMessage::Connect     , "Connect     " },
+    { MqttMessage::ConnAck     , "ConnAck     " },
+    { MqttMessage::Publish     , "Publish     " },
+    { MqttMessage::PubAck      , "PubAck      " },
+    { MqttMessage::Subscribe   , "Subscribe   " },
+    { MqttMessage::SubAck      , "SubAck      " },
+    { MqttMessage::UnSubscribe , "Unsubscribe " },
+    { MqttMessage::UnSuback    , "UnSubAck    " },
+    { MqttMessage::PingReq     , "PingReq     " },
+    { MqttMessage::PingResp    , "PingResp    " },
+    { MqttMessage::Disconnect  , "Disconnect  " } };
+
+  std::cout << "       |   data sent " << std::setw(3) << length << " : ";
+  auto it = pkt.find(buffer[0] & 0xF0);
+  if (it == pkt.end())
+    std::cout << pkt[MqttMessage::Unknown];
+  else
+    std::cout << it->second;
+
+  std::cout << bufferToHexa(buffer, length, ' ', 60) << std::endl;
+}
+
+String toString(const IPAddress& ip)
+{
+  return String(ip[0])+'.'+String(ip[1])+'.'+String(ip[2])+'.'+String(ip[3]);
+}
+
+MqttBroker broker(1883);
+
+std::map<string, std::map<Topic, int>>  published;    // map[client_id] => map[topic] = count
+
+char* lastPayload = nullptr;
+size_t lastLength;
+
+void start_servers(int n, bool early_accept = true)
+{
+    ESP8266WiFiClass::resetInstances();
+    ESP8266WiFiClass::earlyAccept = early_accept;
+    while(n)
+    {
+      ESP8266WiFiClass::selectInstance(n--);
+      WiFi.mode(WIFI_STA);
+      WiFi.begin("fake_ssid", "fake_pwd");
+    }
+}
+
+void onPublish(const MqttClient* srce, const Topic& topic, const char* payload, size_t length)
+{
+  if (srce)
+    published[srce->id()][topic]++;
+
+  if (lastPayload) free(lastPayload);
+  lastPayload = strdup(payload);
+  lastLength = length;
+}
+
+test(network_single_broker_begin)
+{
+  assertEqual(WiFi.status(), WL_CONNECTED);
+
+  MqttBroker broker(1883);
+  broker.begin();
+
+  // TODO Nothing is tested here !
+}
+
+test(suback)
+{
+  start_servers(2, true);
+  assertEqual(WiFi.status(), WL_CONNECTED);
+
+  MqttBroker broker(1883);
+  broker.begin();
+  IPAddress broker_ip = WiFi.localIP();
+
+  ESP8266WiFiClass::selectInstance(2);
+  MqttClient client;
+  client.connect(broker_ip.toString().c_str(), 1883);
+  broker.loop();
+
+  assertTrue(broker.clientsCount() == 1);
+  assertTrue(client.connected());
+
+  MqttClient::counters[MqttMessage::Type::SubAck] = 0;
+  client.subscribe("a/b");
+
+  // TODO how to avoid these loops ???
+  broker.loop();
+  client.loop();
+
+  assertEqual(MqttClient::counters[MqttMessage::Type::SubAck], 1);
+}
+
+test(network_client_keep_alive_high)
+{
+  const uint32_t keep_alive=1000;
+  start_servers(2, true);
+  assertEqual(WiFi.status(), WL_CONNECTED);
+
+  MqttBroker broker(1883);
+  broker.begin();
+  IPAddress broker_ip = WiFi.localIP();
+
+  ESP8266WiFiClass::selectInstance(2);
+  MqttClient client;
+  client.connect(broker_ip.toString().c_str(), 1883, 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(network_client_to_broker_connexion)
+{
+  start_servers(2, true);
+  assertEqual(WiFi.status(), WL_CONNECTED);
+
+  MqttBroker broker(1883);
+  broker.begin();
+  IPAddress broker_ip = WiFi.localIP();
+
+  ESP8266WiFiClass::selectInstance(2);
+  MqttClient client;
+  client.connect(broker_ip.toString().c_str(), 1883);
+  broker.loop();
+
+  assertTrue(broker.clientsCount() == 1);
+  assertTrue(client.connected());
+}
+
+test(network_one_client_one_broker_publish_and_subscribe_through_network)
+{
+  start_servers(2, true);
+  published.clear();
+  assertEqual(WiFi.status(), WL_CONNECTED);
+
+  MqttBroker broker(1883);
+  broker.begin();
+  IPAddress ip_broker = WiFi.localIP();
+
+  // We have a 2nd ESP in order to test through wifi (opposed to local)
+  ESP8266WiFiClass::selectInstance(2);
+  MqttClient client;
+  client.connect(ip_broker.toString().c_str(), 1883);
+  broker.loop();
+  assertTrue(client.connected());
+
+  client.setCallback(onPublish);
+  client.subscribe("a/b");
+  client.publish("a/b", "ab");
+
+  for (int i =0; i<2; i++)
+  {
+    client.loop();
+    broker.loop();
+  }
+
+  assertEqual(published.size(), (size_t)1);
+  assertEqual((int)lastLength, (int)2); // sizeof(ab)
+}
+
+test(network_one_client_one_broker_hudge_publish_and_subscribe_through_network)
+{
+  start_servers(2, true);
+  published.clear();
+  assertEqual(WiFi.status(), WL_CONNECTED);
+
+  MqttBroker broker(1883);
+  broker.begin();
+  IPAddress ip_broker = WiFi.localIP();
+
+  // We have a 2nd ESP in order to test through wifi (opposed to local)
+  ESP8266WiFiClass::selectInstance(2);
+  MqttClient client;
+  client.connect(ip_broker.toString().c_str(), 1883);
+  broker.loop();
+  assertTrue(client.connected());
+
+  std::string sent;
+
+  for(int i=0; i<200; i++)
+    sent += char('0'+i%10);
+
+  client.setCallback(onPublish);
+  client.subscribe("a/b");
+  client.publish("a/b", sent.c_str());
+
+  for (int i =0; i<2; i++)
+  {
+    client.loop();
+    broker.loop();
+  }
+
+  assertEqual(published.size(), (size_t)1);
+  assertEqual((unsigned int)lastLength, (unsigned int)sent.size());
+}
+
+test(network_client_should_unregister_when_destroyed)
+{
+  assertEqual(broker.clientsCount(), (size_t)0);
+  {
+    MqttClient client(&broker);
+    assertEqual(broker.clientsCount(), (size_t)1);
+  }
+  assertEqual(broker.clientsCount(), (size_t)0);
+}
+
+
+// THESE TESTS ARE IN LOCAL MODE
+// WE HAVE TO CONVERT THEM TO WIFI MODE (pass through virtual TCP link)
+
+test(network_connect)
+{
+  assertEqual(broker.clientsCount(), (size_t)0);
+
+  MqttClient client(&broker);
+  assertTrue(client.connected());
+  assertEqual(broker.clientsCount(), (size_t)1);
+}
+
+test(network_publish_should_be_dispatched)
+{
+  published.clear();
+  assertEqual(broker.clientsCount(), (size_t)0);
+
+  MqttClient subscriber(&broker);
+  subscriber.subscribe("a/b");
+  subscriber.subscribe("a/c");
+  subscriber.setCallback(onPublish);
+
+  MqttClient publisher(&broker);
+  publisher.publish("a/b");
+  publisher.publish("a/c");
+  publisher.publish("a/c");
+
+  assertEqual(published.size(), (size_t)1);  // 1 client has received something
+  assertEqual(published[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)
+{
+  published.clear();
+  assertEqual(broker.clientsCount(), (size_t)0);
+
+  MqttClient subscriber_a(&broker, "A");
+  subscriber_a.setCallback(onPublish);
+  subscriber_a.subscribe("a/b");
+  subscriber_a.subscribe("a/c");
+
+  MqttClient subscriber_b(&broker, "B");
+  subscriber_b.setCallback(onPublish);
+  subscriber_b.subscribe("a/b");
+
+  MqttClient publisher(&broker);
+  publisher.publish("a/b");    // A and B should receive this
+  publisher.publish("a/c");    // A should receive this
+
+  assertEqual(published.size(), (size_t)2);  // 2 clients have received something
+  assertEqual(published["A"]["a/b"], 1);
+  assertEqual(published["A"]["a/c"], 1);
+  assertEqual(published["B"]["a/b"], 1);
+  assertEqual(published["B"]["a/c"], 0);
+}
+
+test(network_unsubscribe)
+{
+  published.clear();
+  assertEqual(broker.clientsCount(), (size_t)0);
+
+  MqttClient subscriber(&broker);
+  subscriber.setCallback(onPublish);
+  subscriber.subscribe("a/b");
+
+  MqttClient publisher(&broker);
+  publisher.publish("a/b");    // This publish is received
+
+  subscriber.unsubscribe("a/b");
+
+  publisher.publish("a/b");    // Those one, no (unsubscribed)
+  publisher.publish("a/b");
+
+  assertEqual(published[TINY_MQTT_DEFAULT_CLIENT_ID]["a/b"], 1);  // Only one publish has been received
+}
+
+test(network_nocallback_when_destroyed)
+{
+  published.clear();
+  assertEqual(broker.clientsCount(), (size_t)0);
+
+  MqttClient publisher(&broker);
+
+  {
+    MqttClient subscriber(&broker);
+    subscriber.setCallback(onPublish);
+    subscriber.subscribe("a/b");
+    publisher.publish("a/b");
+  }
+
+  publisher.publish("a/b");
+
+  assertEqual(published.size(), (size_t)1);  // Only one publish has been received
+}
+
+test(network_small_payload)
+{
+  published.clear();
+
+  const char* payload="abcd";
+
+  MqttClient subscriber(&broker);
+  subscriber.setCallback(onPublish);
+  subscriber.subscribe("a/b");
+
+  MqttClient publisher(&broker);
+  publisher.publish("a/b", payload, strlen(payload));    // This publish is received
+
+  // coming from MqttClient::publish(...)
+  assertEqual(payload, lastPayload);
+  assertEqual(lastLength, (size_t)4);
+}
+
+test(network_hudge_payload)
+{
+  const char* payload="This payload is hudge, just because its length exceeds 127. Thus when encoding length, we have to encode it on two bytes at min. This should not prevent the message from being encoded and decoded successfully !";
+
+  MqttClient subscriber(&broker);
+  subscriber.setCallback(onPublish);
+  subscriber.subscribe("a/b");          // Note -> this does not send any byte .... (nowhere to send)
+
+  MqttClient publisher(&broker);
+  publisher.publish("a/b", payload);    // This publish is received
+
+  // onPublish should have filled lastPayload and lastLength
+  assertEqual(payload, lastPayload);
+  assertEqual(lastLength, strlen(payload));
+  assertEqual(strcmp(payload, lastPayload), 0);
+}
+
+test(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;
+
+  NetworkObserver check(
+    [this](const WiFiClient*, const uint8_t* buffer, size_t length)
+    {
+      if (view) dumpMqttMessage(buffer, length);
+      if (buffer[0] == MqttMessage::ConnAck)
+      {
+        std::string hex = bufferToHexa(buffer, length);
+        assertStringCaseEqual(hex.c_str(), "20020000");
+      }
+    }
+  );
+
+  start_servers(2, true);
+  assertEqual(WiFi.status(), WL_CONNECTED);
+
+  MqttBroker broker(1883);
+  broker.begin();
+  IPAddress broker_ip = WiFi.localIP();
+
+  ESP8266WiFiClass::selectInstance(2);
+  MqttClient client;
+  client.connect(broker_ip.toString().c_str(), 1883);
+  broker.loop();
+
+  assertTrue(broker.clientsCount() == 1);
+  assertTrue(client.connected());
+
+  MqttClient::counters[MqttMessage::Type::SubAck] = 0;
+  client.subscribe("a/b");
+
+  // TODO how to avoid these loops ???
+  broker.loop();
+  client.loop();
+
+  assertEqual(MqttClient::counters[MqttMessage::Type::SubAck], 1);
+}
+
+//----------------------------------------------------------------------------
+// setup() and loop()
+void setup() {
+  /* delay(1000);
+  Serial.begin(115200);
+  while(!Serial);
+  */
+
+  Serial.println("=============[ FAKE NETWORK TinyMqtt TESTS       ]========================");
+
+  WiFi.mode(WIFI_STA);
+  WiFi.begin("network", "password");
+}
+
+void loop() {
+  aunit::TestRunner::run();
+
+  if (Serial.available()) ESP.reset();
+  published.clear();  // Avoid crash in unit tests due to exit handlers
+}

tests/nowifi-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 := nowifi-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

tests/nowifi-tests/nowifi-tests.ino

@@ -0,0 +1,283 @@
+// vim: ts=2 sw=2 expandtab
+#include <Arduino.h>
+#include <AUnit.h>
+#include <TinyMqtt.h>
+#include <map>
+
+/**
+  * TinyMqtt nowifi unit tests.
+  *
+  * No wifi connection unit tests.
+  * Checks with a local broker. Clients must connect to the local broker
+  **/
+
+using string = TinyConsole::string;
+
+MqttBroker broker(1883);
+
+std::map<string, std::map<Topic, int>>  published;    // map[client_id] => map[topic] = count
+
+char* lastPayload = nullptr;
+size_t lastLength;
+
+void onPublish(const MqttClient* srce, const Topic& topic, const char* payload, size_t length)
+{
+  if (srce)
+    published[srce->id()][topic]++;
+
+  if (lastPayload) free(lastPayload);
+  lastPayload = strdup(payload);
+  lastLength = length;
+}
+
+test(nowifi_client_should_unregister_when_destroyed)
+{
+  assertEqual(broker.clientsCount(), (size_t)0);
+  {
+    MqttClient client(&broker);
+    assertEqual(broker.clientsCount(), (size_t)1);
+  }
+  assertEqual(broker.clientsCount(), (size_t)0);
+}
+
+test(nowifi_connect)
+{
+  assertEqual(broker.clientsCount(), (size_t)0);
+
+  MqttClient client(&broker);
+  assertTrue(client.connected());
+  assertEqual(broker.clientsCount(), (size_t)1);
+}
+
+test(nowifi_publish_should_be_dispatched)
+{
+  published.clear();
+  assertEqual(broker.clientsCount(), (size_t)0);
+
+  MqttClient subscriber(&broker);
+  subscriber.subscribe("a/b");
+  subscriber.subscribe("a/c");
+  subscriber.setCallback(onPublish);
+
+  MqttClient publisher(&broker);
+  publisher.publish("a/b");
+  publisher.publish("a/c");
+  publisher.publish("a/c");
+
+  assertEqual(published.size(), (size_t)1);  // 1 client has received something
+  assertEqual(published[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)
+{
+  published.clear();
+  assertEqual(broker.clientsCount(), (size_t)0);
+
+  MqttClient subscriber_a(&broker, "A");
+  subscriber_a.setCallback(onPublish);
+  subscriber_a.subscribe("a/b");
+  subscriber_a.subscribe("a/c");
+
+  MqttClient subscriber_b(&broker, "B");
+  subscriber_b.setCallback(onPublish);
+  subscriber_b.subscribe("a/b");
+
+  MqttClient publisher(&broker);
+  publisher.publish("a/b");    // A and B should receive this
+  publisher.publish("a/c");    // A should receive this
+
+  assertEqual(published.size(), (size_t)2);  // 2 clients have received something
+  assertEqual(published["A"]["a/b"], 1);
+  assertEqual(published["A"]["a/c"], 1);
+  assertEqual(published["B"]["a/b"], 1);
+  assertEqual(published["B"]["a/c"], 0);
+}
+
+test(nowifi_subscribe_with_star_wildcard)
+{
+  published.clear();
+  assertEqual(broker.clientsCount(), (size_t)0);
+
+  MqttClient subscriber(&broker, "A");
+  subscriber.setCallback(onPublish);
+  subscriber.subscribe("house/*/temp");
+
+  MqttClient publisher(&broker);
+  publisher.publish("house/bedroom/temp");
+  publisher.publish("house/kitchen/temp");
+  publisher.publish("house/living_room/tv/temp");
+  publisher.publish("building/location1/bedroom/temp");
+
+  assertEqual(published["A"]["house/bedroom/temp"], 1);
+  assertEqual(published["A"]["house/kitchen/temp"], 1);
+  assertEqual(published["A"]["house/living_room/tv/temp"], 1);
+  assertEqual(published["A"]["building/location1/bedroom/temp"], 0);
+}
+
+test(nowifi_subscribe_with_plus_wildcard)
+{
+  published.clear();
+  assertEqual(broker.clientsCount(), (size_t)0);
+
+  MqttClient subscriber(&broker, "A");
+  subscriber.setCallback(onPublish);
+  subscriber.subscribe("house/+/temp");
+
+  MqttClient publisher(&broker);
+  publisher.publish("house/bedroom/temp");
+  publisher.publish("house/kitchen/temp");
+  publisher.publish("house/living_room/tv/temp");
+  publisher.publish("building/location1/bedroom/temp");
+
+  assertEqual(published["A"]["house/bedroom/temp"], 1);
+  assertEqual(published["A"]["house/kitchen/temp"], 1);
+  assertEqual(published["A"]["house/living_room/tv/temp"], 0);
+  assertEqual(published["A"]["building/location1/bedroom/temp"], 0);
+}
+
+test(nowifi_should_not_receive_sys_msg)
+{
+  published.clear();
+  assertEqual(broker.clientsCount(), (size_t)0);
+
+  MqttClient subscriber(&broker, "A");
+  subscriber.setCallback(onPublish);
+  subscriber.subscribe("+/data");
+
+  MqttClient publisher(&broker);
+  publisher.publish("$SYS/data");
+
+  assertEqual(published["A"]["$SYS/data"], 0);
+}
+
+test(nowifi_subscribe_with_mixed_wildcards)
+{
+  published.clear();
+  assertEqual(broker.clientsCount(), (size_t)0);
+
+  MqttClient subscriber(&broker, "A");
+  subscriber.setCallback(onPublish);
+  subscriber.subscribe("+/data/#");
+
+  MqttClient publisher(&broker);
+  publisher.publish("node1/data/update");
+  publisher.publish("node2/data/delta");
+  publisher.publish("node3/data");
+
+  assertEqual(published["A"]["node1/data/update"], 1);
+  assertEqual(published["A"]["node2/data/delta"], 1);
+  assertEqual(published["A"]["node3/data"], 1);
+}
+
+test(nowifi_unsubscribe_with_wildcards)
+{
+  published.clear();
+  assertEqual(broker.clientsCount(), (size_t)0);
+
+  MqttClient subscriber(&broker, "A");
+  subscriber.setCallback(onPublish);
+  subscriber.subscribe("one/two/+");
+  subscriber.subscribe("one/two/three");
+
+  MqttClient publisher(&broker);
+  publisher.publish("one/two/three");
+  publisher.publish("one/two/four");
+
+  subscriber.unsubscribe("one/two/+");
+  publisher.publish("one/two/five");
+
+  assertEqual(published["A"]["one/two/three"], 1);
+  assertEqual(published["A"]["one/two/four"], 1);
+  assertEqual(published["A"]["one/two/five"], 0);
+}
+
+test(nowifi_unsubscribe)
+{
+  published.clear();
+  assertEqual(broker.clientsCount(), (size_t)0);
+
+  MqttClient subscriber(&broker);
+  subscriber.setCallback(onPublish);
+  subscriber.subscribe("a/b");
+
+  MqttClient publisher(&broker);
+  publisher.publish("a/b");    // This publish is received
+
+  subscriber.unsubscribe("a/b");
+
+  publisher.publish("a/b");    // Those one, no (unsubscribed)
+  publisher.publish("a/b");
+
+  assertEqual(published[TINY_MQTT_DEFAULT_CLIENT_ID]["a/b"], 1);  // Only one publish has been received
+}
+
+test(nowifi_nocallback_when_destroyed)
+{
+  published.clear();
+  assertEqual(broker.clientsCount(), (size_t)0);
+
+  MqttClient publisher(&broker);
+
+  {
+    MqttClient subscriber(&broker);
+    subscriber.setCallback(onPublish);
+    subscriber.subscribe("a/b");
+    publisher.publish("a/b");
+  }
+
+  publisher.publish("a/b");
+
+  assertEqual(published.size(), (size_t)1);  // Only one publish has been received
+}
+
+test(nowifi_small_payload)
+{
+  published.clear();
+
+  const char* payload="abcd";
+
+  MqttClient subscriber(&broker);
+  subscriber.setCallback(onPublish);
+  subscriber.subscribe("a/b");
+
+  MqttClient publisher(&broker);
+  publisher.publish("a/b", payload, strlen(payload));    // This publish is received
+
+  // coming from MqttClient::publish(...)
+  assertEqual(payload, lastPayload);
+  assertEqual(lastLength, (size_t)4);
+}
+
+test(nowifi_hudge_payload)
+{
+  const char* payload="This payload is hudge, just because its length exceeds 127. Thus when encoding length, we have to encode it on two bytes at min. This should not prevent the message from being encoded and decoded successfully !";
+
+  MqttClient subscriber(&broker);
+  subscriber.setCallback(onPublish);
+  subscriber.subscribe("a/b");
+
+  MqttClient publisher(&broker);
+  publisher.publish("a/b", payload);    // This publish is received
+
+  // onPublish should have filled lastPayload and lastLength
+  assertEqual(payload, lastPayload);
+  assertEqual(lastLength, strlen(payload));
+}
+
+//----------------------------------------------------------------------------
+// setup() and loop()
+void setup() {
+  delay(1000);
+  Serial.begin(115200);
+  while(!Serial);
+
+  Serial.println("=============[ NO WIFI CONNECTION TinyMqtt TESTS ]========================");
+}
+
+void loop() {
+  aunit::TestRunner::run();
+
+  if (Serial.available()) ESP.reset();
+  published.clear();  // Avoid crash at exit handlers
+}

tests/result.json

@@ -0,0 +1,6 @@
+{
+    "schemaVersion" : 1,
+    "label" : "tests",
+    "message" : "Message content",
+    "color": "red"
+}

tests/result.yaml

@@ -0,0 +1,2 @@
+result: 1
+insert: "passed"

tests/string-indexer-tests/Makefile

@@ -0,0 +1,10 @@
+# See https://github.com/bxparks/EpoxyDuino for documentation about this
+# Makefile to compile and run Arduino programs natively on Linux or MacOS.
+
+include ../Makefile.opts
+
+APP_NAME := string-indexer-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

tests/string-indexer-tests/string-indexer-tests.ino

@@ -0,0 +1,119 @@
+// vim: ts=2 sw=2 expandtab
+#include <Arduino.h>
+#include <AUnit.h>
+#include <StringIndexer.h>
+#include <map>
+
+/**
+  * TinyMqtt / StringIndexer unit tests.
+  *
+  **/
+
+using string = TinyConsole::string;
+
+test(indexer_empty)
+{
+  assertEqual(StringIndexer::count(), 0);
+}
+
+test(indexer_strings_deleted_should_empty_indexer)
+{
+  assertTrue(StringIndexer::count()==0);
+  {
+    IndexedString one("one");
+    assertEqual(StringIndexer::count(), 1);
+    IndexedString two("two");
+    assertEqual(StringIndexer::count(), 2);
+    IndexedString three("three");
+    assertEqual(StringIndexer::count(), 3);
+    IndexedString four("four");
+    assertEqual(StringIndexer::count(), 4);
+  }
+  assertEqual(StringIndexer::count(), 0);
+}
+
+test(indexer_same_strings_count_as_one)
+{
+  IndexedString one  ("one");
+  IndexedString two  ("one");
+  IndexedString three("one");
+  IndexedString fourt("one");
+
+  assertEqual(StringIndexer::count(), 1);
+}
+
+test(indexer_size_of_indexed_string)
+{
+  assertEqual(sizeof(IndexedString), (size_t)1);
+}
+
+test(indexer_different_strings_are_different)
+{
+  IndexedString one("one");
+  IndexedString two("two");
+
+  assertFalse(one == two);
+}
+
+test(indexer_same_strings_should_equal)
+{
+  IndexedString one("one");
+  IndexedString two("one");
+
+  assertTrue(one == two);
+}
+
+test(indexer_compare_strings_with_same_beginning)
+{
+  IndexedString two("one_two");
+  IndexedString one("one");
+
+  assertNotEqual(one.getIndex(), two.getIndex());
+}
+
+test(indexer_indexed_operator_eq)
+{
+  IndexedString one("one");
+  {
+    IndexedString same = one;
+    assertTrue(one == same);
+    assertEqual(StringIndexer::count(), 1);
+  }
+  assertEqual(StringIndexer::count(), 1);
+}
+
+test(indexer_get_string)
+{
+  string sone("one");
+  IndexedString one(sone);
+
+  assertTrue(sone==one.str());
+}
+
+test(indexer_get_index)
+{
+  IndexedString one1("one");
+  IndexedString one2("one");
+  IndexedString two1("two");
+  IndexedString two2("two");
+
+  assertTrue(one1.getIndex() == one2.getIndex());
+  assertTrue(two1.getIndex() == two2.getIndex());
+  assertTrue(one1.getIndex() != two1.getIndex());
+}
+
+//----------------------------------------------------------------------------
+// setup() and loop()
+void setup() {
+  delay(1000);
+  Serial.begin(115200);
+  while(!Serial);
+
+  Serial.println("=============[ TinyMqtt StringIndexer TESTS ]========================");
+}
+
+void loop() {
+  aunit::TestRunner::run();
+
+  // if (Serial.available()) ESP.reset();
+}

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

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();
+}