Minor typo changes and add comments

Minor updates
Re-enabled lot of local unit tests
2023-02-23 19:24:27 +01:00 · 2023-02-23 19:22:40 +01:00 · 2023-02-22 07:40:12 +01:00 · 2023-02-20 05:24:35 +01:00 · 2023-02-20 03:22:50 +01:00 · 2023-02-20 02:39:43 +01:00
30 changed files with 1797 additions and 235 deletions
--- a/.github/workflows/aunit.yml
+++ b/.github/workflows/aunit.yml
@@ -9,7 +9,7 @@ on: [push]
 jobs:
  build:

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

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

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

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

 - Very fast broker I saw it re-sent 1000 topics per second for two
--- a/examples/advanced/mqtt_class_binder/mqtt_class_binder.ino
+++ b/examples/advanced/mqtt_class_binder/mqtt_class_binder.ino
@@ -0,0 +1,134 @@
+#include <TinyMqtt.h>   // https://github.com/hsaturn/TinyMqtt
+#include <MqttClassBinder.h>
+
+/**
+  * Example on how to bind a class:onPublish function
+  *
+  * Local broker that accept connections and two local clients
+  *
+  *
+  *  +-----------------------------+
+  *  | ESP                         |
+  *  |                 +--------+  | 1883 <--- External client/s
+  *  |       +-------->| broker |  | 1883 <--- External client/s
+  *  |       |         +--------+  |
+  *  |       |             ^       |
+  *  |       |             |       |
+  *  |       |             |       |     -----
+  *  |       v             v       |      ---
+  *  | +----------+  +----------+  |       -
+  *  | | internal |  | internal |  +-------*  Wifi
+  *  | | client   |  | client   |  |
+  *  | +----------+  +----------+  |
+  *  |                             |
+  *  +-----------------------------+
+  *
+  * pros - Reduces internal latency (when publish is received by the same ESP)
+  *      - Reduces wifi traffic
+  *      - No need to have an external broker
+  *      - can still report to a 'main' broker (TODO see documentation that have to be written)
+  *      - accepts external clients
+  *      - MqttClassBinder allows to mix together many mqtt sources
+  *
+  * cons - Takes more memory (24 more bytes for the one MqttClassBinder<Class>
+  *      - a bit hard to understand
+  *
+  */
+
+const char *ssid     = "";
+const char *password = "";
+
+std::string topic_b="sensor/btemp";
+std::string topic_sender= "sensor/counter";
+
+MqttBroker broker(1883);
+
+MqttClient mqtt_a(&broker);
+MqttClient mqtt_b(&broker);
+MqttClient mqtt_sender(&broker);
+
+class MqttReceiver: public MqttClassBinder<MqttReceiver>
+{
+  public:
+
+    void onPublish(const MqttClient* source, const Topic& topic, const char* payload, size_t /* length */)
+    {
+      Serial
+        << "   * MqttReceiver received topic (" << topic.c_str() << ")"
+        << " from (" << source->id() << "), "
+        << " payload: (" << payload << ')' << endl;
+    }
+};
+
+void setup()
+{
+  Serial.begin(115200);
+  delay(500);
+  Serial << "Clients with wifi " << endl;
+
+  WiFi.mode(WIFI_STA);
+  WiFi.begin(ssid, password);
+
+  while (WiFi.status() != WL_CONNECTED)
+  {
+    Serial << '-'; delay(500);
+  	if (strlen(ssid)==0)
+	  	Serial << "****** PLEASE EDIT THE EXAMPLE AND MODIFY ssid/password *************" << endl;
+  }
+
+  Serial << "Connected to " << ssid << "IP address: " << WiFi.localIP() << endl;
+
+  broker.begin();
+
+  MqttReceiver* receiver = new MqttReceiver;
+
+  // receiver will receive both publication from two MqttClient
+  // (that could be connected to two different brokers)
+  MqttClassBinder<MqttReceiver>::onPublish(&mqtt_a, receiver);
+  MqttClassBinder<MqttReceiver>::onPublish(&mqtt_b, receiver);
+
+  mqtt_a.id("mqtt_a");
+  mqtt_b.id("mqtt_b");
+  mqtt_sender.id("sender");
+
+  mqtt_a.subscribe(topic_b);
+  mqtt_b.subscribe(topic_sender);
+
+}
+
+void loop()
+{
+  broker.loop();  // Don't forget to add loop for every broker and clients
+
+  mqtt_a.loop();
+  mqtt_b.loop();
+  mqtt_sender.loop();
+
+  // ============= client A publish ================
+  {
+    static const int interval = 5000;  // publishes every 5s (please avoid usage of delay())
+    static uint32_t timer = millis() + interval;
+
+    if (millis() > timer)
+    {
+      static int counter = 0;
+      Serial << "Sender is publishing " << topic_sender.c_str() << endl;
+      timer += interval;
+      mqtt_sender.publish(topic_sender, "sent by Sender, message #"+std::string(String(counter++).c_str()));
+    }
+  }
+
+  // ============= client B publish ================
+  {
+    static const int interval = 7000;	// will send topic each 7s
+    static uint32_t timer = millis() + interval;
+    static int temperature;
+
+    if (millis() > timer)
+    {
+      Serial << "B is publishing " << topic_b.c_str() << endl;
+      timer += interval;
+      mqtt_b.publish(topic_b, "sent by B: temp="+std::string(String(16+temperature++%6).c_str()));
+    }
+  }
+}
--- a/examples/tinymqtt-test/tinymqtt-test.ino
+++ b/examples/tinymqtt-test/tinymqtt-test.ino
@@ -15,6 +15,8 @@
 #include <string>
 #include <map>

+using string = TinyString;
+
 bool echo_on = true;
 auto green = TinyConsole::green;
 auto red = TinyConsole::red;
@@ -32,13 +34,13 @@ const char* password = "";
 struct free_broker
 {
  public:
-    free_broker(const char* s, uint16_t p, const char* comment) : url(s), port(p) {}
+    free_broker(const char* s, uint16_t p, const char* /* comment */) : url(s), port(p) {}

-    std::string url;
+    string url;
    uint16_t port;
 };

