Update mqtt_class_binder.ino

- TINY_MQTT_DEBUG was not set (no dump)
  - MqttClient::counter has disapeared (compilation error)
  - payload was badly displayed
  - broker/client names could be reused for client/brokers

.github/workflows/aunit.yml

@@ -17,6 +17,7 @@ jobs:
     - name: Setup
       run: |
         cd ..
+        git clone https://github.com/hsaturn/TinyConsole
         git clone https://github.com/bxparks/EpoxyDuino
         git clone https://github.com/bxparks/AceRoutine
         git clone https://github.com/bxparks/AUnit
@@ -24,5 +25,11 @@ jobs:
         git clone https://github.com/hsaturn/EspMock
     - name: Verify tests
       run: |
-        make -C tests
+        # 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

@@ -1,26 +1,52 @@
-name: Super-Linter
+---
+#################################
+#################################
+## Super Linter GitHub Actions ##
+#################################
+#################################
+name: Lint Code Base
 
-# Run this workflow every time a new commit pushed to your repository
 #
+# 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:
-  # Set the job key. The key is displayed as the job name
+  build:
-  # when a job name is not provided
-  super-lint:
     # Name the Job
-    name: Lint code base
+    name: Lint Code Base
-    # Set the type of machine to run on
+    # Set the agent to run on
     runs-on: ubuntu-latest
 
+    ##################
+    # Load all steps #
+    ##################
     steps:
-      # Checks out a copy of your repository on the ubuntu-latest machine
+      ##########################
-      - name: Checkout code
+      # Checkout the code base #
-        uses: actions/checkout@v2
+      ##########################
+      - 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
 
-      # Runs the Super-Linter action
+      ################################
-      - name: Run Super-Linter
+      # Run Linter against code base #
-        uses: github/super-linter@v3
+      ################################
+      - 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,5 +0,0 @@
-*~
-src/my_credentials.h
-*.o
-*.swp
-*.out

README.md

@@ -1,67 +1,77 @@
 # TinyMqtt
 