-const std::map<std::string, free_broker> list =
+const std::map<string, free_broker> list =
 {
  { "mqtthq", { "public.mqtthq.com" , 8083, "publish/subscribe" }},
  { "hivemq", { "broker.hivemq.com", 1883, "" }}
@@ -73,8 +75,8 @@ void onPublish(const MqttClient* srce, const Topic& topic, const char* payload,
  }
 }

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

 void setup()
 {
@@ -126,12 +128,12 @@ void setup()
  if (Console.isTerm()) onCommand("every 333 view");
 }

-std::string getword(std::string& str, const char* if_empty=nullptr, char sep=' ');
+string getword(string& str, const char* if_empty=nullptr, char sep=' ');

-int getint(std::string& str, const int if_empty=0)
+int getint(string& str, const int if_empty=0)
 {
-  std::string str2=str;
-  std::string sword = getword(str);
+  string str2=str;
+  string sword = getword(str);
  if (sword[0] and isdigit(sword[0]))
  {
    int ret=atoi(sword.c_str());
@@ -143,11 +145,11 @@ int getint(std::string& str, const int if_empty=0)
  return if_empty;
 }

-std::string getword(std::string& str, const char* if_empty/*=nullptr*/, char sep/*=' '*/)
+string getword(string& str, const char* if_empty/*=nullptr*/, char sep/*=' '*/)
 {
  char quote=(str[0]=='"' or str[0]=='\'' ? str[0] : 0);
  if (quote) str.erase(0,1);
-  std::string sword;
+  string sword;
  while(str.length() and (str[0]!=sep or quote))
  {
    if (str[0]==quote)
@@ -190,7 +192,7 @@ std::string getword(std::string& str, const char* if_empty/*=nullptr*/, char sep
  return sword;
 }

-bool isaddr(std::string s)
+bool isaddr(string s)
 {
  if (s.length()==0 or s.length()>3) return false;
  for(char c: s)
@@ -198,14 +200,14 @@ bool isaddr(std::string s)
  return true;
 }

-std::string getip(std::string& str, const char* if_empty=nullptr, char sep=' ')
+string getip(string& str, const char* if_empty=nullptr, char sep=' ')
 {
-  std::string addr=getword(str, if_empty, sep);
-  std::string ip=addr;
-  std::vector<std::string> build;
+  string addr=getword(str, if_empty, sep);
+  string ip=addr;
+  std::vector<string> build;
  while(ip.length())
  {
-    std::string b=getword(ip,nullptr,'.');
+    string b=getword(ip,nullptr,'.');
    if (isaddr(b) && build.size()<4)
    {
      build.push_back(b);
@@ -219,9 +221,9 @@ std::string getip(std::string& str, const char* if_empty=nullptr, char sep=' ')
  {
    std::stringstream b;
    b << (int)local[3-build.size()];
-    build.insert(build.begin(), b.str());
+    build.insert(build.begin(), b.str().c_str());
  }
-  for(std::string s: build)
+  for(string s: build)
  {
    if (addr.length()) addr += '.';
    addr += s;
@@ -230,22 +232,22 @@ std::string getip(std::string& str, const char* if_empty=nullptr, char sep=' ')
  return addr;
 }

-std::map<std::string, std::string> vars;
+std::map<string, string> vars;

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

-void convertToCommand(std::string& search)
+void convertToCommand(string& search)
 {
  while(search[0]==' ') search.erase(0,1);
  if (search.length()==0) return;
-  std::string matches;
+  string matches;
  int count=0;
-  for(std::string cmd: commands)
+  for(string cmd: commands)
  {
    if (cmd.substr(0, search.length()) == search)
    {
@@ -263,7 +265,7 @@ void convertToCommand(std::string& search)
  }
 }

-void replace(const char* d, std::string& str, std::string srch, std::string to)
+void replace(const char* d, string& str, string srch, string to)
 {
  if (d[0] && d[1])
  {
@@ -271,7 +273,7 @@ void replace(const char* d, std::string& str, std::string srch, std::string to)
    to=d[0]+to+d[1];

    size_t pos = 0;
-    while((pos=str.find(srch, pos)) != std::string::npos)
+    while((pos=str.find(srch, pos)) != string::npos)
    {
      str.erase(pos, srch.length());
      str.insert(pos, to);
@@ -280,7 +282,7 @@ void replace(const char* d, std::string& str, std::string srch, std::string to)
  }
 }

-void replaceVars(std::string& cmd)
+void replaceVars(string& cmd)
 {
  cmd = ' '+cmd+' ';

@@ -291,12 +293,12 @@ void replaceVars(std::string& cmd)
    replace(" .", cmd, it.first, it.second);
    replace("  ", cmd, it.first, it.second);
  }
-  cmd.erase(0, cmd.find_first_not_of(" "));
-  cmd.erase(cmd.find_last_not_of(" ")+1);
+  cmd.erase(0, cmd.find_first_not_of(' '));
+  cmd.erase(cmd.find_last_not_of(' ')+1);

 }

-bool compare(std::string s, const char* cmd)
+bool compare(string s, const char* cmd)
 {
  uint8_t p=0;
  while(s[p++]==*cmd++)
@@ -307,11 +309,11 @@ bool compare(std::string s, const char* cmd)
  return false;
 }

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

 struct Every
 {
-  std::string cmd;
+  string cmd;
  uint32_t ms;
  uint32_t next;
  uint32_t underrun=0;
@@ -341,19 +343,19 @@ int16_t blink;

 std::vector<Every> everies;

-void onCommand(const std::string& command)
+void onCommand(const string& command)
 {
  Console << endl;
-  std::string cmd=command;
+  string cmd=command;
  if (cmd.substr(0,3)!="set") replaceVars(cmd);
  eval(cmd);
  Console << endl;
  Console.prompt();
 }

-void clientConnect(MqttClient* client, std::string& cmd)
+void clientConnect(MqttClient* client, string& cmd)
 {
-  std::string remote = getword(cmd);
+  string remote = getword(cmd);
  uint16_t port;
  auto it=list.find(remote);
  if (it != list.end())
@@ -369,18 +371,18 @@ void clientConnect(MqttClient* client, std::string& cmd)
  Console << (client->connected() ? "connected." : "not connected") << endl;
 }

-void eval(std::string& cmd)
+void eval(string& cmd)
 {
  while(cmd.length())
  {
    MqttError retval = MqttOk;

-    std::string s;
+    string s;
    MqttBroker* broker = nullptr;
    MqttClient* client = nullptr;

    // client.function notation
-    if (cmd.find('.') != std::string::npos &&
+    if (cmd.find('.') != string::npos &&
        cmd.find('.') < cmd.find(' '))
    {
      s=getword(cmd, nullptr, '.');
@@ -632,7 +634,7 @@ void eval(std::string& cmd)
    }
    else if (compare(s, "broker"))
    {
-      std::string id=getword(cmd);
+      string id=getword(cmd);
      if (clients.find(id) != clients.end())
      {
        Console << "A client already have that name" << endl;
@@ -663,7 +665,7 @@ void eval(std::string& cmd)
    }
    else if (compare(s, "client"))
    {
-      std::string id=getword(cmd);
+      string id=getword(cmd);
      if (brokers.find(id) != brokers.end())
      {
        Console << "A broker have that name" << endl;
@@ -700,7 +702,7 @@ void eval(std::string& cmd)
    }
    else if (compare(s, "set"))
    {
-      std::string name(getword(cmd));
+      string name(getword(cmd));
      if (name.length()==0)
      {
        for(auto it: vars)
@@ -812,7 +814,7 @@ void loop()
    if (not every.active) continue;
    if (every.ms && every.cmd.length() && ms > every.next)
    {
-      std::string cmd(every.cmd);
+      string cmd(every.cmd);
      eval(cmd);
      every.next += every.ms;
      if (ms > every.next and ms > every.underrun)
@@ -845,7 +847,6 @@ void loop()
    out++;
  }

-  static long count;
 #if defined(ESP9266)
  MDNS.update();
 #endif
--- a/library.properties
+++ b/library.properties
@@ -1,9 +1,9 @@
 name=TinyMqtt
-version=0.9.7
+version=0.9.12
 author=Francois BIOT, HSaturn, <hsaturn@gmail.com>
-maintainer=Francois BIOT, HSaturn, <hsaturn@gmail.com>
+maintainer=Francois BIOT <hsaturn@gmail.com>
 sentence=A tiny broker and client library for MQTT messaging.
-paragraph=MQTT is a lightweight messaging protocol ideal for small devices. This library allows to send and receive MQTT messages and to host a broker in your ESP 8266 and 32 WROOM. It does support MQTT 3.1.1 with QoS=0.
+paragraph=MQTT is a lightweight messaging protocol. This library allows to host a broker or to use a mqtt client in your ESP 8266 or 32 WROOM. It does support MQTT 3.1.1 with QoS=0, and is intented to be as smallest as possible, keeping a good efficiency (about 1k msg per second on ESP8266 12F).
 category=Communication
 url=https://github.com/hsaturn/TinyMqtt
 architectures=*
--- a/src/MqttClassBinder.h
+++ b/src/MqttClassBinder.h
@@ -0,0 +1,72 @@
+// MqttReceiver must implement onPublish(...)
+template <class MqttReceiver>
+class MqttClassBinder
+{
+  public:
+    MqttClassBinder()
+    {
+      unregister(this);
+    }
+    ~MqttClassBinder() { unregister(this); }
+
+    static void onUnpublished(MqttClient::CallBack handler)
+    {
+      unrouted_handler = handler;
+    }
+
+    static void onPublish(MqttClient* client, MqttReceiver* dest)
+    {
+      routes.insert(std::pair<MqttClient*, MqttReceiver*>(client, dest));
+      client->setCallback(onRoutePublish);
+    }
+
+    void onPublish(const MqttClient* client, const Topic& topic, const char* payload, size_t length)
+    {
+      static_cast<MqttReceiver*>(this)->MqttReceiver::onPublish(client, topic, payload, length);
+    }
+
+    static size_t size() { return routes.size(); }
+
+    static void reset() { routes.clear(); }
+
+  private:
+
+    static void onRoutePublish(const MqttClient* client, const Topic& topic, const char* payload, size_t length)
+    {
+      bool unrouted = true;
+      auto receivers = routes.equal_range(client);
+      for(auto it = receivers.first; it != receivers.second; ++it)
+      {
+        it->second->onPublish(client, topic, payload, length);
+        unrouted = false;
+      }
+
+      if (unrouted and unrouted_handler)
+      {
+        unrouted_handler(client, topic, payload, length);
+      }
+    }
+
+  private:
+    void unregister(MqttClassBinder<MqttReceiver>* which)
+    {
+      if (routes.size()==0) return;   // bug in map stl
+      for(auto it=routes.begin(); it!=routes.end(); it++)
+        if (it->second == which)
+        {
+          routes.erase(it);
+          return;
+        }
+    }
+
+  static std::multimap<const MqttClient*, MqttClassBinder<MqttReceiver>*> routes;
+  static MqttClient::CallBack unrouted_handler;
+
+};
+
+template<class MqttReceiver>
+std::multimap<const MqttClient*, MqttClassBinder<MqttReceiver>*> MqttClassBinder<MqttReceiver>::routes;
+
+template<class MqttReceiver>
+MqttClient::CallBack MqttClassBinder<MqttReceiver>::unrouted_handler = nullptr;
+
--- a/src/StringIndexer.cpp
+++ b/src/StringIndexer.cpp
@@ -1,3 +1,4 @@
 #include "StringIndexer.h"

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

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

@@ -29,13 +36,13 @@ class StringIndexer
  public:
    using index_t = uint8_t;

-   static const std::string& str(const index_t& index)
-    {
-      static std::string dummy;
-      const auto& it=strings.find(index);
-      if (it == strings.end()) return dummy;
-      return it->second.str;
-    }
+   static const string& str(const index_t& index)
+   {
+     static string dummy;
+     const auto& it=strings.find(index);
+     if (it == strings.end()) return dummy;
+     return it->second.str;
+   }

    static void use(const index_t& index)
    {
@@ -77,7 +84,7 @@ class StringIndexer
      {
        if (strings.find(index)==strings.end())
        {
-          strings[index].str = std::string(str, len);
+          strings[index].str = string(str, len);
          strings[index].used++;
          // Serial << "Creating index " << index << " for (" << strings[index].str.c_str() << ") len=" << len << endl;
          return index;
@@ -86,7 +93,9 @@ class StringIndexer
      return 0;  // TODO out of indexes
    }

-    static std::map<index_t, StringCounter> strings;
+    using Strings = std::unordered_map<index_t, StringCounter>;
+
+    static Strings strings;
 };

 class IndexedString
@@ -103,7 +112,7 @@ class IndexedString
      index=StringIndexer::strToIndex(str, len);
    }

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

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

@@ -124,7 +133,7 @@ class IndexedString
      return i1.index == i2.index;
    }

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

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

--- a/src/TinyMqtt.cpp
+++ b/src/TinyMqtt.cpp
@@ -27,7 +27,14 @@ MqttBroker::~MqttBroker()
 {
  while(clients.size())
  {
-    delete clients[0];
+    auto client = clients[0];
+    client->local_broker = nullptr;
+    if (client->cltFlags & MqttClient::CltFlags::CltFlagToDelete)
+    {
+      // std::cout << "Deleting client" << std::endl;
+      delete client;
+    }
+    clients.erase(clients.begin());
  }
  delete server;
 }
@@ -38,12 +45,12 @@ MqttClient::MqttClient(MqttBroker* local_broker, TcpClient* new_client)
 {
  debug("MqttClient private with broker");
 #ifdef TINY_MQTT_ASYNC
-  client = new_client;
-  client->onData(onData, this);
+  tcp_client = new_client;
+  tcp_client->onData(onData, this);
  // client->onConnect() TODO
  // client->onDisconnect() TODO
 #else
-  client = new WiFiClient(*new_client);
+  tcp_client = new WiFiClient(*new_client);
 #endif
 #ifdef EPOXY_DUINO
  alive = millis()+500000;
@@ -52,33 +59,35 @@ MqttClient::MqttClient(MqttBroker* local_broker, TcpClient* new_client)
 #endif
 }

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

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

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

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

  if (local_broker)
@@ -93,25 +102,26 @@ void MqttClient::connect(MqttBroker* local)
  debug("MqttClient::connect_local");
  close();
  local_broker = local;
+  local_broker->addClient(this);
 }

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

 #ifdef TINY_MQTT_ASYNC
-  client->onData(onData, this);
-  client->onConnect(onConnect, this);
-  client->connect(broker.c_str(), port, ka);
+  tcp_client->onData(onData, this);
+  tcp_client->onConnect(onConnect, this);
+  tcp_client->connect(broker.c_str(), port, ka);
 #else
-  if (client->connect(broker.c_str(), port))
+  if (tcp_client->connect(broker.c_str(), port))
  {
    debug("link established");
-    onConnect(this, client);
+    onConnect(this, tcp_client);
  }
  else
  {
@@ -126,12 +136,12 @@ void MqttBroker::addClient(MqttClient* client)
  clients.push_back(client);
 }

-void MqttBroker::connect(const std::string& host, uint16_t port)
+void MqttBroker::connect(const string& host, uint16_t port)
 {
  debug("MqttBroker::connect");
-  if (broker == nullptr) broker = new MqttClient;
-  broker->connect(host, port);
-  broker->local_broker = this;  // Because connect removed the link
+  if (remote_broker == nullptr) remote_broker = new MqttClient;
+  remote_broker->connect(host, port);
+  remote_broker->local_broker = this;  // Because connect removed the link
 }

 void MqttBroker::removeClient(MqttClient* remove)
@@ -161,33 +171,32 @@ void MqttBroker::onClient(void* broker_ptr, TcpClient* client)
  debug("MqttBroker::onClient");
  MqttBroker* broker = static_cast<MqttBroker*>(broker_ptr);

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

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

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

-
-  // for(auto it=clients.begin(); it!=clients.end(); it++)
-  // use index because size can change during the loop
  for(size_t i=0; i<clients.size(); i++)
  {
-    auto client = clients[i];
+    MqttClient* client = clients[i];
    if (client->connected())
    {
      client->loop();
@@ -205,9 +214,9 @@ void MqttBroker::loop()
 MqttError MqttBroker::subscribe(const Topic& topic, uint8_t qos)
 {
  debug("MqttBroker::subscribe");
-  if (broker && broker->connected())
+  if (remote_broker && remote_broker->connected())
  {
-    return broker->subscribe(topic, qos);
+    return remote_broker->subscribe(topic, qos);
  }
  return MqttNowhereToSend;
 }
@@ -222,19 +231,19 @@ MqttError MqttBroker::publish(const MqttClient* source, const Topic& topic, Mqtt
  {
    i++;
 #if TINY_MQTT_DEBUG
-    Console << __LINE__ << " broker:" << (broker && broker->connected() ? "linked" : "alone") <<
+    Console << __LINE__ << " broker:" << (remote_broker && remote_broker->connected() ? "linked" : "alone") <<
       "  srce=" << (source->isLocal() ? "loc" : "rem") << " clt#" << i << ", local=" << client->isLocal() << ", con=" << client->connected() << endl;
 #endif
    bool doit = false;
-    if (broker && broker->connected())  // this (MqttBroker) is connected (to a external broker)
+    if (remote_broker && remote_broker->connected())  // this (MqttBroker) is connected (to a external broker)
    {
      // ext_broker -> clients or clients -> ext_broker
-      if (source == broker)  // external broker -> internal clients
+      if (source == remote_broker)  // external broker -> internal clients
        doit = true;
      else                  // external clients -> this broker
      {
        // As this broker is connected to another broker, simply forward the msg
-        MqttError ret = broker->publishIfSubscribed(topic, msg);
+        MqttError ret = remote_broker->publishIfSubscribed(topic, msg);
        if (ret != MqttOk) retval = ret;
      }
    }
@@ -285,7 +294,7 @@ void MqttClient::clientAlive(uint32_t more_seconds)

 void MqttClient::loop()
 {
-  if (alive && (millis() > alive))
+  if (keep_alive && (millis() >= alive))
  {
    if (local_broker)
    {
@@ -293,11 +302,11 @@ void MqttClient::loop()
      close();
      debug(red << "closed");
    }
-    else if (client && client->connected())
+    else if (tcp_client && tcp_client->connected())
    {
      debug("pingreq");
      uint16_t pingreq = MqttMessage::Type::PingReq;
-      client->write((const char*)(&pingreq), 2);
+      tcp_client->write((const char*)(&pingreq), 2);
      clientAlive(0);

      // TODO when many MqttClient passes through a local broker
@@ -305,9 +314,9 @@ void MqttClient::loop()
    }
  }
 #ifndef TINY_MQTT_ASYNC
-  while(client && client->available()>0)
+  while(tcp_client && tcp_client->available()>0)
  {
-    message.incoming(client->read());
+    message.incoming(tcp_client->read());
    if (message.type())
    {
      processMessage(&message);
@@ -441,7 +450,7 @@ void MqttClient::processMessage(MqttMessage* mesg)
  switch(mesg->type())
  {
    case MqttMessage::Type::Connect:
-      if (mqtt_connected)
+      if (mqtt_connected())
      {
        debug("already connected");
        break;
@@ -456,13 +465,13 @@ void MqttClient::processMessage(MqttMessage* mesg)
      }
      if (header[6]!=0x04)
      {
-        debug("unknown level");
+        debug("Unsupported MQTT version (" << (int) header[6] << "), only version=4 supported" << endl);
        break;  // Level 3.1.1
      }

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

      if (mqtt_flags & FlagWill)  // Will topic
@@ -491,7 +500,7 @@ void MqttClient::processMessage(MqttMessage* mesg)
        Console << yellow << "Client " << clientId << " connected : keep alive=" << keep_alive << '.' << white << endl;
      #endif
      bclose = false;
-      mqtt_connected=true;
+      setFlag(CltFlagConnected);
      {
        MqttMessage msg(MqttMessage::Type::ConnAck);
        msg.add(0);  // Session present (not implemented)
@@ -501,14 +510,14 @@ void MqttClient::processMessage(MqttMessage* mesg)
      break;

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

    case MqttMessage::Type::SubAck:
    case MqttMessage::Type::PubAck:
-      if (!mqtt_connected) break;
+      if (not mqtt_connected()) break;
      // Ignore acks
      bclose = false;
      break;
@@ -519,12 +528,12 @@ void MqttClient::processMessage(MqttMessage* mesg)
      break;

    case MqttMessage::Type::PingReq:
-      if (!mqtt_connected) break;
-      if (client)
+      if (not mqtt_connected()) break;
+      if (tcp_client)
      {
        uint16_t pingreq = MqttMessage::Type::PingResp;
        debug(cyan << "Ping response to client ");
-        client->write((const char*)(&pingreq), 2);
+        tcp_client->write((const char*)(&pingreq), 2);
        bclose = false;
      }
      else
@@ -536,15 +545,15 @@ void MqttClient::processMessage(MqttMessage* mesg)
    case MqttMessage::Type::Subscribe:
    case MqttMessage::Type::UnSubscribe:
      {
-        if (!mqtt_connected) break;
+        if (not mqtt_connected()) break;
        payload = header+2;

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

@@ -580,15 +589,15 @@ void MqttClient::processMessage(MqttMessage* mesg)
      break;

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

    case MqttMessage::Type::Publish:
      #if TINY_MQTT_DEBUG
-        Console << "publish " << mqtt_connected << '/' << (long) client << endl;
+        Console << "publish " << mqtt_connected() << '/' << (long) tcp_client << endl;
      #endif
-      if (mqtt_connected or client == nullptr)
+      if (mqtt_connected() or tcp_client == nullptr)
      {
        uint8_t qos = mesg->flags();
        payload = header;
@@ -598,13 +607,13 @@ void MqttClient::processMessage(MqttMessage* mesg)
        #if TINY_MQTT_DEBUG
          Console << "Received Publish (" << published.str().c_str() << ") size=" << (int)len << endl;
        #endif
-        // << '(' << std::string(payload, len).c_str() << ')'  << " msglen=" << mesg->length() << endl;
+        // << '(' << string(payload, len).c_str() << ')'  << " msglen=" << mesg->length() << endl;
        if (qos) payload+=2;  // ignore packet identifier if any
        len=mesg->end()-payload;
        // TODO reset DUP
        // TODO reset RETAIN

-        if (local_broker==nullptr or client==nullptr)  // internal MqttClient receives publish
+        if (local_broker==nullptr or tcp_client==nullptr)  // internal MqttClient receives publish
        {
          #if TINY_MQTT_DEBUG
            if (TinyMqtt::debug >= 2)
@@ -629,8 +638,8 @@ void MqttClient::processMessage(MqttMessage* mesg)

    case MqttMessage::Type::Disconnect:
      // TODO should discard any will msg
-      if (!mqtt_connected) break;
-      mqtt_connected = false;
+      if (not mqtt_connected()) break;
+      resetFlag(CltFlagConnected);
      close(false);
      bclose=false;
      break;
@@ -730,7 +739,7 @@ MqttError MqttClient::publish(const Topic& topic, const char* payload, size_t pa
  {
    return local_broker->publish(this, topic, msg);
  }
-  else if (client)
+  else if (tcp_client)
    return msg.sendTo(this);
  else
    return MqttNowhereToSend;
@@ -744,7 +753,7 @@ MqttError MqttClient::publishIfSubscribed(const Topic& topic, MqttMessage& msg)
  debug("mqttclient publishIfSubscribed " << topic.c_str() << ' ' << subscriptions.size());
  if (isSubscribedTo(topic))
  {
-    if (client)
+    if (tcp_client)
      retval = msg.sendTo(this);
    else
    {
@@ -890,7 +899,7 @@ void MqttMessage::hexdump(const char* prefix) const
  (void)prefix;
 #if TINY_MQTT_DEBUG
  if (TinyMqtt::debug<2) return;
-  static std::map<Type, std::string> tts={
+  static std::map<Type, string> tts={
    { Connect, "Connect" },
    { ConnAck, "Connack" },
    { Publish, "Publish" },
@@ -903,7 +912,7 @@ void MqttMessage::hexdump(const char* prefix) const
    { PingResp, "Pingresp" },
    { Disconnect, "Disconnect" }
  };
-  std::string t("Unknown");
+  string t("Unknown");
  Type typ=static_cast<Type>(buffer[0] & 0xF0);
  if (tts.find(typ) != tts.end())
    t=tts[typ];
@@ -920,7 +929,7 @@ void MqttMessage::hexdump(const char* prefix) const
  const char* hex_to_str = " | ";
  const char* separator = hex_to_str;
  const char* half_sep = " - ";
-  std::string ascii;
+  string ascii;

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

--- a/src/TinyMqtt.h
+++ b/src/TinyMqtt.h
@@ -1,6 +1,9 @@
 // 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
@@ -37,9 +40,9 @@

 #define TINY_MQTT_DEFAULT_CLIENT_ID "Tiny"

-#if TINY_MQTT_DEBUG
 #include <TinyStreaming.h>
-#include <TinyConsole.h>    // https://github.com/hsaturn/TinyConsole
+#if TINY_MQTT_DEBUG
+  #include <TinyConsole.h>    // https://github.com/hsaturn/TinyConsole
  struct TinyMqtt
  {
    static int debug;
@@ -65,12 +68,15 @@ enum __attribute__((packed)) MqttError
  MqttInvalidMessage=2,
 };

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

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

@@ -119,7 +125,7 @@ class MqttMessage
    void incoming(char byte);
    void add(char byte) { incoming(byte); }
    void add(const char* p, size_t len, bool addLength=true );
-    void add(const std::string& s) { add(s.c_str(), s.length()); }
+    void add(const string& s) { add(s.c_str(), s.length()); }
    void add(const Topic& t) { add(t.str()); }
    const char* end() const { return &buffer[0]+buffer.size(); }
    const char* getVHeader() const { return &buffer[vheader]; }
@@ -153,7 +159,7 @@ class MqttMessage
  private:
    void encodeLength();

-    std::string buffer;
+    string buffer;
    uint8_t vheader;
    uint16_t size;  // bytes left to receive
    State state;
@@ -162,7 +168,6 @@ class MqttMessage
 class MqttBroker;
 class MqttClient
 {
-  using CallBack = void (*)(const MqttClient* source, const Topic& topic, const char* payload, size_t payload_length);
  enum __attribute__((packed)) Flags
  {
    FlagUserName = 128,
@@ -173,31 +178,42 @@ class MqttClient
    FlagCleanSession = 2,  // unsupported
    FlagReserved = 1
  };
+
+  enum __attribute__((packed)) CltFlags
+  {
+    CltFlagNone = 0,
+    CltFlagConnected = 1,
+    CltFlagToDelete = 2
+  };
  public:
+
+    using CallBack = void (*)(const MqttClient* source, const Topic& topic, const char* payload, size_t payload_length);
+
    /** Constructor. Broker is the adress of a local broker if not null
        If you want to connect elsewhere, leave broker null and use connect() **/
-    MqttClient(MqttBroker* broker = nullptr, const std::string& id = TINY_MQTT_DEFAULT_CLIENT_ID);
-    MqttClient(const std::string& id) : MqttClient(nullptr, id){}
+    MqttClient(MqttBroker* broker = nullptr, const string& id = TINY_MQTT_DEFAULT_CLIENT_ID);
+    MqttClient(const string& id) : MqttClient(nullptr, id){}

    ~MqttClient();

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

    // TODO it seems that connected returns true in tcp mode even if
    // no negociation occurred
    bool connected()
    {
-      return (local_broker!=nullptr and client==nullptr) or (client and client->connected());
+      return (local_broker!=nullptr and tcp_client==nullptr)
+           or (tcp_client and tcp_client->connected());
    }

    void write(const char* buf, size_t length)
    {
-      if (client) client->write(buf, length);
+      if (tcp_client) tcp_client->write(buf, length);
    }

-    const std::string& id() const { return clientId; }
-    void id(const std::string& new_id) { clientId = new_id; }
+    const string& id() const { return clientId; }
+    void id(const string& new_id) { clientId = new_id; }

    /** Should be called in main loop() */
    void loop();
@@ -215,7 +231,7 @@ class MqttClient
    MqttError publish(const Topic&, const char* payload, size_t pay_length);
    MqttError publish(const Topic& t, const char* payload) { return publish(t, payload, strlen(payload)); }
    MqttError publish(const Topic& t, const String& s) { return publish(t, s.c_str(), s.length()); }
-    MqttError publish(const Topic& t, const std::string& s) { return publish(t,s.c_str(),s.length());}
+    MqttError publish(const Topic& t, const string& s) { return publish(t,s.c_str(),s.length());}
    MqttError publish(const Topic& t) { return publish(t, nullptr, 0);};

    MqttError subscribe(Topic topic, uint8_t qos=0);
@@ -224,18 +240,18 @@ class MqttClient

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

-    void dump(std::string indent="")
+    void dump(string indent="")
    {
      (void)indent;
      #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 (tcp_client)
        {
-          if (client->connected())
+          if (tcp_client->connected())
            Console << TinyConsole::green << "connected";
          else
            Console << TinyConsole::red << "disconnected";
@@ -263,6 +279,9 @@ class MqttClient
    uint32_t keepAlive() const { return keep_alive; }

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

    // event when tcp/ip link established (real or fake)
    static void onConnect(void * client_ptr, TcpClient*);
@@ -280,7 +299,7 @@ class MqttClient
    void clientAlive(uint32_t more_seconds);
    void processMessage(MqttMessage* message);

-    bool mqtt_connected = false;
+    uint8_t cltFlags = CltFlagNone;
    char mqtt_flags;
    uint32_t keep_alive = 30;
    uint32_t alive;
@@ -290,9 +309,9 @@ class MqttClient
    // when MqttBroker uses MqttClient for each external connexion
    MqttBroker* local_broker=nullptr;

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

@@ -302,7 +321,7 @@ class MqttBroker
  {
    Disconnected,  // Also the initial state
    Connecting,    // connect and sends a fake publish to avoid circular cnx
-    Connected,    // this->broker is connected and circular cnx avoided
+    Connected,     // this->broker is connected and circular cnx avoided
  };
  public:
    // TODO limit max number of clients
@@ -312,12 +331,14 @@ class MqttBroker
    void begin() { server->begin(); }
    void loop();

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

    size_t clientsCount() const { return clients.size(); }

-    void dump(std::string indent="")
+    void dump(string indent="")
    {
      for(auto client: clients)
        client->dump(indent);
@@ -352,7 +373,7 @@ class MqttBroker

    const char* auth_user = "guest";
    const char* auth_password = "guest";
-    MqttClient* broker = nullptr;
+    MqttClient* remote_broker = nullptr;

    State state = Disconnected;
 };
--- a/tests/Makefile
+++ b/tests/Makefile
@@ -1,28 +1,40 @@
+SUB=
+
+all:runtests
+
 tests:
-	set -e; \
-	for i in *-tests/Makefile; do \
+	@set -e; \
+	for i in $(SUB)*-tests/Makefile; do \
 		echo '==== Making:' $$(dirname $$i); \
 		$(MAKE) -C $$(dirname $$i) -j; \
 	done
+	$(MAKE) -C compile-test
+
+valgrind:
+	@set -e; \
+	$(MAKE) tests; \
+	for i in $(SUB)*-tests/Makefile; do \
+		echo '==== Running:' $$(dirname $$i); \
+		valgrind $$(dirname $$i)/$$(dirname $$i).out; \
+	done

 debugtest:
-	set -e; \
+	@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 \
+runtests:
+	@set -e; \
+	$(MAKE) tests; \
+	for i in $(SUB)*-tests/Makefile; do \
 		echo '==== Running:' $$(dirname $$i); \
 		$$(dirname $$i)/$$(dirname $$i).out; \
 	done

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

-EXTRA_CXXFLAGS=-g3 -O0
-
-# Remove flto flag from EpoxyDuino (too many <optimized out>)
-CXXFLAGS = -Wextra -Wall -std=gnu++11 -fno-exceptions -fno-threadsafe-statics
+include ../Makefile.opts

 APP_NAME := local-tests
 ARDUINO_LIBS := AUnit AceCommon AceTime TinyMqtt EspMock ESP8266WiFi  ESPAsyncTCP TinyConsole
--- a/tests/local-tests/local-tests.ino
+++ b/tests/local-tests/local-tests.ino
@@ -12,11 +12,11 @@
  * Also, this will allow to mock and thus run Action on github
  **/

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

 MqttBroker broker(1883);

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

 const char* lastPayload;
 size_t lastLength;
@@ -29,6 +29,15 @@ void onPublish(const MqttClient* srce, const Topic& topic, const char* payload,
  lastLength = length;
 }

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

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

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

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

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

-  MqttClient publisher;
+  MqttClient publisher(&broker);
  publisher.publish("a/b");
  publisher.publish("a/c");
  publisher.publish("a/c");
@@ -75,16 +126,16 @@ test(local_publish_should_be_dispatched_to_local_clients)
  published.clear();
  assertEqual(broker.clientsCount(), (size_t)0);

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

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

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

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

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

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

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

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

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

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

 # Remove flto flag from EpoxyDuino (too many <optimized out>)
-CXXFLAGS = -Wextra -Wall -std=gnu++11 -fno-exceptions -fno-threadsafe-statics
+# CXXFLAGS = -Wextra -Wall -std=gnu++11 -fno-exceptions -fno-threadsafe-statics

 APP_NAME := network-tests
 ARDUINO_LIBS := AUnit AceCommon AceTime TinyMqtt EspMock ESP8266WiFi  ESPAsyncTCP TinyConsole
--- a/tests/network-tests/network-tests.ino
+++ b/tests/network-tests/network-tests.ino
@@ -16,6 +16,8 @@
  * Checks with a local broker. Clients must connect to the local broker
  **/

+using string = TinyConsole::string;
+
 // if ascii_pos = 0, no ascii dump, else ascii dump starts after column ascii_pos
 std::string bufferToHexa(const uint8_t* buffer, size_t length, char sep = 0, size_t ascii_pos = 0)
 {
@@ -78,7 +80,7 @@ String toString(const IPAddress& ip)

 MqttBroker broker(1883);

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

 char* lastPayload = nullptr;
 size_t lastLength;
@@ -404,6 +406,20 @@ test(network_hudge_payload)
  assertEqual(strcmp(payload, lastPayload), 0);
 }

+test(disconnected_when_broker_is_deleted)
+{
+  MqttBroker* broker = new MqttBroker(1883);
+  broker->begin();
+
+  MqttClient client;
+  client.connect(broker);
+  assertEqual(client.connected(), true);
+  client.publish("a", "b");
+
+  delete broker;
+  assertEqual(client.connected(), false);
+}
+
 test(connack)
 {
  const bool view = false;
@@ -463,4 +479,5 @@ void loop() {
  aunit::TestRunner::run();

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

-EXTRA_CXXFLAGS=-g3 -O0
-
-# Remove flto flag from EpoxyDuino (too many <optimized out>)
-CXXFLAGS = -Wextra -Wall -std=gnu++11 -fno-exceptions -fno-threadsafe-statics
+include ../Makefile.opts

 APP_NAME := nowifi-tests
 ARDUINO_LIBS := AUnit AceCommon AceTime TinyMqtt EspMock ESP8266WiFi  ESPAsyncTCP TinyConsole
--- a/tests/nowifi-tests/nowifi-tests.ino
+++ b/tests/nowifi-tests/nowifi-tests.ino
@@ -11,11 +11,11 @@
  * Checks with a local broker. Clients must connect to the local broker
  **/

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

 MqttBroker broker(1883);

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

 char* lastPayload = nullptr;
 size_t lastLength;
@@ -279,4 +279,5 @@ void loop() {
  aunit::TestRunner::run();

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

-EXTRA_CXXFLAGS=-g3 -O0
+include ../Makefile.opts

 APP_NAME := string-indexer-tests
 ARDUINO_LIBS := AUnit AceCommon AceTime TinyMqtt EspMock ESP8266WiFi  ESPAsync TinyConsole
--- a/tests/string-indexer-tests/string-indexer-tests.ino
+++ b/tests/string-indexer-tests/string-indexer-tests.ino
@@ -9,7 +9,7 @@
  *
  **/

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

 test(indexer_empty)
 {
@@ -84,7 +84,7 @@ test(indexer_indexed_operator_eq)

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

  assertTrue(sone==one.str());
--- a/tests/topic-tests/Makefile
+++ b/tests/topic-tests/Makefile
@@ -1,7 +1,7 @@
 # See https://github.com/bxparks/EpoxyDuino for documentation about this
 # Makefile to compile and run Arduino programs natively on Linux or MacOS.

-EXTRA_CXXFLAGS=-g3 -O0
+include ../Makefile.opts

 APP_NAME := topic-tests
 ARDUINO_LIBS := AUnit AceCommon AceTime TinyMqtt EspMock ESP8266WiFi  ESPAsync TinyConsole
--- a/tests/topic-tests/topic-tests.ino
+++ b/tests/topic-tests/topic-tests.ino
@@ -5,26 +5,22 @@
 #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() << ' ';
+  std::cout << "  " << ta.c_str() << ' ';
  if (match != expected)
-    cout << (expected ? " should match " : " should not match ");
+    std::cout << (expected ? " should match " : " should not match ");
  else
-    cout << (expected ? " matches " : " unmatches ");
-  cout << tb.c_str() << endl;
+    std::cout << (expected ? " matches " : " unmatches ");
+  std::cout << tb.c_str() << std::endl;
  return expected == match;
 }
Author	SHA1	Message	Date
Francois BIOT	2587371457	Minor typo changes and add comments	2023-02-23 19:24:27 +01:00
hsaturn	a880a1ff2f	Minor updates	2023-02-23 19:22:40 +01:00
hsaturn	143d57db2d	Re-enabled lot of local unit tests	2023-02-22 07:40:12 +01:00
hsaturn	2a8dbd09c5	Memory deletion fixes	2023-02-20 05:24:35 +01:00
Francois BIOT	00333ed805	[TinyMqtt] Fix obsolete warning	2023-02-20 03:22:50 +01:00
hsaturn	9228408f57	[tests] Added -Wall and use TinyConsole::string	2023-02-20 02:39:43 +01:00
hsaturn	1653b2e386	[tests] Added a compilation test (based on example tiny-tests)	2023-02-20 02:28:22 +01:00
Francois BIOT	775fbc14ee	[tests] Use TinyConsole::string instead of any	2023-02-20 02:24:39 +01:00
hsaturn	c21b7b63fb	[tests] Removed warning and using namespace std	2023-02-20 02:21:33 +01:00
hsaturn	e45af112c2	Update README.md	2023-02-19 09:16:35 +01:00
hsaturn	f9c539ff6a	Added TinyConsole aunit test and dependency	2023-02-19 09:16:10 +01:00
hsaturn	7dc23d322c	TinyString moved to TinyConsole	2023-02-19 08:38:11 +01:00
Francois BIOT	4fb632ce3d	[TinyString] change size_t to be more tolerant with signed ints	2023-02-19 06:04:54 +01:00
hsaturn	c9130c7a24	[TinyString] Added size_t, added find(char)	2023-02-19 05:21:55 +01:00
hsaturn	31c51aeaff	[aunit] Use my git repo instead of bxpark's	2023-02-15 07:57:25 +01:00
hsaturn	2eeda4ecab	[makefiles] Added missing Makefile.opt	2023-02-15 05:39:17 +01:00
hsaturn	787cb77a26	String indexer std::string removed	2023-02-15 05:37:23 +01:00
hsaturn	d324a913ec	Merge pull request #59 from richievos/clearer-version-error More informative error on version mismatch	2023-02-13 09:00:39 +01:00
Richie Vos	ac1eedd72a	More informative error on version mismatch I spent a lot of time debugging my arduino, trying to figure out why my calls were all failing. Turned out to be due to the mqtt cli using v5, while this library only supports v4. By mqtt cli I mean the [hivemq one](https://hivemq.github.io/mqtt-cli/), which is the first one that shows up on google searches. Being new to mqtt this burned me for awhile, so I'm hoping this helps the next person. Both by having this PR show up if they search, and making the error more informative.	2023-02-12 21:37:17 -08:00
hsaturn	0900e799a9	Update README.md	2023-02-02 03:15:57 +01:00
hsaturn	2086c7f0e7	Added auint test to unit tests array	2023-02-02 03:14:25 +01:00
hsaturn	72382bf351	Added missing dependency to bxparks AceRoutine	2023-02-02 03:02:03 +01:00
hsaturn	3fec7b87a8	Unit tests of dependencies projects added	2023-02-02 02:21:59 +01:00
hsaturn	8641627742	Re-added flto in makefile	2023-01-15 16:04:16 +01:00
hsaturn	3b2460572b	Fix unit tests	2023-01-14 14:26:30 +01:00
hsaturn	a0435b2cfb	Release 0.9.12 unit test build upgrade	2023-01-03 04:33:47 +01:00
hsaturn	bda041417d	Release 0.9.12	2023-01-03 04:32:14 +01:00
hsaturn	baffda8a6d	MqttClient - fix local disconnect after pulish + ka	2023-01-03 04:25:26 +01:00
Francois BIOT	09e3a3e45f	Rename MqttBroker to remote_broker	2022-12-29 13:39:34 +01:00
Francois BIOT	f17ece3376	MqttClient::client renamed to tcp_client	2022-12-29 12:58:08 +01:00
hsaturn	0db07df27b	Remove useless comment	2022-12-29 12:54:58 +01:00
hsaturn	292592c3dd	Added missing Makefile for unit test of MqttClassBinder	2022-12-29 02:17:54 +01:00
Francois BIOT	1f267c135b	fix erroneous sizeof multimap comment	2022-12-29 02:15:18 +01:00
Francois BIOT	2b92833ea5	Remove spaces to end of lines	2022-12-28 21:22:19 +01:00
Francois BIOT	42fc054c94	release 0.9.11	2022-12-28 20:30:41 +01:00
hsaturn	7f12ecfd6d	Update mqtt_class_binder.ino	2022-12-28 20:29:33 +01:00
Francois BIOT	3ae1afec27	Release 0.9.10	2022-12-28 20:23:58 +01:00
Francois BIOT	9608ed9fdf	Added example for MqttClassBinder	2022-12-28 20:22:31 +01:00
hsaturn	220e904ae9	Add MqttClassBinder	2022-12-28 19:34:29 +01:00
hsaturn	49b696315c	Fix TINY_MQTT_DEBUG compilation	2022-12-28 19:30:16 +01:00
hsaturn	a9ebf31e6f	Version 0.9.9	2022-12-24 02:01:27 +01:00
hsaturn	4b4eb0b684	Fix compilation error when not in debug	2022-12-23 18:06:35 +01:00