-![Release](https://img.shields.io/github/v/release/hsaturn/TinyMqtt)
+[![Release](https://img.shields.io/github/v/release/hsaturn/TinyMqtt)](https://github.com/hsaturn/TinyMqtt/releases)
-![Issues](https://img.shields.io/github/issues/hsaturn/TinyMqtt)
+[![AUnit Tests](https://github.com/hsaturn/TinyMqtt/actions/workflows/aunit.yml/badge.svg)](https://github.com/hsaturn/TinyMqtt/actions/workflows/aunit.yml)
-![Esp8266](https://img.shields.io/badge/platform-ESP8266-green)
+[![Issues](https://img.shields.io/github/issues/hsaturn/TinyMqtt)](https://github.com/hsaturn/TinyMqtt/issues)
-![Gpl 3.0](https://img.shields.io/github/license/hsaturn/TinyMqtt)
+[![Esp8266](https://img.shields.io/badge/platform-ESP8266-green)](https://www.espressif.com/en/products/socs/esp8266)
-![Mqtt 3.1.1](https://img.shields.io/badge/Mqtt-%203.1.1-yellow)
+[![Esp32](https://img.shields.io/badge/platform-ESP32-green)](https://www.espressif.com/en/products/socs/esp32)
+[![Gpl 3.0](https://img.shields.io/github/license/hsaturn/TinyMqtt)](https://www.gnu.org/licenses/gpl-3.0.fr.html)
+[![Mqtt 3.1.1](https://img.shields.io/badge/Mqtt-%203.1.1-yellow)](https://docs.oasis-open.org/mqtt/mqtt/v3.1.1/errata01/os/mqtt-v3.1.1-errata01-os-complete.html#_Toc442180822)
 
-ESP 8266 is a small, fast and capable Mqtt Broker and Client
+TinyMqtt is a small, fast and capable Mqtt Broker and Client for Esp8266 / Esp32 / Esp WROOM
 
 ## Features
 
-- Very (very !!) fast broker I saw it re-sent 1000 topics per second for two
+- Very fast broker I saw it re-sent 1000 topics per second for two
-  clients that had subscribed (payload ~15 bytes). No topic lost.
+  clients that had subscribed (payload ~15 bytes ESP8266). No topic lost.
   The max I've seen was 2k msg/s (1 client 1 subscription)
 - Act as as a mqtt broker and/or a mqtt client
 - Mqtt 3.1.1 / Qos 0 supported
+- Wildcards supported (+ # $ and * (even if not part of the spec...))
 - Standalone (can work without WiFi) (degraded/local mode)
 - Brokers can connect to another broker and becomes then a
   proxy for clients that are connected to it.
 - zeroconf, this is a strange but very powerful mode where
   all brokers tries to connect together on the same local network.
+- small memory footprint (very efficient topic storage)
+- long messages are supported (>127 bytes)
+- TinyMQTT is largely unit tested, so once a bug is fixed, it is fixed forever
 
-## TODO List
+## Limitations
-* Use [Async library](https://github.com/me-no-dev/ESPAsyncTCP)
+
-* Implement zeroconf mode (needs async)
+- Max of 255 different topics can be stored (change index_t type to allow more)
-* Add a max_clients in MqttBroker. Used with zeroconf, there will be
+- No Qos because messages are not queued but immediately sent to clients
-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.
-* ~~MqttMessage uses a buffer 256 bytes which is usually far than needed.~~
-* ~~MqttClient does not support more than one subscription at time~~
-* ~~MqttClient auto re-subscribe (::resubscribe works bad on broker.emqx.io)~~
-* MqttClient auto reconnection
-* ~~MqttClient unsubscribe~~
-* MqttClient does not sent payload to callback...
-* MqttClient user/password
-* Wildcards (I may implement only # as I'm not interrested by a clever and cpu consuming matching)
 
 ## Quickstart
 
 * install [TinyMqtt library](https://github.com/hsaturn/TinyMqtt)
+  (you can use the Arduino library manager and search for TinyMqtt)
 * modify <libraries/TinyMqtt/src/my_credentials.h> (wifi setup)
 
 ## Examples
 
-
 | Example             | Description                                |
-| ---------------------------- | --------------------------------- |
+| ------------------- | ------------------------------------------ |
-| client-without-wifi | standalone example                         |
+| [client-with-wifi](https://github.com/hsaturn/TinyMqtt/tree/main/examples/client-with-wifi/client-with-wifi.ino) | standalone example                         |
-| simple-client       | Connect the ESP to an external Mqtt broker |
+| [client-without-wifi](https://github.com/hsaturn/TinyMqtt/tree/main/examples/client-without-wifi/client-without-wifi.ino) | standalone example                         |
-| simple-broker       | Simple Mqtt broker with your ESP           |
+| [simple-client](https://github.com/hsaturn/TinyMqtt/tree/main/examples/simple-client/simple-client.ino)       | Connect the ESP to an external Mqtt broker |
-| tinymqtt-test       | Complex console example                    |
+| [simple-broker](https://github.com/hsaturn/TinyMqtt/tree/main/examples/simple-broker/simple-broker.ino)       | Simple Mqtt broker with your ESP           |
+| [tinymqtt-test](https://github.com/hsaturn/TinyMqtt/tree/main/examples/tinymqtt-test/tinymqtt-test.ino)       | Complex console example                    |
 
 - tinymqtt-test : This is a complex sketch with a terminal console
   that allows to add clients publish, connect etc with interpreted commands.
 
 ## Standalone mode (zeroconf)
 -> The zeroconf mode is not yet implemented
-zerofonf clients to connect to broker on local network.
+zeroconf clients to connect to broker on local network.
 
 In Zeroconf mode, each ESP is a a broker and scans the local network.
 After a while one ESP naturally becomes a 'master' and all ESP are connected together.
 No problem if the master dies, a new master will be choosen soon.
 
+## TODO List
+* ~~Use [Async library](https://github.com/me-no-dev/ESPAsyncTCP)~~
+* Implement zeroconf mode (needs async)
+* Add a max_clients in MqttBroker. Used with zeroconf, there will be
+no need for having tons of clients (also RAM is the problem with many clients)
+* Why not a 'global' TinyMqtt::loop() instead of having to call loop for all broker/clients instances
+* Test what is the real max number of clients for broker. As far as I saw, 1k is needed per client which would make more than 30 clients critical.
+* ~~MqttClient auto re-subscribe (::resubscribe works bad on broker.emqx.io)~~
+* MqttClient auto reconnection
+* MqttClient user/password
+* ~~Wildcards (I may implement only # as I'm not interrested by a clever and cpu consuming matching)~~
+* I suspect that MqttClient::parent could be removed and replaced with a simple boolean
+  (this'll need to rewrite a few functions)
+
 ## License
 Gnu GPL 3.0, see [LICENSE](https://github.com/hsaturn/TinyMqtt/blob/main/LICENSE).

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 (48 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

@@ -3,23 +3,36 @@
 /** 
   * 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)
+  *      - can still report to a 'main' broker (TODO see documentation that have to be written)
-	*      - accepts external clients
+  *      - accepts external clients
   *
   * cons - Takes more memory
-	*      - a bit hard to understand
+  *      - a bit hard to understand
-	*
-  * This sounds crazy: a mqtt mqtt that do not need a broker !
-  *  The use case arise when one ESP wants to publish topics and subscribe to them at the same time.
-  *  Without broker, the ESP won't react to its own topics.
   *
-  *  TinyMqtt mqtt allows this use case to work.
   */
 
-#include <my_credentials.h>
+const char *ssid     = "";
+const char *password = "";
 
 std::string topic="sensor/temperature";
 
@@ -28,17 +41,20 @@ 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)
+void onPublishA(const MqttClient* /* source */, const Topic& topic, const char* payload, size_t /* length */)
-{ Serial << endl << "---------> A Received " << topic.c_str() << endl; }
+{ Serial << "--> client A received " << topic.c_str() << ", " << payload << endl; }
 
-void onPublishB(const MqttClient* source, const Topic& topic, const char* payload, size_t length)
+void onPublishB(const MqttClient* /* source */, const Topic& topic, const char* payload, size_t /* length */)
-{ Serial << endl << "---------> B Received " << topic.c_str() << endl; }
+{ Serial << "--> client B Received " << topic.c_str() << ", " << payload << endl; }
 
 void setup()
 {
   Serial.begin(115200);
-	delay(500);
+  delay(500);
-	Serial << "Clients with wifi " << endl;
+  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);
@@ -47,7 +63,7 @@ void setup()
 
   Serial << "Connected to " << ssid << "IP address: " << WiFi.localIP() << endl;
 
-	broker.begin();
+  broker.begin();
 
   mqtt_a.setCallback(onPublishA);
   mqtt_a.subscribe(topic);
@@ -58,30 +74,31 @@ void setup()
 
 void loop()
 {
-	broker.loop();
+  broker.loop();  // Don't forget to add loop for every broker and clients
 
   mqtt_a.loop();
   mqtt_b.loop();
 
   // ============= client A publish ================
-	static const int intervalA = 5000;  // publishes every 5s
+  static const int intervalA = 5000;  // publishes every 5s (please avoid usage of delay())
-	static uint32_t timerA = millis() + intervalA;
+  static uint32_t timerA = millis() + intervalA;
 
-	if (millis() > timerA)
+  if (millis() > timerA)
-	{
+  {
-		Serial << "A is publishing " << topic.c_str() << endl;
+    Serial << "A is publishing " << topic.c_str() << endl;
-		timerA += intervalA;
+    timerA += intervalA;
-		mqtt_a.publish(topic);
+    mqtt_a.publish(topic, " sent by A");
-	}
+  }
 
   // ============= client B publish ================
-	static const int intervalB = 7000;	// will send topic each 7s
+  static const int intervalB = 7000;	// will send topic each 7s
-	static uint32_t timerB = millis() + intervalB;
+  static uint32_t timerB = millis() + intervalB;
 
-	if (millis() > timerB)
+  if (millis() > timerB)
-	{
+  {
-		Serial << "B is publishing " << topic.c_str() << endl;
+		static int temperature;
-		timerB += intervalB;
+    Serial << "B is publishing " << topic.c_str() << endl;
-		mqtt_b.publish(topic, std::string(String(15+millis()%10).c_str()));
+    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

@@ -1,12 +1,30 @@
 #include <TinyMqtt.h>   // https://github.com/hsaturn/TinyMqtt
 
 /** TinyMQTT allows a disconnected mode:
- * 
+  * 
- *  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
+  *  | ESP                         |
- *  of MQTT, and once connected still continue to work with others.
+  *  |                 +--------+  |
- *  
+  *  |       +-------->| broker |  |
- */
+  *  |       |         +--------+  |
+  *  |       |             ^       |
+  *  |       |             |       |
+  *  |       v             v       |
+  *  | +----------+  +----------+  |
+  *  | | internal |  | internal |  |
+  *  | | client   |  | client   |  |          
+  *  | +----------+  +----------+  |          
+  *  |                             |
+  *  +-----------------------------+
+  *
+  *  In this example, local clients A and B are talking together, no need to be connected.
+  *
+  *  A single ESP can use this to be able to comunicate with itself with the power
+  *  of MQTT, and once connected still continue to work with others.
+  *
+  *  The broker may still be conected if wifi is on.
+  *
+  */
 
 std::string topic="sensor/temperature";
 
@@ -14,11 +32,11 @@ MqttBroker broker(1883);
 MqttClient mqtt_a(&broker);
 MqttClient mqtt_b(&broker);
 
-void onPublishA(const MqttClient* srce, const Topic& topic, const char* payload, size_t length)
+void onPublishA(const MqttClient* /* srce */, const Topic& topic, const char* payload, size_t /* length */)
-{ Serial << "--> A Received " << topic.c_str() << endl; }
+{ 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)
+void onPublishB(const MqttClient* /* srce */, const Topic& topic, const char* payload, size_t /* length */)
-{ Serial << "--> B Received " << topic.c_str() << endl; }
+{ Serial << "--> Client B received msg on topic " << topic.c_str() << ", " << payload << endl; }
 
 void setup()
 {
@@ -35,7 +53,7 @@ void setup()
 
 void loop()
 {
-	broker.loop();
+	broker.loop();	// Don't forget to call loop() for all brokers and clients
   mqtt_a.loop();
   mqtt_b.loop();
 
@@ -47,7 +65,7 @@ void loop()
 	{
 		Serial << "A is publishing " << topic.c_str() << endl;
 		timerA += intervalA;
-		mqtt_a.publish(topic);
+		mqtt_a.publish(topic, "sent by A");
 	}
 
   // ============= client B publish ================
@@ -58,6 +76,6 @@ void loop()
 	{
 		Serial << "B is publishing " << topic.c_str() << endl;
 		timerB += intervalB;
-		mqtt_b.publish(topic);
+		mqtt_b.publish(topic, "sent by B");
 	}
 }

examples/simple-broker/simple-broker.ino

@@ -1,14 +1,33 @@
 #include "TinyMqtt.h"   // https://github.com/hsaturn/TinyMqtt
 
-#include <my_credentials.h>
-
 #define PORT 1883
 MqttBroker broker(PORT);
 
+/** Basic Mqtt Broker
+  *
+  *  +-----------------------------+
+  *  | ESP                         |
+  *  |       +--------+            |
+  *  |       | broker |            | 1883 <--- External client/s
+  *  |       +--------+            |
+  *  |                             |
+  *  +-----------------------------+
+  *
+  *  Your ESP will become a MqttBroker.
+	*  You can test it with any client such as mqtt-spy for example
+	*
+  */
+
+const char* ssid = "";
+const char* password = "";
+
 void setup()
 {
   Serial.begin(115200);
 
+	if (strlen(ssid)==0)
+		Console << TinyConsole::red << "****** PLEASE MODIFY ssid/password *************" << endl;
+
   WiFi.mode(WIFI_STA);
   WiFi.begin(ssid, password);
 
@@ -16,10 +35,10 @@ void setup()
     Serial << '.';
     delay(500);
   }
-  Serial << "Connected to " << ssid << "IP address: " << WiFi.localIP() << endl;  
+  Console << TinyConsole::green << "Connected to " << ssid << "IP address: " << WiFi.localIP() << endl;
 
   broker.begin();
-  Serial << "Broker ready : " << WiFi.localIP() << " on port " << PORT << endl;
+  Console << "Broker ready : " << WiFi.localIP() << " on port " << PORT << endl;
 }
 
 void loop()

examples/simple-client/simple-client.ino

@@ -1,9 +1,26 @@
-#include <ESP8266WiFi.h>
+#include "TinyMqtt.h"    // https://github.com/hsaturn/TinyMqtt
-#include "TinyMqtt.h"   // https://github.com/hsaturn/TinyMqtt
+#include "TinyStreaming.h" // https://github.com/hsaturn/TinyConsole
 
-/** Simple Client
+/** Simple Client (The simplest configuration)
   *
-	* This is the simplest Mqtt client configuration
+  *                             
+  *                   +--------+       
+  *           +------>| broker |<--- <  Other client
+  *           |       +--------+       
+  *           |                               
+  *   +-----------------+
+  *   | ESP   |         |           
+  *   | +----------+    |          
+  *   | | internal |    |              
+  *   | | client   |    |          
+  *   | +----------+    |          
+  *   |                 |
+  *   +-----------------+
+  * 
+	* 1 - change the ssid/password
+	* 2 - change BROKER values (or keep emqx.io test broker)
+	* 3 - you can use mqtt-spy to connect to the same broker and
+	*     see the sensor/temperature updated by the client.
 	*
 	* pro  - small memory footprint (both ram and flash)
 	*      - very simple to setup and use
@@ -13,7 +30,11 @@
 	*      - local publishes takes more time (because they go outside)
 	*/
 
-#include <my_credentials.h>
+const char* BROKER = "broker.emqx.io";
+const uint16_t BROKER_PORT = 1883;
+
+const char* ssid = "";
+const char* password = "";
 
 static float temp=19;
 static MqttClient client;
@@ -22,7 +43,10 @@ void setup()
 {
   Serial.begin(115200);
 	delay(500);
+
 	Serial << "Simple clients with wifi " << endl;
+	if (strlen(ssid)==0)
+		Serial << "****** PLEASE MODIFY ssid/password *************" << endl;
 
   WiFi.mode(WIFI_STA);
   WiFi.begin(ssid, password);
@@ -32,21 +56,33 @@ void setup()
 
   Serial << "Connected to " << ssid << "IP address: " << WiFi.localIP() << endl;  
 
-	client.connect("192.168.1.40", 1883);	// Put here your broker ip / port
+	client.connect(BROKER, BROKER_PORT);
-
 }
 
 void loop()
 {
-	client.loop();
+	client.loop();	// Don't forget to call loop() for each broker and client
 
-	delay(1000);
+	// delay(1000);		please avoid usage of delay (see below how this done using next_send and millis())
+	static auto next_send = millis();
 	
-	auto rnd=random(100);
+	if (millis() > next_send)
+	{
+		next_send += 1000;
 
-	if (rnd > 66) temp += 0.1;
+		if (not client.connected())
-	else if (rnd < 33) temp -= 0.1;
+		{
+			Serial << millis() << ": Not connected to broker" << endl;
+			return;
+		}
 
-	client.publish("sensor/temperature", String(temp));
+		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));
+	}
 }

keywords.txt

@@ -9,13 +9,19 @@
 TinyMqtt    KEYWORD1
 
 MqttBroker  KEYWORD1
+connect		  KEYWORD2
+clientsCount KEYWORD2
 begin				KEYWORD2
 loop				KEYWORD2
+port				KEYWORD2
 
 MqttClient  KEYWORD1
+connect		  KEYWORD2
+connected	  KEYWORD2
 publish     KEYWORD2
 setCallback	KEYWORD2
 subscribe	  KEYWORD2
+unsubscribe	KEYWORD2
 
 Topic				KEYWORD1
 matches			KEYWORD2

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 to send and receive MQTT messages. It does support MQTT 3.1.1 without QOS=0.",
-    "repository": {
-        "type": "git",
-        "url": "https://github.com/hsaturn/TinyMqtt.git"
-    },
-    "version": "0.7.2",
-    "exclude": "",
-    "examples": "examples/*/*.ino",
-    "frameworks": "arduino",
-    "platforms": [
-        "atmelavr",
-        "espressif8266",
-        "espressif32"
-    ]
-}

library.properties

@@ -1,11 +1,11 @@
 name=TinyMqtt
-version=0.7.2
+version=0.9.10
 author=Francois BIOT, HSaturn, <hsaturn@gmail.com>
 maintainer=Francois BIOT, HSaturn, <hsaturn@gmail.com>
 sentence=A tiny broker and client library for MQTT messaging.
-paragraph=MQTT is a lightweight messaging protocol ideal for small devices. This library allows to send and receive MQTT messages and to host a broker in your ESP. It does support MQTT 3.1.1 without QoS=0.
+paragraph=MQTT is a lightweight messaging protocol ideal for small devices. This library allows to send and receive MQTT messages and to host a broker in your ESP 8266 and 32 WROOM. It does support MQTT 3.1.1 with QoS=0.
 category=Communication
 url=https://github.com/hsaturn/TinyMqtt
 architectures=*
+depends=TinyConsole
 includes=TinyMqtt.h
-depends=

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/MqttStreaming.h

@@ -1,412 +0,0 @@
-/* MqttStreaming.h - Fork of Streaming.h adding std::string and with some minor fixes
- * (I have to speek to the author in order to include my changes to his library if possible)
- **/
-
-/*
-  Streaming.h - Arduino library for supporting the << streaming operator
-  Copyright (c) 2010-2012 Mikal Hart.  All rights reserved.
-
-  This library is free software; you can redistribute it and/or
-  modify it under the terms of the GNU Lesser General Public
-  License as published by the Free Software Foundation; either
-  version 2.1 of the License, or (at your option) any later version.
-
-  This library is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-  Lesser General Public License for more details.
-
-  You should have received a copy of the GNU Lesser General Public
-  License along with this library; if not, write to the Free Software
-  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
-*/
-
-/*
-  Version 6 library changes
-    Copyright (c) 2019 Gazoodle. All rights reserved.
-
-  1.  _BASED moved to template to remove type conversion to long and
-      sign changes which break int8_t and int16_t negative numbers. 
-      The print implementation still upscales to long for it's internal
-      print routine.
-
-  2.  _PAD added to allow padding & filling of characters to the stream
-
-  3.  _WIDTH & _WIDTHZ added to allow width printing with space padding
-      and zero padding for numerics
-
-  4.  Simple _FMT mechanism ala printf, but without the typeunsafetyness 
-      and no internal buffers for replaceable stream printing
-*/
-
-#ifndef ARDUINO_STREAMING
-#define ARDUINO_STREAMING
-
-#if defined(ARDUINO) && ARDUINO >= 100
-#include "Arduino.h"
-#else
-#ifndef STREAMING_CONSOLE
-#include "WProgram.h"
-#endif
-#endif
-
-#include <string>
-
-#if defined(ARDUINO_ARCH_AVR) || defined(ARDUINO_ARCH_MEGAAVR)
-// No stl library, so need trivial version of std::is_signed ...
-namespace std {
-template<typename T>
-  struct is_signed { static const bool value = false; };
-  template<>
-  struct is_signed<int8_t> { static const bool value = true; };
-  template<>
-  struct is_signed<int16_t> { static const bool value = true; };
-  template<>
-  struct is_signed<int32_t> { static const bool value = true; };
-};
-#else
-#include <type_traits>
-#endif
-
-#define STREAMING_LIBRARY_VERSION 6
-
-#if !defined(typeof)
-#define typeof(x) __typeof__(x)
-#endif
-
-// PrintBuffer implementation of Print, a small buffer to print in
-// see its use with pad_float()
-template <size_t N>
-class PrintBuffer : public Print
-{
-  size_t  pos = 0;
-  char    str[N] {};
-public:
-  inline const char *operator() () 
-  { return str; };
-  
-  // inline void clear() 
-  // { pos = 0; str[0] = '\0'; };
-  
-  inline size_t write(uint8_t c) 
-  { return write(&c, 1); };
-  
-  inline size_t write(const uint8_t *buffer, size_t size)
-  {
-    size_t s = std::min(size, N-1 - pos); // need a /0 left
-    if (s)
-    {
-      memcpy(&str[pos], buffer, s);
-      pos += s;
-    }
-    return s;
-  };
-};
-
-// Generic template
-template<class T>
-inline Print &operator <<(Print &stream, const T &arg)
-{ stream.print(arg); return stream; }
-
-// TODO sfinae maybe could do the trick ?
-inline Print &operator <<(Print &stream, const std::string &str)
-{ stream.print(str.c_str()); return stream; }
-
-template<typename T>
-struct _BASED
-{
-  T val;
-  int base;
-  _BASED(T v, int b): val(v), base(b)
-  {}
-};
-
-#if ARDUINO >= 100
-
-struct _BYTE_CODE
-{
-  byte val;
-  _BYTE_CODE(byte v) : val(v)
-  {}
-};
-#define _BYTE(a)    _BYTE_CODE(a)
-
-inline Print &operator <<(Print &obj, const _BYTE_CODE &arg)
-{ obj.write(arg.val); return obj; }
-
-#else
-
-#define _BYTE(a)    _BASED<typeof(a)>(a, BYTE)
-
-#endif
-
-#define _HEX(a)     _BASED<typeof(a)>(a, HEX)
-#define _DEC(a)     _BASED<typeof(a)>(a, DEC)
-#define _OCT(a)     _BASED<typeof(a)>(a, OCT)
-#define _BIN(a)     _BASED<typeof(a)>(a, BIN)
-
-// Specialization for class _BASED
-// Thanks to Arduino forum user Ben Combee who suggested this
-// clever technique to allow for expressions like
-//   Serial << _HEX(a);
-
-template<typename T>
-inline Print &operator <<(Print &obj, const _BASED<T> &arg)
-{ obj.print(arg.val, arg.base); return obj; }
-
-#if ARDUINO >= 18
-// Specialization for class _FLOAT
-// Thanks to Michael Margolis for suggesting a way
-// to accommodate Arduino 0018's floating point precision
-// feature like this:
-//   Serial << _FLOAT(gps_latitude, 6); // 6 digits of precision
-
-struct _FLOAT
-{
-  double val; // only Print::print(double)
-  int digits;
-  _FLOAT(double v, int d): val(v), digits(d)
-  {}
-};
-
-inline Print &operator <<(Print &obj, const _FLOAT &arg)
-{ obj.print(arg.val, arg.digits); return obj; }
-#endif
-
-// Specialization for enum _EndLineCode
-// Thanks to Arduino forum user Paul V. who suggested this
-// clever technique to allow for expressions like
-//   Serial << "Hello!" << endl;
-
-enum _EndLineCode { endl };
-
-inline Print &operator <<(Print &obj, _EndLineCode)
-{ obj.println(); return obj; }
-
-// Specialization for padding & filling, mainly utilized
-// by the width printers
-//
-//  Use like 
-//    Serial << _PAD(10,' ');   // Will output 10 spaces
-//    Serial << _PAD(4, '0');   // Will output 4 zeros
-struct _PAD
-{
-  int8_t width;
-  char   chr;
-  _PAD(int8_t w, char c) : width(w), chr(c) {}
-};
-
-inline Print &operator <<(Print& stm, const _PAD &arg)
-{
-  for(int8_t i = 0; i < arg.width; i++)
-    stm.print(arg.chr);
-  return stm;
-}
-
-// Specialization for width printing
-//
-//    Use like                            Result
-//    --------                            ------
-//    Serial << _WIDTH(1,5)               "    1"
-//    Serial << _WIDTH(10,5)              "   10"
-//    Serial << _WIDTH(100,5)             "  100"
-//    Serial << _WIDTHZ(1,5)              "00001"
-//
-//  Great for times & dates, or hex dumps
-//
-//    Serial << _WIDTHZ(hour,2) << ':' << _WIDTHZ(min,2) << ':' << _WIDTHZ(sec,2)
-//
-//    for(int index=0; index<byte_array_size; index++)
-//      Serial << _WIDTHZ(_HEX(byte_array[index]))
-
-template<typename T>
-struct __WIDTH
-{
-  const T val;
-  int8_t width;
-  char pad;
-  __WIDTH(const T& v, int8_t w, char p) : val(v), width(w), pad(p) {}
-};
-
-//  Count digits in an integer of specific base
-template<typename T>
-inline uint8_t digits(T v, int8_t base = 10)
-{
-  uint8_t digits = 0;
-  if ( std::is_signed<T>::value )
-  {
-    if ( v < 0 )
-    {
-      digits++;
-      v = -v; // v needs to be postive for the digits counter to work
-    }
-  }
-  do
-  {
-    v /= base;
-    digits++;
-  } while( v > 0 );
-  return digits;
-}
-
-// Generic get the width of a value in base 10
-template<typename T>
-inline uint8_t get_value_width(T val)
-{ return digits(val); }
-
-inline uint8_t get_value_width(const char * val)
-{ return strlen(val); }
-
-#ifdef ARDUINO
-inline uint8_t get_value_width(const __FlashStringHelper * val)
-{ return strlen_P(reinterpret_cast<const char *>(val)); }
-#endif
-
-// _BASED<T> get the width of a value
-template<typename T>
-inline uint8_t get_value_width(_BASED<T> b)
-{ return digits(b.val, b.base); }
-
-// Constructor wrapper to allow automatic template parameter deduction
-template<typename T>
-__WIDTH<T> _WIDTH(T val, int8_t width) { return __WIDTH<T>(val, width, ' '); }
-template<typename T>
-__WIDTH<T> _WIDTHZ(T val, int8_t width) { return __WIDTH<T>(val, width, '0'); }
-
-
-// Operator overload to handle width printing.
-template<typename T>
-inline Print &operator <<(Print &stm, const __WIDTH<T> &arg)
-{ stm << _PAD(arg.width - get_value_width(arg.val), arg.pad) << arg.val; return stm; }
-
-// explicit Operator overload to handle width printing of _FLOAT, double and float
-template<typename T>
-inline Print &pad_float(Print &stm, const __WIDTH<T> &arg, const double val, const int digits = 2) // see Print::print(double, int = 2)
-{
-  PrintBuffer<32> buf; // it's only ~45B on the stack, no allocation, leak or fragmentation
-  size_t size = buf.print(val, digits); // print in buf
-  return stm << _PAD(arg.width - size, arg.pad) << buf(); // pad and concat what's in buf
-}
-
-inline Print &operator <<(Print &stm, const __WIDTH<float>  &arg) 
-{ return pad_float(stm, arg, arg.val); }
-
-inline Print &operator <<(Print &stm, const __WIDTH<double> &arg) 
-{ return pad_float(stm, arg, arg.val); } 
-
-inline Print &operator <<(Print &stm, const __WIDTH<_FLOAT> &arg) 
-{ auto& f = arg.val; return pad_float(stm, arg, f.val, f.digits); }
-
-// a less verbose _FLOATW for _WIDTH(_FLOAT)
-#define _FLOATW(val, digits, width) _WIDTH<_FLOAT>(_FLOAT((val), (digits)), (width))
-
-// Specialization for replacement formatting
-//
-//  Designed to be similar to printf that everyone knows and loves/hates. But without
-//  the internal buffers and type agnosticism. This version only has placeholders in
-//  the format string, the actual values are supplied using the stream safe operators
-//  defined in this library.
-//
-//  Use like this:
-//
-//      Serial << FMT(F("Replace % with %"), 1, 2 )
-//      Serial << FMT("Time is %:%:%", _WIDTHZ(hours,2), _WIDTHZ(minutes,2), _WIDTHZ(seconds,2))
-//      Serial << FMT("Your score is %\\%", score);   // Note the \\ to escape the % sign
-
-// Ok, hold your hats. This is a foray into C++11's variadic template engine ...
-
-inline char get_next_format_char(const char *& format_string)
-{
-  char format_char = *format_string;
-  if ( format_char > 0 ) format_string++;
-  return format_char;
-}
-
-#ifdef ARDUINO
-inline char get_next_format_char(const __FlashStringHelper*& format_string)
-{
-  char format_char = pgm_read_byte(format_string);
-  if ( format_char > 0 ) format_string = reinterpret_cast<const __FlashStringHelper*>(reinterpret_cast<const char *>(format_string)+1);
-  return format_char;
-}
-#endif
-
-template<typename Ft>
-inline bool check_backslash(char& format_char, Ft& format_string)
-{
-  if ( format_char == '\\')
-  {
-    format_char = get_next_format_char(format_string);
-    return true;
-  }
-  return false;
-}
-
-// The template tail printer helper
-template<typename Ft, typename... Ts>
-struct __FMT
-{
-  Ft format_string;
-  __FMT(Ft f, Ts ... args) : format_string(f) {}
-  inline void tstreamf(Print& stm, Ft format) const
-  {
-    while(char c = get_next_format_char(format))
-    {
-      check_backslash(c, format);
-      if ( c )
-        stm.print(c);
-    }
-  }
-};
-
-// The variadic template helper
-template<typename Ft, typename T, typename... Ts>
-struct __FMT<Ft, T, Ts...> : __FMT<Ft, Ts...>
-{
-  T val;
-  __FMT(Ft f, T t, Ts... ts) : __FMT<Ft, Ts...>(f, ts...), val(t) {}
-  inline void tstreamf(Print& stm, Ft format) const
-  {
-    while(char c = get_next_format_char(format))
-    {
-      if (!check_backslash(c, format))
-      {
-        if ( c == '%')
-        {
-          stm << val;
-          // Variadic recursion ... compiler rolls this out during 
-          // template argument pack expansion
-          __FMT<Ft, Ts...>::tstreamf(stm, format);
-          return;
-        }
-      }
-      if (c)
-        stm.print(c);
-    }
-  }
-};
-
-// The actual operator should you only instanciate the FMT 
-// helper with a format string and no parameters
-template<typename Ft, typename... Ts>
-inline Print& operator <<(Print &stm, const __FMT<Ft, Ts...> &args)
-{
-    args.tstreamf(stm, args.format_string);
-    return stm;
-}
-
-// The variadic stream helper
-template<typename Ft, typename T, typename... Ts>
-inline Print& operator <<(Print &stm, const __FMT<Ft, T, Ts...> &args)
-{
-    args.tstreamf(stm, args.format_string);
-    return stm;
-}
-
-// As we don't have C++17, we can't get a constructor to use
-// automatic argument deduction, but ... this little trick gets
-// around that ...
-template<typename Ft, typename... Ts>
-__FMT<Ft, Ts...> _FMT(Ft format, Ts ... args) { return __FMT<Ft, Ts...>(format, args...); }
-
-#endif

src/StringIndexer.h

@@ -1,8 +1,8 @@
+// vim: ts=2 sw=2 expandtab
 #pragma once
 #include <map>
 #include <string>
 #include <string.h>
-#include <ESP8266WiFi.h>
 
 /***
  * Allows to store up to 255 different strings with one byte class
@@ -10,112 +10,124 @@
  */
 class StringIndexer
 {
-	class StringCounter
+  class StringCounter
-	{
+  {
-		std::string str;
+    std::string str;
-		uint8_t used=0;
+    uint8_t used=0;
-		friend class StringIndexer;
+    friend class StringIndexer;
 
-		#if EPOXY_DUINO
+    #if EPOXY_DUINO
-		public:
+    public:
-		// Workaround to avoid coredump in Indexer::release
+    // Workaround to avoid coredump in Indexer::release
-		// when destroying a Topic after the deletion of
+    // when destroying a Topic after the deletion of
-		// StringIndexer::strings map (which can occurs only with AUnit,
+    // StringIndexer::strings map (which can occurs only with AUnit,
-		// never in the ESP itself, because ESP never ends)
+    // never in the ESP itself, because ESP never ends)
-		// (I hate static vars)
+    // (I hate static vars)
-		~StringCounter() { used=255; }
+    ~StringCounter() { used=255; }
-		#endif
+    #endif
-	};
+  };
-	public:
+  public:
-		using index_t=uint8_t;
+    using index_t = uint8_t;
 
-		static const index_t strToIndex(const char* str, uint8_t len)
+   static const std::string& str(const index_t& index)
-		{
+    {
-			for(auto it=strings.begin(); it!=strings.end(); it++)
+      static std::string dummy;
-			{
+      const auto& it=strings.find(index);
-				if (strncmp(it->second.str.c_str(), str, len)==0)
+      if (it == strings.end()) return dummy;
-				{
+      return it->second.str;
-					it->second.used++;
+    }
-					return it->first;
-				}
-			}
-			for(index_t index=0; index<255; index++)
-			{
-				if (strings.find(index)==strings.end())
-				{
-					strings[index].str = std::string(str, len);
-					strings[index].used++;
-					// Serial << "Creating index " << index << " for (" << strings[index].str.c_str() << ") len=" << len << endl;
-					return index;
-				}
-			}
-			return 0;	// TODO out of indexes
-		}
 
-		static const std::string& str(const index_t& index)
+    static void use(const index_t& index)
-		{
+    {
-			static std::string dummy;
+      auto it=strings.find(index);
-			const auto& it=strings.find(index);
+      if (it != strings.end()) it->second.used++;
-			if (it == strings.end()) return dummy;
+    }
-			return it->second.str;
-		}
 
-		static void use(const index_t& index)
+    static void release(const index_t& index)
-		{
+    {
-			auto it=strings.find(index);
+      auto it=strings.find(index);
-			if (it != strings.end()) it->second.used++;
+      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 void release(const index_t& index)
+    static uint16_t count() { return strings.size(); }
-		{
-			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;
-				}
-			}
-		}
 
-	private:
+  private:
-		static std::map<index_t, StringCounter> strings;
+    friend class IndexedString;
+
+    // increment use of str or create a new index
+    static index_t strToIndex(const char* str, uint8_t len)
+    {
+      for(auto it=strings.begin(); it!=strings.end(); it++)
+      {
+        if (it->second.str.length() == len && strcmp(it->second.str.c_str(), str)==0)
+        {
+          it->second.used++;
+          return it->first;
+        }
+      }
+      for(index_t index=1; index; index++)
+      {
+        if (strings.find(index)==strings.end())
+        {
+          strings[index].str = std::string(str, len);
+          strings[index].used++;
+          // Serial << "Creating index " << index << " for (" << strings[index].str.c_str() << ") len=" << len << endl;
+          return index;
+        }
+      }
+      return 0;  // TODO out of indexes
+    }
+
+    static std::map<index_t, StringCounter> strings;
 };
 
 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 std::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 std::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,265 +1,363 @@
-#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"
-#include <MqttStreaming.h>
 
-#if 0
+#define TINY_MQTT_DEFAULT_CLIENT_ID "Tiny"
-  #define debug(what) { Serial << __LINE__ << ' ' << what << endl; delay(100); }
+
-  #define TINY_MQTT_DEBUG 1
+#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 TINY_MQTT_DEBUG 0
   #define debug(what) {}
 #endif
 
-enum MqttError
+#ifdef TINY_MQTT_ASYNC
+  using TcpClient = AsyncClient;
+  using TcpServer = AsyncServer;
+#else
+  using TcpClient = WiFiClient;
+  using TcpServer = WiFiServer;
+#endif
+
+enum __attribute__((packed)) MqttError
 {
-	MqttOk = 0,
+  MqttOk = 0,
-	MqttNowhereToSend=1,
+  MqttNowhereToSend=1,
-	MqttInvalidMessage=2,
+  MqttInvalidMessage=2,
 };
 
 class Topic : public IndexedString
 {
-	public:
+  public:
-		Topic(const char* s, uint8_t len) : IndexedString(s,len){}
+    Topic(const char* s, uint8_t len) : IndexedString(s,len){}
-		Topic(const char* s) : Topic(s, strlen(s)) {}
+    Topic(const char* s) : Topic(s, strlen(s)) {}
-		Topic(const std::string s) : Topic(s.c_str(), s.length()){};
+    Topic(const std::string s) : Topic(s.c_str(), s.length()){};
 
-		const char* c_str() const { return str().c_str(); }
+    const char* c_str() const { return str().c_str(); }
 
-		bool matches(const Topic&) const;
+    bool matches(const Topic&) const;
 };
 
 class MqttClient;
 class MqttMessage
 {
-	const uint16_t MaxBufferLength = 255;
+  const uint16_t MaxBufferLength = 4096;  //hard limit: 16k due to size decoding
-	public:
+  public:
-		enum Type
+    enum __attribute__((packed)) Type
-		{
+    {
-			Unknown     =    0,
+      Unknown     =    0,
-			Connect     = 0x10,
+      Connect     = 0x10,
-			ConnAck     = 0x20,
+      ConnAck     = 0x20,
-			Publish     = 0x30,
+      Publish     = 0x30,
-			PubAck      = 0x40,
+      PubAck      = 0x40,
-			Subscribe   = 0x80,
+      Subscribe   = 0x80,
-			SubAck      = 0x90,
+      SubAck      = 0x90,
-			UnSubscribe = 0xA0,
+      UnSubscribe = 0xA0,
-			PingReq     = 0xC0,
+      UnSuback    = 0xB0,
-			PingResp    = 0xD0,
+      PingReq     = 0xC0,
-			Disconnect  = 0xE0
+      PingResp    = 0xD0,
-		};
+      Disconnect  = 0xE0
-		enum State
+    };
-		{
-			FixedHeader=0,
-			Length=1,
-			VariableHeader=2,
-			PayLoad=3,
-			Complete=4,
-			Error=5,
-			Create=6
-		};
 
-		MqttMessage() { reset(); }
+    enum __attribute__((packed)) State
-		MqttMessage(Type t, uint8_t bits_d3_d0=0) { create(t); buffer[0] |= bits_d3_d0; }
+    {
-		void incoming(char byte);
+      FixedHeader=0,
-		void add(char byte) { incoming(byte); }
+      Length=1,
-		void add(const char* p, size_t len, bool addLength=true );
+      VariableHeader=2,
-		void add(const std::string& s) { add(s.c_str(), s.length()); }
+      PayLoad=3,
-		void add(const Topic& t) { add(t.str()); }
+      Complete=4,
-		const char* end() const { return &buffer[0]+buffer.size(); }
+      Error=5,
-		const char* getVHeader() const { return &buffer[vheader]; }
+      Create=6
-		uint16_t length() const { return buffer.size(); }
+    };
 
-		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; }
-		static void getString(const 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 std::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=(char)type;
+      return state == Complete ? static_cast<Type>(buffer[0] & 0xF0) : Unknown;
-			buffer+='\0';
+    }
-			vheader=2;
-			size=0;
-			state=Create;
-		}
-		MqttError sendTo(MqttClient*);
-		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);
 
-		std::string buffer;
+    void create(Type type)
-		uint8_t vheader;
+    {
-		uint16_t size;	// bytes left to receive
+      buffer=(decltype(buffer)::value_type)type;
-		State state;
+      buffer+='\0';    // reserved for msg length byte 1/2
+      buffer+='\0';    // reserved for msg length byte 2/2 (fixed)
+      vheader=3;      // Should never change
+      size=0;
+      state=Create;
+    }
+    MqttError sendTo(MqttClient*);
+    void hexdump(const char* prefix=nullptr) const;
+
+  private:
+    void encodeLength();
+
+    std::string buffer;
+    uint8_t vheader;
+    uint16_t size;  // bytes left to receive
+    State state;
 };
 
 class MqttBroker;
 class MqttClient
 {
-	using CallBack = void (*)(const MqttClient* source, const Topic& topic, const char* payload, size_t payload_length);
+  enum __attribute__((packed)) Flags
-	enum Flags
+  {
-	{
+    FlagUserName = 128,
-		FlagUserName = 128,
+    FlagPassword = 64,
-		FlagPassword = 64,
+    FlagWillRetain = 32,   // unsupported
-		FlagWillRetain = 32,	// unsupported
+    FlagWillQos = 16 | 8,  // unsupported
-		FlagWillQos = 16 | 8, // unsupported
+    FlagWill = 4,          // unsupported
-		FlagWill = 4,			    // unsupported
+    FlagCleanSession = 2,  // unsupported
-		FlagCleanSession = 2,	// unsupported
+    FlagReserved = 1
-		FlagReserved = 1
+  };
-	};
+  public:
-	public:
-		MqttClient(MqttBroker* brk = nullptr, const std::string& id="");
-		MqttClient(const std::string& id) : MqttClient(nullptr, id){}
 
-		~MqttClient();
+    using CallBack = void (*)(const MqttClient* source, const Topic& topic, const char* payload, size_t payload_length);
 
-		void connect(MqttBroker* parent);
+    /** Constructor. Broker is the adress of a local broker if not null
-		void connect(std::string broker, uint16_t port, uint16_t ka=10);
+        If you want to connect elsewhere, leave broker null and use connect() **/
+    MqttClient(MqttBroker* broker = nullptr, const std::string& id = TINY_MQTT_DEFAULT_CLIENT_ID);
+    MqttClient(const std::string& id) : MqttClient(nullptr, id){}
 
-		bool connected() { return
+    ~MqttClient();
-			(parent!=nullptr and client==nullptr) or
-			(client and client->connected()); }
-		void write(const char* buf, size_t length)
-		{ if (client) client->write(buf, length); }
 
-		const std::string& id() const { return clientId; }
+    void connect(MqttBroker* local_broker);
-		void id(std::string& new_id) { clientId = new_id; }
+    void connect(std::string broker, uint16_t port, uint16_t keep_alive = 10);
 
-		void loop();
+    // TODO it seems that connected returns true in tcp mode even if
-		void close(bool bSendDisconnect=true);
+    // no negociation occurred
-		void setCallback(CallBack fun) {callback=fun; };
+    bool connected()
+    {
+      return (local_broker!=nullptr and client==nullptr) or (client and client->connected());
+    }
 
-		// Publish from client to the world
+    void write(const char* buf, size_t length)
-		MqttError publish(const Topic&, const char* payload, size_t pay_length);
+    {
-		MqttError publish(const Topic& t, const String& s) { return publish(t, s.c_str(), s.length()); }
+      if (client) client->write(buf, length);
-		MqttError publish(const Topic& t, const std::string& s) { return publish(t,s.c_str(),s.length());}
+    }
-		MqttError publish(const Topic& t) { return publish(t, nullptr, 0);};
 
-		MqttError subscribe(Topic topic, uint8_t qos=0);
+    const std::string& id() const { return clientId; }
-		MqttError unsubscribe(Topic topic);
+    void id(const std::string& new_id) { clientId = new_id; }
 
-		// connected to local broker
+    /** Should be called in main loop() */
-		// TODO seems to be useless
+    void loop();
-		bool isLocal() const { return client == nullptr; }
+    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
+    };
 
-		void dump()
+    // Publish from client to the world
-		{
+    MqttError publish(const Topic&, const char* payload, size_t pay_length);
-			uint32_t ms=millis();
+    MqttError publish(const Topic& t, const char* payload) { return publish(t, payload, strlen(payload)); }
-			Serial << "MqttClient (" << clientId.c_str() << ") " << (connected() ? " ON " : " OFF");
+    MqttError publish(const Topic& t, const String& s) { return publish(t, s.c_str(), s.length()); }
-			Serial << ", alive=" << alive << '/' << ms << ", ka=" << keep_alive;
+    MqttError publish(const Topic& t, const std::string& s) { return publish(t,s.c_str(),s.length());}
-			Serial << (client && client->connected() ? "" : "dis") << "connected";
+    MqttError publish(const Topic& t) { return publish(t, nullptr, 0);};
-            message.hexdump("entrant msg");
-			bool c=false;
-			Serial << " [";
-			for(auto s: subscriptions)
-			{
-				Serial << (c?", ": "")<< s.str().c_str();
-				c=true;
-			}
 
+    MqttError subscribe(Topic topic, uint8_t qos=0);
+    MqttError unsubscribe(Topic topic);
+    bool isSubscribedTo(const Topic& topic) const;
 
-			Serial << "]" << endl;
+    // connected to local broker
-		}
+    // TODO seems to be useless
+    bool isLocal() const { return client == nullptr; }
 
-		static long counter;	// Number of messages sent
+    void dump(std::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 (client)
+        {
+          if (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
+    }
 
-	private:
+#ifdef EPOXY_DUINO
-		MqttError sendTopic(const Topic& topic, MqttMessage::Type type, uint8_t qos);
+    static std::map<MqttMessage::Type, int> counters;  // Number of processed messages
-		void resubscribe();
+#endif
+    uint32_t keepAlive() const { return keep_alive; }
 
-		friend class MqttBroker;
+  private:
-		MqttClient(MqttBroker* parent, WiFiClient& client);
-		// republish a received publish if topic matches any in subscriptions
-		MqttError publish(const Topic& topic, MqttMessage& msg);
 
-		void clientAlive(uint32_t more_seconds);
+    // event when tcp/ip link established (real or fake)
-		void processMessage();
+    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();
 
-		bool mqtt_connected = false;
+    friend class MqttBroker;
-		char mqtt_flags;
+    MqttClient(MqttBroker* local_broker, TcpClient* client);
-		uint32_t keep_alive;
+    // republish a received publish if topic matches any in subscriptions
-		uint32_t alive;
+    MqttError publishIfSubscribed(const Topic& topic, MqttMessage& msg);
-		MqttMessage message;
 
-		// TODO	having a pointer on MqttBroker may produce larger binaries
+    void clientAlive(uint32_t more_seconds);
-		// due to unecessary function linked if ever parent is not used
+    void processMessage(MqttMessage* message);
-		// (this is the case when MqttBroker isn't used except here)
-		MqttBroker* parent=nullptr;		// connection to local broker
 
-		WiFiClient* client=nullptr;		// connection to mqtt client or to remote broker
+    bool mqtt_connected = false;
-		std::set<Topic>	subscriptions;
+    char mqtt_flags;
-		std::string clientId;
+    uint32_t keep_alive = 30;
-		CallBack callback = nullptr;
+    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* client=nullptr;    // connection to remote broker
+    std::set<Topic>  subscriptions;
+    std::string clientId;
+    CallBack callback = nullptr;
 };
 
 class MqttBroker
 {
-	enum State
+  enum __attribute__((packed)) State
-	{
+  {
-		Disconnected,	// Also the initial state
+    Disconnected,  // Also the initial state
-		Connecting,		// connect and sends a fake publish to avoid circular cnx
+    Connecting,    // connect and sends a fake publish to avoid circular cnx
-		Connected,		// this->broker is connected and circular cnx avoided
+    Connected,    // this->broker is connected and circular cnx avoided
-	};
+  };
-	public:
+  public:
-	  // TODO limit max number of clients
+    // TODO limit max number of clients
-		MqttBroker(uint16_t port);
+    MqttBroker(uint16_t port);
-		~MqttBroker();
+    ~MqttBroker();
 
-		void begin() { server.begin(); }
+    void begin() { server->begin(); }
-		void loop();
+    void loop();
 
-		uint16_t port() const { return server.port(); }
+    void connect(const std::string& host, uint16_t port=1883);
+    bool connected() const { return state == Connected; }
 
-		void connect(std::string host, uint16_t port=1883);
+    size_t clientsCount() const { return clients.size(); }
-		bool connected() const { return state == Connected; }
 
-		size_t clientsCount() const { return clients.size(); }
+    void dump(std::string indent="")
+    {
+      for(auto client: clients)
+        client->dump(indent);
+    }
 
-		void dump()
+    const std::vector<MqttClient*>  getClients() const { return clients; }
-		{
-			Serial << clients.size() << " client/s" << endl;
-			for(auto client: clients)
-			{
-				Serial << "  ";
-				client->dump();
-			}
-		}
 
-	private:
+  private:
-		friend class MqttClient;
+    friend class MqttClient;
 
-		bool checkUser(const char* user, uint8_t len) const
+    static void onClient(void*, TcpClient*);
-		{ return compareString(auth_user, user, len); }
+    bool checkUser(const char* user, uint8_t len) const
+    { return compareString(auth_user, user, len); }
 
-		bool checkPassword(const char* password, uint8_t len) const
+    bool checkPassword(const char* password, uint8_t len) const
-		{ return compareString(auth_password, password, len); }
+    { return compareString(auth_password, password, len); }
 
 
-		MqttError publish(const MqttClient* source, const Topic& topic, MqttMessage& msg);
+    MqttError publish(const MqttClient* source, const Topic& topic, MqttMessage& msg) const;
 
-		// For clients that are added not by the broker itself
+    MqttError subscribe(const Topic& topic, uint8_t qos);
-		void addClient(MqttClient* client);
-		void removeClient(MqttClient* client);
 
-		bool compareString(const char* good, const char* str, uint8_t str_len) const;
+    // For clients that are added not by the broker itself (local clients)
-		std::vector<MqttClient*>	clients;
+    void addClient(MqttClient* client);
-		WiFiServer server;
+    void removeClient(MqttClient* client);
 
-		const char* auth_user = "guest";
+    bool compareString(const char* good, const char* str, uint8_t str_len) const;
-		const char* auth_password = "guest";
+    std::vector<MqttClient*>  clients;
-		State state = Disconnected;
 
-		MqttClient* broker = nullptr;
+  private:
+    TcpServer* server = nullptr;
+
+    const char* auth_user = "guest";
+    const char* auth_password = "guest";
+    MqttClient* broker = nullptr;
+
+    State state = Disconnected;
 };

src/my_credentials.h

@@ -1,2 +0,0 @@
-const char *ssid     = "YOUR-SSID-HERE";
-const char *password = "YOUR-PASSWORD-HERE";

tests/Makefile

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

tests/classbind-tests/classbind-tests.ino

@@ -0,0 +1,351 @@
+// 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 */)
+    {
+      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)
+{
+  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("=============[ FAKE NETWORK TinyMqtt TESTS       ]========================");
+
+  WiFi.mode(WIFI_STA);
+  WiFi.begin("network", "password");
+}
+
+void loop() {
+  aunit::TestRunner::run();
+
+  if (Serial.available()) ESP.reset();
+}

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

@@ -1,6 +1,13 @@
 # See https://github.com/bxparks/EpoxyDuino for documentation about this
 # Makefile to compile and run Arduino programs natively on Linux or MacOS.
 
+EXTRA_CXXFLAGS=-g3 -O0
+
+# Remove flto flag from EpoxyDuino (too many <optimized out>)
+CXXFLAGS = -Wextra -Wall -std=gnu++11 -fno-exceptions -fno-threadsafe-statics
+
 APP_NAME := local-tests
-ARDUINO_LIBS := AUnit AceCommon AceTime TinyMqtt EspMock
+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

@@ -1,147 +1,151 @@
+#include <Arduino.h>
 #include <AUnit.h>
 #include <TinyMqtt.h>
 #include <map>
 
 /**
-	* TinyMqtt local unit tests.
+  * TinyMqtt local unit tests.
-	*
+  *
-	* Clients are connected to pseudo remote broker
+  * Clients are connected to pseudo remote broker
-	* The remote will be 127.0.0.1:1883
+  * 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
+  * 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
+  * 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
+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)
+  if (srce)
-		published[srce->id()][topic]++;
+    published[srce->id()][topic]++;
+  lastPayload = payload;
+  lastLength = length;
 }
 
 test(local_client_should_unregister_when_destroyed)
 {
-return;
+  assertEqual(broker.clientsCount(), (size_t)0);
-	assertEqual(broker.clientsCount(), (size_t)0);
+  {
-	{
+    assertEqual(broker.clientsCount(), (size_t)0);  // Ensure client is not yet connected
-		MqttClient client;
+    MqttClient client(&broker);
-		assertEqual(broker.clientsCount(), (size_t)0);	// Ensure client is not yet connected
+    assertEqual(broker.clientsCount(), (size_t)1);  // Ensure client is now connected
-		client.connect("127.0.0.1", 1883);
+  }
-		assertEqual(broker.clientsCount(), (size_t)1);	// Ensure client is now connected
+  assertEqual(broker.clientsCount(), (size_t)0);
-	}
-	assertEqual(broker.clientsCount(), (size_t)0);
 }
 
 #if 0
 test(local_connect)
 {
-	assertEqual(broker.clientsCount(), (size_t)0);
+  assertEqual(broker.clientsCount(), (size_t)0);
 
-	MqttClient client;
+  MqttClient client;
-	assertTrue(client.connected());
+  assertTrue(client.connected());
-	assertEqual(broker.clientsCount(), (size_t)1);
+  assertEqual(broker.clientsCount(), (size_t)1);
 }
 
 test(local_publish_should_be_dispatched)
 {
-	published.clear();
+  published.clear();
-	assertEqual(broker.clientsCount(), (size_t)0);
+  assertEqual(broker.clientsCount(), (size_t)0);
 
-	MqttClient subscriber;
+  MqttClient subscriber;
-	subscriber.subscribe("a/b");
+  subscriber.subscribe("a/b");
-	subscriber.subscribe("a/c");
+  subscriber.subscribe("a/c");
-	subscriber.setCallback(onPublish);
+  subscriber.setCallback(onPublish);
 
-	MqttClient publisher;
+  MqttClient publisher;
-	publisher.publish("a/b");
+  publisher.publish("a/b");
-	publisher.publish("a/c");
+  publisher.publish("a/c");
-	publisher.publish("a/c");
+  publisher.publish("a/c");
 
-	assertEqual(published.size(), (size_t)1);	// 1 client has received something
+  assertEqual(published.size(), (size_t)1);  // 1 client has received something
-	assertTrue(published[""]["a/b"] == 1);
+  assertEqual(published[""]["a/b"], 1);
-	assertTrue(published[""]["a/c"] == 2);
+  assertEqual(published[""]["a/c"], 2);
 }
 
 test(local_publish_should_be_dispatched_to_local_clients)
 {
-	published.clear();
+  published.clear();
-	assertEqual(broker.clientsCount(), (size_t)0);
+  assertEqual(broker.clientsCount(), (size_t)0);
 
-	MqttClient subscriber_a("A");
+  MqttClient subscriber_a("A");
-	subscriber_a.setCallback(onPublish);
+  subscriber_a.setCallback(onPublish);
-	subscriber_a.subscribe("a/b");
+  subscriber_a.subscribe("a/b");
-	subscriber_a.subscribe("a/c");
+  subscriber_a.subscribe("a/c");
 
-	MqttClient subscriber_b("B");
+  MqttClient subscriber_b("B");
-	subscriber_b.setCallback(onPublish);
+  subscriber_b.setCallback(onPublish);
-	subscriber_b.subscribe("a/b");
+  subscriber_b.subscribe("a/b");
 
-	MqttClient publisher;
+  MqttClient publisher;
-	publisher.publish("a/b");
+  publisher.publish("a/b");
-	publisher.publish("a/c");
+  publisher.publish("a/c");
 
-	assertEqual(published.size(), (size_t)2);	// 2 clients have received something
+  assertEqual(published.size(), (size_t)2);  // 2 clients have received something
-	assertTrue(published["A"]["a/b"] == 1);
+  assertEqual(published["A"]["a/b"], 1);
-	assertTrue(published["A"]["a/c"] == 1);
+  assertEqual(published["A"]["a/c"], 1);
-	assertTrue(published["B"]["a/b"] == 1);
+  assertEqual(published["B"]["a/b"], 1);
-	assertTrue(published["B"]["a/c"] == 0);
+  assertEqual(published["B"]["a/c"], 0);
 }
 
 test(local_unsubscribe)
 {
-	published.clear();
+  published.clear();
-	assertEqual(broker.clientsCount(), (size_t)0);
+  assertEqual(broker.clientsCount(), (size_t)0);
 
-	MqttClient subscriber;
+  MqttClient subscriber;
-	subscriber.setCallback(onPublish);
+  subscriber.setCallback(onPublish);
-	subscriber.subscribe("a/b");
+  subscriber.subscribe("a/b");
 
-	MqttClient publisher;
+  MqttClient publisher;
-	publisher.publish("a/b");
+  publisher.publish("a/b");
 
-	subscriber.unsubscribe("a/b");
+  subscriber.unsubscribe("a/b");
 
-	publisher.publish("a/b");
+  publisher.publish("a/b");
-	publisher.publish("a/b");
+  publisher.publish("a/b");
 
-	assertTrue(published[""]["a/b"] == 1);	// Only one publish has been received
+  assertEqual(published[""]["a/b"], 1);  // Only one publish has been received
 }
 
 test(local_nocallback_when_destroyed)
 {
-	published.clear();
+  published.clear();
-	assertEqual(broker.clientsCount(), (size_t)0);
+  assertEqual(broker.clientsCount(), (size_t)0);
 
-	MqttClient publisher;
+  MqttClient publisher;
-	{
+  {
-		MqttClient subscriber;
+    MqttClient subscriber;
-		subscriber.setCallback(onPublish);
+    subscriber.setCallback(onPublish);
-		subscriber.subscribe("a/b");
+    subscriber.subscribe("a/b");
-		publisher.publish("a/b");
+    publisher.publish("a/b");
-	}
+  }
 
-	publisher.publish("a/b");
+  publisher.publish("a/b");
 
-	assertEqual(published.size(), (size_t)1);	// Only one publish has been received
+  assertEqual(published.size(), (size_t)1);  // Only one publish has been received
 }
 #endif
 
 //----------------------------------------------------------------------------
 // setup() and loop()
 void setup() {
-	delay(1000);
+  delay(1000);
-	Serial.begin(115200);
+  Serial.begin(115200);
-	while(!Serial);
+  while(!Serial);
 
-	Serial.println("=============[ NO WIFI CONNECTION TinyMqtt TESTS ]========================");
+  Serial.println("=============[ LOCAL TinyMqtt TESTS              ]========================");
 }
 
 void loop() {
-	aunit::TestRunner::run();
+  aunit::TestRunner::run();
 
-	if (Serial.available()) ESP.reset();
+  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.
+
+EXTRA_CXXFLAGS=-g3 -O0
+
+# Remove flto flag from EpoxyDuino (too many <optimized out>)
+CXXFLAGS = -Wextra -Wall -std=gnu++11 -fno-exceptions -fno-threadsafe-statics
+
+APP_NAME := network-tests
+ARDUINO_LIBS := AUnit AceCommon AceTime TinyMqtt EspMock ESP8266WiFi  ESPAsyncTCP TinyConsole
+ARDUINO_LIB_DIRS := ../../../EspMock/libraries
+EPOXY_CORE := EPOXY_CORE_ESP8266
+include ../../../EpoxyDuino/EpoxyDuino.mk

tests/network-tests/network-tests.ino

@@ -0,0 +1,466 @@
+// 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
+  **/
+
+// if ascii_pos = 0, no ascii dump, else ascii dump starts after column ascii_pos
+std::string bufferToHexa(const uint8_t* buffer, size_t length, char sep = 0, size_t ascii_pos = 0)
+{
+  std::stringstream out;
+  std::string ascii;
+  std::string h("0123456789ABCDEF");
+  for(size_t i=0; i<length; i++)
+  {
+    uint8_t c = buffer[i];
+    out << h[ c >> 4] << h[ c & 0x0F ];
+    if (sep) out << sep;
+    if (ascii_pos)
+    {
+      if (c>=32)
+        ascii += c;
+      else
+        ascii +='.';
+    }
+  }
+  std::string ret(out.str());
+  if (ascii_pos)
+  {
+    while(ret.length() < ascii_pos)
+      ret += ' ';
+    ret +='[' + ascii + ']';
+  }
+  return ret;
+}
+
+void dumpMqttMessage(const uint8_t* buffer, size_t length)
+{
+  std::map<int, std::string> pkt =
+  { { MqttMessage::Unknown     , "Unknown     " },
+    { MqttMessage::Connect     , "Connect     " },
+    { MqttMessage::ConnAck     , "ConnAck     " },
+    { MqttMessage::Publish     , "Publish     " },
+    { MqttMessage::PubAck      , "PubAck      " },
+    { MqttMessage::Subscribe   , "Subscribe   " },
+    { MqttMessage::SubAck      , "SubAck      " },
+    { MqttMessage::UnSubscribe , "Unsubscribe " },
+    { MqttMessage::UnSuback    , "UnSubAck    " },
+    { MqttMessage::PingReq     , "PingReq     " },
+    { MqttMessage::PingResp    , "PingResp    " },
+    { MqttMessage::Disconnect  , "Disconnect  " } };
+
+  std::cout << "       |   data sent " << std::setw(3) << length << " : ";
+  auto it = pkt.find(buffer[0] & 0xF0);
+  if (it == pkt.end())
+    std::cout << pkt[MqttMessage::Unknown];
+  else
+    std::cout << it->second;
+
+  std::cout << bufferToHexa(buffer, length, ' ', 60) << std::endl;
+}
+
+String toString(const IPAddress& ip)
+{
+  return String(ip[0])+'.'+String(ip[1])+'.'+String(ip[2])+'.'+String(ip[3]);
+}
+
+MqttBroker broker(1883);
+
+std::map<std::string, std::map<Topic, int>>  published;    // map[client_id] => map[topic] = count
+
+char* lastPayload = nullptr;
+size_t lastLength;
+
+void start_servers(int n, bool early_accept = true)
+{
+    ESP8266WiFiClass::resetInstances();
+    ESP8266WiFiClass::earlyAccept = early_accept;
+    while(n)
+    {
+      ESP8266WiFiClass::selectInstance(n--);
+      WiFi.mode(WIFI_STA);
+      WiFi.begin("fake_ssid", "fake_pwd");
+    }
+}
+
+void onPublish(const MqttClient* srce, const Topic& topic, const char* payload, size_t length)
+{
+  if (srce)
+    published[srce->id()][topic]++;
+  
+  if (lastPayload) free(lastPayload);
+  lastPayload = strdup(payload);
+  lastLength = length;
+}
+
+test(network_single_broker_begin)
+{
+  assertEqual(WiFi.status(), WL_CONNECTED);
+
+  MqttBroker broker(1883);
+  broker.begin();
+
+  // TODO Nothing is tested here !
+}
+
+test(suback)
+{
+  start_servers(2, true);
+  assertEqual(WiFi.status(), WL_CONNECTED);
+
+  MqttBroker broker(1883);
+  broker.begin();
+  IPAddress broker_ip = WiFi.localIP();
+
+  ESP8266WiFiClass::selectInstance(2);
+  MqttClient client;
+  client.connect(broker_ip.toString().c_str(), 1883);
+  broker.loop();
+
+  assertTrue(broker.clientsCount() == 1);
+  assertTrue(client.connected());
+
+  MqttClient::counters[MqttMessage::Type::SubAck] = 0;
+  client.subscribe("a/b");
+
+  // TODO how to avoid these loops ???
+  broker.loop();
+  client.loop();
+
+  assertEqual(MqttClient::counters[MqttMessage::Type::SubAck], 1);
+}
+
+test(network_client_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(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();
+}

tests/nowifi-tests/Makefile

@@ -1,6 +1,13 @@
 # See https://github.com/bxparks/EpoxyDuino for documentation about this
 # Makefile to compile and run Arduino programs natively on Linux or MacOS.
 
+EXTRA_CXXFLAGS=-g3 -O0
+
+# Remove flto flag from EpoxyDuino (too many <optimized out>)
+CXXFLAGS = -Wextra -Wall -std=gnu++11 -fno-exceptions -fno-threadsafe-statics
+
 APP_NAME := nowifi-tests
-ARDUINO_LIBS := AUnit AceCommon AceTime TinyMqtt EspMock
+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

@@ -1,141 +1,282 @@
+// 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.
+  * No wifi connection unit tests.
-    * Checks with a local broker. Clients must connect to the local client
+  * Checks with a local broker. Clients must connect to the local broker
-	**/
+  **/
 
 using namespace std;
 
 MqttBroker broker(1883);
 
-std::map<std::string, std::map<Topic, int>>	published;		// map[client_id] => map[topic] = count
+std::map<std::string, std::map<Topic, int>>  published;    // map[client_id] => map[topic] = count
+
+char* lastPayload = nullptr;
+size_t lastLength;
 
 void onPublish(const MqttClient* srce, const Topic& topic, const char* payload, size_t length)
 {
-	if (srce)
+  if (srce)
-		published[srce->id()][topic]++;
+    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);
+  assertEqual(broker.clientsCount(), (size_t)0);
-	{
+  {
-		MqttClient client(&broker);
+    MqttClient client(&broker);
-		assertEqual(broker.clientsCount(), (size_t)1);
+    assertEqual(broker.clientsCount(), (size_t)1);
-	}
+  }
-	assertEqual(broker.clientsCount(), (size_t)0);
+  assertEqual(broker.clientsCount(), (size_t)0);
 }
 
 test(nowifi_connect)
 {
-	assertEqual(broker.clientsCount(), (size_t)0);
+  assertEqual(broker.clientsCount(), (size_t)0);
 
-	MqttClient client(&broker);
+  MqttClient client(&broker);
-	assertTrue(client.connected());
+  assertTrue(client.connected());
-	assertEqual(broker.clientsCount(), (size_t)1);
+  assertEqual(broker.clientsCount(), (size_t)1);
 }
 
 test(nowifi_publish_should_be_dispatched)
 {
-	published.clear();
+  published.clear();
-	assertEqual(broker.clientsCount(), (size_t)0);
+  assertEqual(broker.clientsCount(), (size_t)0);
 
-	MqttClient subscriber(&broker);
+  MqttClient subscriber(&broker);
-	subscriber.subscribe("a/b");
+  subscriber.subscribe("a/b");
-	subscriber.subscribe("a/c");
+  subscriber.subscribe("a/c");
-	subscriber.setCallback(onPublish);
+  subscriber.setCallback(onPublish);
 
-	MqttClient publisher(&broker);
+  MqttClient publisher(&broker);
-	publisher.publish("a/b");
+  publisher.publish("a/b");
-	publisher.publish("a/c");
+  publisher.publish("a/c");
-	publisher.publish("a/c");
+  publisher.publish("a/c");
 
-	assertEqual(published.size(), (size_t)1);	// 1 client has received something
+  assertEqual(published.size(), (size_t)1);  // 1 client has received something
-	assertTrue(published[""]["a/b"] == 1);
+  assertEqual(published[TINY_MQTT_DEFAULT_CLIENT_ID]["a/b"], 1);
-	assertTrue(published[""]["a/c"] == 2);
+  assertEqual(published[TINY_MQTT_DEFAULT_CLIENT_ID]["a/c"], 2);
 }
 
-test(nowifi_publish_should_be_dispatched_to_nowifi_clients)
+test(nowifi_publish_should_be_dispatched_to_clients)
 {
-	published.clear();
+  published.clear();
-	assertEqual(broker.clientsCount(), (size_t)0);
+  assertEqual(broker.clientsCount(), (size_t)0);
 
-	MqttClient subscriber_a(&broker, "A");
+  MqttClient subscriber_a(&broker, "A");
-	subscriber_a.setCallback(onPublish);
+  subscriber_a.setCallback(onPublish);
-	subscriber_a.subscribe("a/b");
+  subscriber_a.subscribe("a/b");
-	subscriber_a.subscribe("a/c");
+  subscriber_a.subscribe("a/c");
 
-	MqttClient subscriber_b(&broker, "B");
+  MqttClient subscriber_b(&broker, "B");
-	subscriber_b.setCallback(onPublish);
+  subscriber_b.setCallback(onPublish);
-	subscriber_b.subscribe("a/b");
+  subscriber_b.subscribe("a/b");
 
-	MqttClient publisher(&broker);
+  MqttClient publisher(&broker);
-	publisher.publish("a/b");
+  publisher.publish("a/b");    // A and B should receive this
-	publisher.publish("a/c");
+  publisher.publish("a/c");    // A should receive this 
 
-	assertEqual(published.size(), (size_t)2);	// 2 clients have received something
+  assertEqual(published.size(), (size_t)2);  // 2 clients have received something
-	assertTrue(published["A"]["a/b"] == 1);
+  assertEqual(published["A"]["a/b"], 1);
-	assertTrue(published["A"]["a/c"] == 1);
+  assertEqual(published["A"]["a/c"], 1);
-	assertTrue(published["B"]["a/b"] == 1);
+  assertEqual(published["B"]["a/b"], 1);
-	assertTrue(published["B"]["a/c"] == 0);
+  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();
+  published.clear();
-	assertEqual(broker.clientsCount(), (size_t)0);
+  assertEqual(broker.clientsCount(), (size_t)0);
 
-	MqttClient subscriber(&broker);
+  MqttClient subscriber(&broker);
-	subscriber.setCallback(onPublish);
+  subscriber.setCallback(onPublish);
-	subscriber.subscribe("a/b");
+  subscriber.subscribe("a/b");
 
-	MqttClient publisher(&broker);
+  MqttClient publisher(&broker);
-	publisher.publish("a/b");
+  publisher.publish("a/b");    // This publish is received
 
-	subscriber.unsubscribe("a/b");
+  subscriber.unsubscribe("a/b");
 
-	publisher.publish("a/b");
+  publisher.publish("a/b");    // Those one, no (unsubscribed)
-	publisher.publish("a/b");
+  publisher.publish("a/b");
 
-	assertTrue(published[""]["a/b"] == 1);	// Only one publish has been received
+  assertEqual(published[TINY_MQTT_DEFAULT_CLIENT_ID]["a/b"], 1);  // Only one publish has been received
 }
 
 test(nowifi_nocallback_when_destroyed)
 {
-	published.clear();
+  published.clear();
-	assertEqual(broker.clientsCount(), (size_t)0);
+  assertEqual(broker.clientsCount(), (size_t)0);
 
-	MqttClient publisher(&broker);
+  MqttClient publisher(&broker);
 
-	{
+  {
-		MqttClient subscriber(&broker);
+    MqttClient subscriber(&broker);
-		subscriber.setCallback(onPublish);
+    subscriber.setCallback(onPublish);
-		subscriber.subscribe("a/b");
+    subscriber.subscribe("a/b");
-		publisher.publish("a/b");
+    publisher.publish("a/b");
-	}
+  }
 
-	publisher.publish("a/b");
+  publisher.publish("a/b");
 
-	assertEqual(published.size(), (size_t)1);	// Only one publish has been received
+  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);
+  delay(1000);
-	Serial.begin(115200);
+  Serial.begin(115200);
-	while(!Serial);
+  while(!Serial);
 
-	Serial.println("=============[ NO WIFI CONNECTION TinyMqtt TESTS ]========================");
+  Serial.println("=============[ NO WIFI CONNECTION TinyMqtt TESTS ]========================");
 }
 
 void loop() {
-	aunit::TestRunner::run();
+  aunit::TestRunner::run();
 
-	if (Serial.available()) ESP.reset();
+  if (Serial.available()) ESP.reset();
 }

tests/string-indexer-tests/Makefile

@@ -0,0 +1,10 @@
+# See https://github.com/bxparks/EpoxyDuino for documentation about this
+# Makefile to compile and run Arduino programs natively on Linux or MacOS.
+
+EXTRA_CXXFLAGS=-g3 -O0
+
+APP_NAME := string-indexer-tests
+ARDUINO_LIBS := AUnit AceCommon AceTime TinyMqtt EspMock ESP8266WiFi  ESPAsync 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 namespace std;
+
+test(indexer_empty)
+{
+  assertEqual(StringIndexer::count(), 0);
+}
+
+test(indexer_strings_deleted_should_empty_indexer)
+{
+  assertTrue(StringIndexer::count()==0);
+  {
+    IndexedString one("one");
+    assertEqual(StringIndexer::count(), 1);
+    IndexedString two("two");
+    assertEqual(StringIndexer::count(), 2);
+    IndexedString three("three");
+    assertEqual(StringIndexer::count(), 3);
+    IndexedString four("four");
+    assertEqual(StringIndexer::count(), 4);
+  }
+  assertEqual(StringIndexer::count(), 0);
+}
+
+test(indexer_same_strings_count_as_one)
+{
+  IndexedString one  ("one");
+  IndexedString two  ("one");
+  IndexedString three("one");
+  IndexedString fourt("one");
+
+  assertEqual(StringIndexer::count(), 1);
+}
+
+test(indexer_size_of_indexed_string)
+{
+  assertEqual(sizeof(IndexedString), (size_t)1);
+}
+
+test(indexer_different_strings_are_different)
+{
+  IndexedString one("one");
+  IndexedString two("two");
+
+  assertFalse(one == two);
+}
+
+test(indexer_same_strings_should_equal)
+{
+  IndexedString one("one");
+  IndexedString two("one");
+
+  assertTrue(one == two);
+}
+
+test(indexer_compare_strings_with_same_beginning)
+{
+  IndexedString two("one_two");
+  IndexedString one("one");
+
+  assertNotEqual(one.getIndex(), two.getIndex());
+}
+
+test(indexer_indexed_operator_eq)
+{
+  IndexedString one("one");
+  {
+    IndexedString same = one;
+    assertTrue(one == same);
+    assertEqual(StringIndexer::count(), 1);
+  }
+  assertEqual(StringIndexer::count(), 1);
+}
+
+test(indexer_get_string)
+{
+  std::string sone("one");
+  IndexedString one(sone);
+
+  assertTrue(sone==one.str());
+}
+
+test(indexer_get_index)
+{
+  IndexedString one1("one");
+  IndexedString one2("one");
+  IndexedString two1("two");
+  IndexedString two2("two");
+
+  assertTrue(one1.getIndex() == one2.getIndex());
+  assertTrue(two1.getIndex() == two2.getIndex());
+  assertTrue(one1.getIndex() != two1.getIndex());
+}
+
+//----------------------------------------------------------------------------
+// setup() and loop()
+void setup() {
+  delay(1000);
+  Serial.begin(115200);
+  while(!Serial);
+
+  Serial.println("=============[ TinyMqtt StringIndexer TESTS ]========================");
+}
+
+void loop() {
+  aunit::TestRunner::run();
+
+  // if (Serial.available()) ESP.reset();
+}

tests/topic-tests/Makefile

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

tests/topic-tests/topic-tests.ino

@@ -0,0 +1,86 @@
+// vim: ts=2 sw=2 expandtab
+#include <Arduino.h>
+#include <AUnit.h>
+#include <TinyMqtt.h>
+#include <map>
+#include <iostream>
+
+#define endl "\n"
+
+/**
+  * TinyMqtt / StringIndexer unit tests.
+  *
+  **/
+
+using namespace std;
+
+bool testTopicMatch(const char* a, const char* b, bool expected)
+{
+  Topic ta(a);
+  Topic tb(b);
+  bool match(ta.matches(tb));
+  cout << "  " << ta.c_str() << ' ';
+  if (match != expected)
+    cout << (expected ? " should match " : " should not match ");
+  else
+    cout << (expected ? " matches " : " unmatches ");
+  cout << tb.c_str() << endl;
+  return expected == match;
+}
+
+test(topic_matches)
+{
+  // matching
+  assertTrue(testTopicMatch("a/b/c"    , "a/b/c"     , true));
+  assertTrue(testTopicMatch("a/*/c"    , "a/xyz/c"   , true));
+  assertTrue(testTopicMatch("a/*/e"    , "a/b/c/d/e" , true));
+  assertTrue(testTopicMatch("a/*"      , "a/b/c/d/e" , true));
+  assertTrue(testTopicMatch("*/c"      , "a/b/c"     , true));
+  assertTrue(testTopicMatch("/*/c"     , "/a/b/c"    , true));
+  assertTrue(testTopicMatch("a/*"      , "a/b/c/d"   , true));
+  assertTrue(testTopicMatch("a/+/c"    , "a/b/c"     , true));
+  assertTrue(testTopicMatch("a/+/c/+/e", "a/b/c/d/e" , true));
+  assertTrue(testTopicMatch("a/*/c/+/e", "a/b/c/d/e" , true));
+  assertTrue(testTopicMatch("/+/b"     , "/a/b"      , true));
+  assertTrue(testTopicMatch("+"        , "a"         , true));
+  assertTrue(testTopicMatch("a/b/#"    , "a/b/c/d"   , true));
+  assertTrue(testTopicMatch("a/b/#"    , "a/b"       , true));
+  assertTrue(testTopicMatch("a/*/c"    , "a/*/c"     , true));
+
+  // not matching
+  assertTrue(testTopicMatch("a/b/c"    , "a/b/d"     , false));
+  assertTrue(testTopicMatch("a/b/c"    , "a/b/d"     , false));
+  assertTrue(testTopicMatch("a/*/e"    , "a/b/c/d/f" , false));
+  assertTrue(testTopicMatch("a/+"      , "a"         , false));
+  assertTrue(testTopicMatch("a/+"      , "a/b/d"     , false));
+  assertTrue(testTopicMatch("a/+/"     , "a/"        , false));
+
+  // $SYS topics
+  assertTrue(testTopicMatch("+/any"    , "$SYS/any"  , false));
+  assertTrue(testTopicMatch("*/any"    , "$SYS/any"  , false));
+  assertTrue(testTopicMatch("$SYS/any" , "$SYS/any"  , true));
+  assertTrue(testTopicMatch("$SYS/+/y" , "$SYS/a/y"  , true));
+  assertTrue(testTopicMatch("$SYS/#"   , "$SYS/a/y"  , true));
+
+  // not valid
+  assertTrue(testTopicMatch("a/#/b"    , "a/x/b"     , false));
+  assertTrue(testTopicMatch("a+"      , "a/b/d"     , false));
+  assertTrue(testTopicMatch("a/b/#/d"  , "a/b/c/d"   , false));
+
+}
+
+//----------------------------------------------------------------------------
+// setup() and loop()
+void setup() {
+  delay(1000);
+  Serial.begin(115200);
+  while(!Serial);
+
+  Serial.println("=============[ TinyMqtt StringIndexer TESTS ]========================");
+}
+
+void loop() {
+  aunit::TestRunner::run();
+
+  // if (Serial.available()) ESP.reset();
+}