Release 0.9.17

More informative error on version mismatch

.github/workflows/aunit.yml

@@ -20,7 +20,7 @@ jobs:
         git clone https://github.com/hsaturn/TinyConsole
         git clone https://github.com/hsaturn/EpoxyDuino
         git clone https://github.com/bxparks/AceRoutine
-        git clone https://github.com/bxparks/AUnit
+        git clone https://github.com/hsaturn/AUnit
         git clone https://github.com/bxparks/AceCommon
         git clone https://github.com/hsaturn/EspMock
     - name: Verify tests

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

bump_version.sh

@@ -0,0 +1,40 @@
+#!/bin/bash
+current_version=$(git describe --tags --abbrev=0)
+cp library.json.skeleton library.json
+while ifs= read -r line; do
+  name=$(echo "$line" | sed "s/=.*//g")
+  value=$(echo "$line" | cut -d= -f 2 | sed 's/"//g')
+  sed -i "s/#$name/$value/g" library.json
+done < library.properties
+
+if [ "$1" == "" ]; then
+	echo
+	echo "Syntax: $0 {new_version}"
+	echo
+	echo "  Current version: $current_version"
+	echo
+else
+	echo "Current version: ($current_version)"
+	echo "New version    : ($1)"
+	echo -n "Do you want to proceed ? "
+	read a
+	if [ "$a" == "y" ]; then
+		echo "Doing this..."
+		grep $current_version library.properties
+		if [ "$?" == "0" ]; then
+			sed -i "s/$current_version/$1/" library.properties
+			if [ 0 == 1 ]; then
+        git tag $1
+        git add library.properties
+        git add library.json
+        git commit -m "Release $1"
+        git push
+        git push --tags
+      else
+        echo "No git operation made"
+      fi
+		else
+			echo "Current version does not match library.property version, aborting"
+		fi
+	fi
+fi

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<string, MqttClient*> clients;
-std::map<std::string, MqttBroker*> brokers;
+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;
+  string str2=str;
-  std::string sword = getword(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);
+  string addr=getword(str, if_empty, sep);
-  std::string ip=addr;
+  string ip=addr;
-  std::vector<std::string> build;
+  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(0, cmd.find_first_not_of(' '));
-  cmd.erase(cmd.find_last_not_of(" ")+1);
+  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

library.json

@@ -0,0 +1,20 @@
+{
+    "name": "TinyMqtt",
+    "keywords": "ethernet, mqtt, m2m, iot",
+    "description": "MQTT is a lightweight messaging protocol. This library allows to host a broker or to use a mqtt client in your ESP 8266 or 32 WROOM. It does support MQTT 3.1.1 with QoS",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/hsaturn/TinyMqtt.git"
+    },
+    "dependencies":
+    { "hsaturn/TinyConsole" : "*" },
+    "version": "0.9.17",
+    "exclude": "",
+    "examples": "examples/*/*.ino",
+    "frameworks": "arduino",
+    "platforms": [
+        "atmelavr",
+        "espressif8266",
+        "espressif32"
+    ]
+}

library.json.skeleton

@@ -0,0 +1,18 @@
+{
+    "name": "#name",
+    "keywords": "ethernet, mqtt, m2m, iot",
+    "description": "#paragraph",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/hsaturn/TinyMqtt.git"
+    },
+    "version": "#version",
+    "exclude": "",
+    "examples": "examples/*/*.ino",
+    "frameworks": "arduino",
+    "platforms": [
+        "atmelavr",
+        "espressif8266",
+        "espressif32"
+    ]
+}

library.properties

@@ -1,11 +1,11 @@
 name=TinyMqtt
-version=0.9.12
+version=0.9.17
 author=Francois BIOT, HSaturn, <hsaturn@gmail.com>
-maintainer=Francois BIOT, HSaturn, <hsaturn@gmail.com>
+maintainer=Francois BIOT <hsaturn@gmail.com>
 sentence=A tiny broker and client library for MQTT messaging.
-paragraph=MQTT is a lightweight messaging protocol ideal for small devices. This library allows to send and receive MQTT messages and to host a broker in your ESP 8266 and 32 WROOM. It does support MQTT 3.1.1 with QoS=0.
+paragraph=MQTT is a lightweight messaging protocol. This library allows to host a broker or to use a mqtt client in your ESP 8266 or 32 WROOM. It does support MQTT 3.1.1 with QoS=0, and is intented to be as smallest as possible, keeping a good efficiency (about 1k msg per second on ESP8266 12F).
 category=Communication
 url=https://github.com/hsaturn/TinyMqtt
 architectures=*
-depends=TinyConsole
+depends=hsaturn/TinyConsole
 includes=TinyMqtt.h

src/StringIndexer.cpp

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

src/StringIndexer.h

@@ -1,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 const string& str(const index_t& index)
-    {
+   {
-      static std::string dummy;
+     static string dummy;
-      const auto& it=strings.find(index);
+     const auto& it=strings.find(index);
-      if (it == strings.end()) return dummy;
+     if (it == strings.end()) return dummy;
-      return it->second.str;
+     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; }
 

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;
 }
@@ -52,7 +59,7 @@ 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)
 {
   alive = 0;
@@ -71,7 +78,7 @@ MqttClient::~MqttClient()
 void MqttClient::close(bool bSendDisconnect)
 {
   debug("close " << id().c_str());
-  mqtt_connected = false;
+  resetFlag(CltFlagConnected);
   if (tcp_client)  // connected to a remote broker
   {
     if (bSendDisconnect and tcp_client->connected())
@@ -95,9 +102,10 @@ 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;
@@ -128,7 +136,7 @@ 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 (remote_broker == nullptr) remote_broker = new MqttClient;
@@ -163,14 +171,16 @@ 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)
   {
@@ -440,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;
@@ -455,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
@@ -490,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)
@@ -500,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;
@@ -518,7 +528,7 @@ void MqttClient::processMessage(MqttMessage* mesg)
       break;
 
     case MqttMessage::Type::PingReq:
-      if (!mqtt_connected) break;
+      if (not mqtt_connected()) break;
       if (tcp_client)
       {
         uint16_t pingreq = MqttMessage::Type::PingResp;
@@ -535,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);
 
@@ -579,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) tcp_client << endl;
+        Console << "publish " << mqtt_connected() << '/' << (long) tcp_client << endl;
       #endif
-      if (mqtt_connected or tcp_client == nullptr)
+      if (mqtt_connected() or tcp_client == nullptr)
       {
         uint8_t qos = mesg->flags();
         payload = header;
@@ -597,7 +607,7 @@ 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
@@ -628,8 +638,8 @@ void MqttClient::processMessage(MqttMessage* mesg)
 
     case MqttMessage::Type::Disconnect:
       // TODO should discard any will msg
-      if (!mqtt_connected) break;
+      if (not mqtt_connected()) break;
-      mqtt_connected = false;
+      resetFlag(CltFlagConnected);
       close(false);
       bclose=false;
       break;
@@ -889,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" },
@@ -902,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];
@@ -919,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;
 

src/TinyMqtt.h

@@ -68,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(); }
 
@@ -122,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]; }
@@ -156,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;
@@ -175,19 +178,26 @@ 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(MqttBroker* broker = nullptr, const string& id = TINY_MQTT_DEFAULT_CLIENT_ID);
-    MqttClient(const std::string& id) : MqttClient(nullptr, 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
@@ -202,8 +212,8 @@ class MqttClient
       if (tcp_client) tcp_client->write(buf, length);
     }
 
-    const std::string& id() const { return clientId; }
+    const string& id() const { return clientId; }
-    void id(const std::string& new_id) { clientId = new_id; }
+    void id(const string& new_id) { clientId = new_id; }
 
     /** Should be called in main loop() */
     void loop();
@@ -221,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);
@@ -232,7 +242,7 @@ class MqttClient
     // TODO seems to be useless
     bool isLocal() const { return tcp_client == nullptr; }
 
-    void dump(std::string indent="")
+    void dump(string indent="")
     {
       (void)indent;
       #if TINY_MQTT_DEBUG
@@ -269,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*);
@@ -286,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;
@@ -298,7 +311,7 @@ class MqttClient
 
     TcpClient* tcp_client=nullptr;    // connection to remote broker
     std::set<Topic>  subscriptions;
-    std::string clientId;
+    string clientId;
     CallBack callback = nullptr;
 };
 
@@ -308,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
@@ -318,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);

tests/Makefile

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

tests/Makefile.opts

@@ -0,0 +1,11 @@
+
+# GCC
+# CXXFLAGS = -Wextra -Wall -std=gnu++11 -fno-exceptions -fno-threadsafe-statics
+EXTRA_CXXFLAGS=-g3 -O0
+
+CXXFLAGS=-D_GNU_SOURCE -Werror=return-type -std=gnu++17 -Wall -g3 -O0
+
+# CLANG SANITIZE
+# CXX=clang
+# EXTRA_CXXFLAGS=-g3 -O0 -fsanitize=memory
+# LDFLAGS = -lpthread -lstdc++

tests/classbind-tests/Makefile

@@ -3,9 +3,6 @@
 
 EXTRA_CXXFLAGS=-g3 -O0 -DTINY_MQTT_TESTS
 
-# Remove flto flag from EpoxyDuino (too many <optimized out>)
-CXXFLAGS = -Wextra -Wall -std=gnu++11 -fno-exceptions -fno-threadsafe-statics
-
 APP_NAME := classbind-tests
 ARDUINO_LIBS := AUnit AceCommon AceTime TinyMqtt EspMock ESP8266WiFi  ESPAsyncTCP TinyConsole
 ARDUINO_LIB_DIRS := ../../../EspMock/libraries

tests/classbind-tests/classbind-tests.ino

@@ -17,9 +17,10 @@ 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 onPublish(const MqttClient* /* source */, const Topic& topic, const char* /* payload */, size_t /* length */)
     {
-      Serial << "--> routed message received by " << name_ << ':' << topic.c_str() << " = " << payload << endl;
+      (void) topic;
+      // Serial << "--> routed message received by " << name_ << ':' << topic.c_str() << " = " << payload << endl;
       messages[name_]++;
     }
 
@@ -35,7 +36,8 @@ 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;
+  (void) topic;
+  // Serial << "--> unrouted: " << topic.c_str() << endl;
   unrouted++;
 }
 
@@ -338,7 +340,7 @@ void setup() {
   while(!Serial);
   */
 
-  Serial.println("=============[ FAKE NETWORK TinyMqtt TESTS       ]========================");
+  Serial.println("=============[ TinyMqtt class-bind TESTS       ]========================");
 
   WiFi.mode(WIFI_STA);
   WiFi.begin("network", "password");

tests/compile-test/Makefile

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

tests/compile-test/tinymqtt-test.ino

@@ -0,0 +1,848 @@
+// vim: ts=2 sw=2 expandtab smartindent
+#include <TinyConsole.h>
+#include <TinyMqtt.h>       // https://github.com/hsaturn/TinyMqtt
+#include <TinyStreaming.h>
+
+#include <sstream>
+#include <string>
+#include <map>
+
+using string = TinyConsole::string;
+
+bool echo_on = true;
+auto green = TinyConsole::green;
+auto red = TinyConsole::red;
+auto white = TinyConsole::white;
+auto cyan = TinyConsole::cyan;
+auto yellow = TinyConsole::yellow;
+auto magenta = TinyConsole::magenta;
+auto save_cursor = TinyConsole::save_cursor;
+auto restore_cursor = TinyConsole::restore_cursor;
+auto erase_to_end = TinyConsole::erase_to_end;
+
+const char* ssid = "";
+const char* password = "";
+
+struct free_broker
+{
+  public:
+    free_broker(const char* s, uint16_t p, const char* /* comment */) : url(s), port(p) {}
+
+    string url;
+    uint16_t port;
+};
+
+const std::map<string, free_broker> list =
+{
+  { "mqtthq", { "public.mqtthq.com" , 8083, "publish/subscribe" }},
+  { "hivemq", { "broker.hivemq.com", 1883, "" }}
+};
+
+/** Very complex example
+  * Console allowing to make any kind of test,
+  * even some stress tests.
+  *
+  * Upload the sketch, the use the terminal.
+  * Press H for mini help.
+  *
+  * tested with mqtt-spy-0.5.4
+  * TODO examples of scripts
+  */
+
+void onPublish(const MqttClient* srce, const Topic& topic, const char* payload, size_t length)
+{
+  Console << cyan << "--> " << srce->id().c_str() << ": received " << topic.c_str() << white;
+  if (payload)
+  {
+    Console << ", payload[" << length << "]=[";
+    while(length--)
+    {
+      const char c=*payload++;
+      if (c<32)
+        Console << '?';
+      else
+        Console << c;
+    }
+    Console << ']' << endl;
+  }
+}
+
+std::map<string, MqttClient*> clients;
+std::map<string, MqttBroker*> brokers;
+std::map<string, string> vars;
+
+void eval(string& cmd);
+
+void replace(const char* d, string& str, string srch, string to)
+{
+  if (d[0] && d[1])
+  {
+    srch=d[0]+srch+d[1];
+    to=d[0]+to+d[1];
+
+    size_t pos = 0;
+    while((pos=str.find(srch, pos)) != string::npos)
+    {
+      str.erase(pos, srch.length());
+      str.insert(pos, to);
+      pos += to.length()-1;
+    }
+  }
+}
+
+void replaceVars(string& cmd)
+{
+  cmd = ' '+cmd+' ';
+
+  for(auto it: vars)
+  {
+    replace("..", cmd, it.first, it.second);
+    replace(". ", cmd, it.first, it.second);
+    replace(" .", cmd, it.first, it.second);
+    replace("  ", cmd, it.first, it.second);
+  }
+  cmd.erase(0, cmd.find_first_not_of(' '));
+  cmd.erase(cmd.find_last_not_of(' ')+1);
+
+}
+
+void onCommand(const string& command)
+{
+  Console << endl;
+  string cmd=command;
+  if (cmd.substr(0,3)!="set") replaceVars(cmd);
+  eval(cmd);
+  Console << endl;
+  Console.prompt();
+}
+
+void setup()
+{
+  Serial.begin(115200);
+  Console.begin(Serial);
+  Console.setPrompt("> ");
+  Console.setCallback(onCommand);
+  delay(500);
+
+  Console.cls();
+  Console << endl << endl;
+  Console << yellow
+          << "***************************************************************" << endl;
+  Console << "*  Welcome to the TinyMqtt console" << endl;
+  Console << "*  The console allows to test all features of the libraries." << endl;
+  Console << "*  Enter help to view the list of commands." << endl;
+  Console << "***************************************************************" << endl;
+  Console << endl;
+  if (strlen(ssid)==0)
+    Console << red << "*  ERROR: You must modify ssid/password in order" << endl
+                   << "          to be able to connect to your Wifi network." << endl;
+  Console << endl << white;
+
+  Console << "Connecting to '" << ssid << "' ";
+
+  WiFi.mode(WIFI_STA);
+  WiFi.begin(ssid, password);
+  WiFi.mode(WIFI_STA);
+  WiFi.begin(ssid, password);
+
+  while (WiFi.status() != WL_CONNECTED)
+  { Console << '-'; delay(500); }
+
+  Console << endl << "Connected to " << ssid << "IP address: " << WiFi.localIP() << endl;
+
+  const char* name="tinytest";
+  Console << "Starting MDNS, name= " << name;
+
+  MqttBroker* broker = new MqttBroker(1883);
+  broker->begin();
+  brokers["broker"] = broker;
+
+  if (Console.isTerm()) onCommand("every 333 view");
+}
+
+string getword(string& str, const char* if_empty=nullptr, char sep=' ');
+
+int getint(string& str, const int if_empty=0)
+{
+  string str2=str;
+  string sword = getword(str);
+  if (sword[0] and isdigit(sword[0]))
+  {
+    int ret=atoi(sword.c_str());
+    while(isdigit(sword[0]) or sword[0]==' ') sword.erase(0,1);
+    if (sword.length()) str = sword+' '+str;
+    return ret;
+  }
+  str=str2;
+  return if_empty;
+}
+
+string getword(string& str, const char* if_empty/*=nullptr*/, char sep/*=' '*/)
+{
+  char quote=(str[0]=='"' or str[0]=='\'' ? str[0] : 0);
+  if (quote) str.erase(0,1);
+  string sword;
+  while(str.length() and (str[0]!=sep or quote))
+  {
+    if (str[0]==quote)
+    {
+      str.erase(0,1);
+      break;
+    }
+    sword += str[0];
+    str.erase(0,1);
+  }
+  while(str[0]==sep) str.erase(0,1);
+  if (if_empty and sword.length()==0) return if_empty;
+  if (quote==false and sword.length()>=4 and sword.substr(0,3)=="rnd")
+  {
+    sword.erase(0,3);
+    if (sword[0]=='(')
+    {
+      int to = 100;
+      sword.erase(0,1);
+      int from=getint(sword);
+      if (sword[0]==',')
+      {
+        sword.erase(0,1);
+        to = getint(sword);
+        if (sword[0]!=')') Console << "Missing ')'" << endl;
+      }
+      else
+      {
+        to=from;
+        from=0;
+      }
+      return String(random(from,to)).c_str();
+    }
+    else
+    {
+      Console << "Missing '('" << endl;
+    }
+  }
+  while(str[0]==' ') str.erase(0,1);
+  return sword;
+}
+
+bool isaddr(string s)
+{
+  if (s.length()==0 or s.length()>3) return false;
+  for(char c: s)
+    if (c<'0' or c>'9') return false;
+  return true;
+}
+
+string getip(string& str, const char* if_empty=nullptr, char sep=' ')
+{
+  string addr=getword(str, if_empty, sep);
+  string ip=addr;
+  std::vector<string> build;
+  while(ip.length())
+  {
+    string b=getword(ip,nullptr,'.');
+    if (isaddr(b) && build.size()<4)
+    {
+      build.push_back(b);
+    }
+    else
+      return addr;
+  }
+  IPAddress local=WiFi.localIP();
+  addr.clear();
+  while(build.size()!=4)
+  {
+    std::stringstream b;
+    b << (int)local[3-build.size()];
+    build.insert(build.begin(), b.str().c_str());
+  }
+  for(string s: build)
+  {
+    if (addr.length()) addr += '.';
+    addr += s;
+  }
+  Console << "connect address: " << addr << endl;
+  return addr;
+}
+
+std::set<string> commands = {
+  "broker", "blink", "client", "connect",
+  "create", "delete", "debug", "help", "interval",
+  "list", "ls", "ip", "off", "on", "set",
+  "publish", "reset", "subscribe", "unsubscribe", "view", "echo", "every"
+};
+
+void convertToCommand(string& search)
+{
+  while(search[0]==' ') search.erase(0,1);
+  if (search.length()==0) return;
+  string matches;
+  int count=0;
+  for(string cmd: commands)
+  {
+    if (cmd.substr(0, search.length()) == search)
+    {
+      if (count) matches +=", ";
+      count++;
+      matches += cmd;
+    }
+  }
+  if (count==1)
+    search = matches;
+  else if (count>1)
+  {
+    Console << "Ambiguous command: " << matches << endl;
+    search.clear();
+  }
+}
+
+bool compare(string s, const char* cmd)
+{
+  uint8_t p=0;
+  while(s[p++]==*cmd++)
+  {
+    if (*cmd==0 or s[p]==0) return true;
+    if (s[p]==' ') return true;
+  }
+  return false;
+}
+
+using ClientFunction = void(*)(string& cmd, MqttClient* publish);
+
+struct Every
+{
+  string cmd;
+  uint32_t ms;
+  uint32_t next;
+  uint32_t underrun=0;
+  bool active=true;
+
+  void dump()
+  {
+    if (active)
+      Console << green << "enabled";
+    else
+      Console << red << "disabled";
+
+    auto mill=millis();
+    Console << white << ms << "ms [" << cmd << "] next in ";
+    if (mill > next)
+      Console << "now";
+    else
+      Console << next-mill << "ms";
+  }
+};
+
+uint32_t blink_ms_on[16];
+uint32_t blink_ms_off[16];
+uint32_t blink_next[16];
+bool blink_state[16];
+int16_t blink;
+
+std::vector<Every> everies;
+
+void clientConnect(MqttClient* client, string& cmd)
+{
+  string remote = getword(cmd);
+  uint16_t port;
+  auto it=list.find(remote);
+  if (it != list.end())
+  {
+    Console << "Connecting to free broker: " << remote << endl;
+    remote = it->second.url;
+    port=it->second.port;
+  }
+  else
+    port=getint(cmd);
+
+  client->connect(remote.c_str(), port, getint(cmd, 60));
+  Console << (client->connected() ? "connected." : "not connected") << endl;
+}
+
+void eval(string& cmd)
+{
+  while(cmd.length())
+  {
+    MqttError retval = MqttOk;
+
+    string s;
+    MqttBroker* broker = nullptr;
+    MqttClient* client = nullptr;
+
+    // client.function notation
+    if (cmd.find('.') != string::npos &&
+        cmd.find('.') < cmd.find(' '))
+    {
+      s=getword(cmd, nullptr, '.');
+
+      if (s.length())
+      {
+        if (clients.find(s) != clients.end())
+        {
+          client = clients[s];
+        }
+        else if (brokers.find(s) != brokers.end())
+        {
+          broker = brokers[s];
+        }
+        else
+        {
+          Console << red << "Unknown class (" << s.c_str() << ")" << white << endl;
+          cmd.clear();
+        }
+      }
+    }
+
+    s = getword(cmd);
+    if (s.length()) convertToCommand(s);
+    if (s.length()==0)
+    {}
+    else if (compare(s, "debug"))
+    {
+#if TINY_MQTT_DEBUG
+      TinyMqtt::debug = getint(cmd);
+#else
+      Console << red << "TinyMqtt not compiled in debug" << endl;
+#endif
+    }
+    else if (compare(s, "list"))
+    {
+      Console << "List of free servers" << endl;
+      for(const auto& fb: list)
+      {
+        Console << "  " << fb.first << " : " << fb.second.url << ":" << fb.second.port << endl;
+      }
+    }
+    else if (compare(s, "delete"))
+    {
+      if (client==nullptr && broker==nullptr)
+      {
+        s = getword(cmd);
+        if (clients.find(s) != clients.end())
+        {
+          client = clients[s];
+        }
+        else if (brokers.find(s) != brokers.end())
+        {
+          broker = brokers[s];
+        }
+        else
+          Console << red << "Unable to find (" << s.c_str() << ")" << white << endl;
+      }
+      if (client)
+      {
+        for (auto it: clients)
+        {
+          if (it.second != client) continue;
+          Console << "deleted" << endl;
+          delete (it.second);
+          clients.erase(it.first);
+          break;
+        }
+        cmd += " ls";
+      }
+      else if (broker)
+      {
+        for(auto it: brokers)
+        {
+          if (broker != it.second) continue;
+          Console << "deleted" << endl;
+          delete (it.second);
+          brokers.erase(it.first);
+          break;
+        }
+        cmd += " ls";
+      }
+      else
+        Console << "Nothing to delete" << endl;
+    }
+    else if (broker)
+    {
+      if (compare(s,"connect"))
+      {
+        Console << "NYI" << endl;
+      }
+      else if (compare(s, "view"))
+      {
+        broker->dump();
+      }
+      else
+      {
+        Console << "Unknown broker command (" << s << ")" << endl;
+        s.clear();
+      }
+    }
+    else if (client)
+    {
+      if (compare(s,"connect"))
+      {
+        clientConnect(client, cmd);
+      }
+      else if (compare(s,"publish"))
+      {
+        retval = client->publish(getword(cmd), getword(cmd));
+      }
+      else if (compare(s,"subscribe"))
+      {
+        client->subscribe(getword(cmd));
+      }
+      else if (compare(s, "unsubscribe"))
+      {
+        client->unsubscribe(getword(cmd));
+      }
+      else if (compare(s, "view"))
+      {
+        client->dump();
+      }
+      else
+      {
+        Console << "Unknown client command (" << s << ")" << endl;
+        s.clear();
+      }
+    }
+    else if (compare(s, "on"))
+    {
+      uint8_t pin=getint(cmd, 2);
+      pinMode(pin, OUTPUT);
+      digitalWrite(pin, HIGH);
+    }
+    else if (compare(s, "off"))
+    {
+      uint8_t pin=getint(cmd, 2);
+      pinMode(pin, OUTPUT);
+      digitalWrite(pin, LOW);
+    }
+    else if (compare(s, "echo"))
+    {
+      s=getword(cmd);
+      if (s=="on")
+        echo_on = true;
+      else if (s=="off")
+        echo_on = false;
+      else
+      {
+        Console << s << ' ';
+        while(cmd.length())
+        {
+          Console << getword(cmd) << ' ';
+        }
+      }
+    }
+    else if (compare(s, "every"))
+    {
+      uint32_t ms = getint(cmd, 0);
+      if (ms)
+      {
+        if (cmd.length())
+        {
+          Every every;
+          every.ms=ms;
+          every.cmd=cmd;
+          every.next=millis()+ms;
+          everies.push_back(every);
+          every.dump();
+          Console << endl;
+          cmd.clear();
+        }
+      }
+      else if (compare(cmd, "off") or compare(cmd, "on"))
+      {
+        bool active=getword(cmd)=="on";
+        uint8_t ever=getint(cmd, 100);
+        uint8_t count=0;
+        for(auto& every: everies)
+        {
+          if (count==ever or (ever==100))
+          {
+            if (every.active != active)
+            {
+              Console << "every #" << count << (active ? " on" :" off") << endl;
+              every.active = active;
+              every.underrun = 0;
+            }
+          }
+          count++;
+        }
+      }
+      else if (compare(cmd, "list") or cmd.length()==0)
+      {
+        getword(cmd);
+        Console << "List of everies (ms=" << millis() << ")" << endl;
+        uint8_t count=0;
+        for(auto& every: everies)
+        {
+          Console << count << ": ";
+          every.dump();
+          Console << endl;
+          count++;
+        }
+      }
+      else if (compare(cmd, "remove"))
+      {
+        Console << "Removing..." << endl;
+        getword(cmd);
+        int8_t every=getint(cmd, -1);
+        if (every==-1 and compare(cmd, "last") and everies.size())
+        {
+          getword(cmd);
+          everies.erase(everies.begin()+everies.size()-1);
+        }
+        else if (every==-1 and compare(cmd, "all"))
+        {
+          getword(cmd);
+          everies.clear();
+        }
+        else if (everies.size() > (uint8_t)every)
+        {
+          everies.erase(everies.begin()+every);
+        }
+        else
+          Console << "Bad colmmand" << endl;
+      }
+      else
+        Console << "Bad command" << endl;
+    }
+    else if (compare(s, "blink"))
+    {
+      int8_t blink_nr = getint(cmd, -1);
+      if (blink_nr >= 0)
+      {
+        blink_ms_on[blink_nr]=getint(cmd, blink_ms_on[blink_nr]);
+        blink_ms_off[blink_nr]=getint(cmd, blink_ms_on[blink_nr]);
+        pinMode(blink_nr, OUTPUT);
+        blink_next[blink_nr] = millis();
+        Console << "Blink " << blink_nr << ' ' << (blink_ms_on[blink_nr] ? "on" : "off") << endl;
+        if (blink_ms_on[blink_nr])
+          blink |= 1<< blink_nr;
+        else
+        {
+          blink &= ~(1<< blink_nr);
+        }
+      }
+    }
+    else if (compare(s, "broker"))
+    {
+      string id=getword(cmd);
+      if (clients.find(id) != clients.end())
+      {
+        Console << "A client already have that name" << endl;
+        cmd.clear();
+      }
+      else if (id.length() or brokers.find(id)!=brokers.end())
+      {
+        int port=getint(cmd, 0);
+        if (port)
+        {
+          MqttBroker* broker = new MqttBroker(port);
+          broker->begin();
+
+          brokers[id] = broker;
+          Console << "new broker (" << id.c_str() << ")" << endl;
+        }
+        else
+        {
+          Console << "Missing port" << endl;
+          cmd.clear();
+        }
+      }
+      else
+      {
+        Console << "Missing or existing broker name (" << id.c_str() << ")" << endl;
+        cmd.clear();
+      }
+    }
+    else if (compare(s, "client"))
+    {
+      string id=getword(cmd);
+      if (brokers.find(id) != brokers.end())
+      {
+        Console << "A broker have that name" << endl;
+        cmd.clear();
+      }
+      else if (id.length() or clients.find(id)!=clients.end())
+      {
+        s=getword(cmd);  // broker
+        if (s=="" or brokers.find(s) != brokers.end() or list.find(s) != list.end())
+        {
+          MqttBroker* broker = nullptr;
+          if (s.length()) broker = brokers[s];
+          MqttClient* client = new MqttClient(broker, id);
+          clients[id]=client;
+          client->setCallback(onPublish);
+          if (list.find(s) != list.end())
+          {
+            cmd=s+' '+cmd;
+            clientConnect(client, cmd);
+          }
+          Console << "new client (" << id.c_str() << ", " << s.c_str() << ')' << endl;
+        }
+        else if (s.length())
+        {
+          Console << " not found." << endl;
+          cmd.clear();
+        }
+      }
+      else
+      {
+        Console << "Missing or existing client name" << endl;
+        cmd.clear();
+      }
+    }
+    else if (compare(s, "set"))
+    {
+      string name(getword(cmd));
+      if (name.length()==0)
+      {
+        for(auto it: vars)
+        {
+          Console << "  " << it.first << " -> " << it.second << endl;
+        }
+      }
+      else if (commands.find(name) != commands.end())
+      {
+        Console << "Reserved keyword (" << name << ")" << endl;
+        cmd.clear();
+      }
+      else
+      {
+        if (cmd.length())
+        {
+          vars[name] = cmd;
+          cmd.clear();
+        }
+        else if (vars.find(name) != vars.end())
+          vars.erase(vars.find(name));
+      }
+    }
+    else if (compare(s, "ls") or compare(s, "view"))
+    {
+      bool view = compare(s, "view");
+      if (view)
+      {
+        Console << save_cursor << magenta;
+        Console.gotoxy(1,1);
+      }
+      Console << "--< " << '/' << clients.size() << " client/s. >--" << erase_to_end << endl;
+      for(auto it: clients)
+      {
+        it.second->dump("  ");
+      }
+
+      Console << "--< " << brokers.size() << " brokers/s. >--" << erase_to_end << endl;
+      for(auto it: brokers)
+      {
+        Console << "  +-- '" << it.first.c_str() << "' " << it.second->clientsCount() << " client/s."<< erase_to_end << endl;
+        it.second->dump("     ");
+      }
+      if (view)
+      {
+        Console.bg(white);
+        Console << erase_to_end << restore_cursor;
+      }
+    }
+    else if (compare(s, "reset"))
+      ESP.restart();
+    else if (compare(s, "ip"))
+      Console << "IP: " << WiFi.localIP() << endl;
+    else if (compare(s,"help"))
+    {
+      Console << "syntax:" << endl;
+      Console << "  MqttBroker:" << endl;
+      Console << "    broker {broker_name} {port} : create a new broker" << endl;
+      Console << "      broker_name can be one of 'list'" << endl;
+      Console << "      broker_name.delete : delete a broker (buggy)" << endl;
+      Console << "      broker_name.view   : dump a broker" << endl;
+      Console << endl;
+      Console << "  MqttClient:" << endl;
+      Console << "    client {name} {broker} : create a client then" << endl;
+      Console << "      name.connect  [ip] [port] [alive]" << endl;
+      Console << "      name.[un]subscribe topic" << endl;
+      Console << "      name.publish topic [payload]" << endl;
+      Console << "      name.view" << endl;
+      Console << "      name.delete" << endl;
+      Console << endl;
+      Console << "  list : list of free brokers (debug 1 advised)" << endl;
+      Console << "  debug #" << endl;
+      Console << "  list : get list of free brokers" << endl;
+      Console << "  blink [Dx on_ms off_ms]    : make pin blink" << endl;
+      Console << "  ls / ip / reset" << endl;
+      Console << "  set [name][value]" << endl;
+      Console << "  !  repeat last command" << endl;
+      Console << endl;
+      Console << "  echo [on|off] or strings" << endl;
+      Console << "  every ms [command]; every list; every remove [nr|all]; every (on|off) [#]" << endl;
+      Console << "  on {output}; off {output}" << endl;
+      Console << "  $id : name of the client." << endl;
+      Console << "  rnd[(min[,max])] random number." << endl;
+      Console << endl;
+    }
+    else
+    {
+      while(s[0]==' ') s.erase(0,1);
+      if (s.length())
+        Console << "Unknown command (" << s.c_str() << ")" << endl;
+    }
+
+    if (retval != MqttOk)
+    {
+      Console << "# MQTT ERROR " << retval << endl;
+    }
+  }
+}
+
+void loop()
+{
+  auto ms=millis();
+  int8_t out=0;
+  int16_t blink_bits = blink;
+  uint8_t e=0;
+
+  for(auto& every: everies)
+  {
+    if (not every.active) continue;
+    if (every.ms && every.cmd.length() && ms > every.next)
+    {
+      string cmd(every.cmd);
+      eval(cmd);
+      every.next += every.ms;
+      if (ms > every.next and ms > every.underrun)
+      {
+        every.next += every.ms;
+        Console << yellow << "Underrun every #" << e << ", " <<  (ms - every.next) << "ms late" << endl;
+        every.underrun = ms+5000;
+      }
+    }
+    e++;
+  }
+
+  while(blink_bits)
+  {
+    if (blink_ms_on[out] and ms > blink_next[out])
+    {
+      if (blink_state[out])
+      {
+        blink_next[out] += blink_ms_on[out];
+        digitalWrite(out, LOW);
+      }
+      else
+      {
+        blink_next[out] += blink_ms_off[out];
+        digitalWrite(abs(out), HIGH);
+      }
+      blink_state[out] = not blink_state[out];
+    }
+    blink_bits >>=1;
+    out++;
+  }
+
+#if defined(ESP9266)
+  MDNS.update();
+#endif
+
+  for(auto it: brokers)
+    it.second->loop();
+
+  for(auto it: clients)
+    it.second->loop();
+
+  Console.loop();
+}

tests/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
+include ../Makefile.opts
-
-# Remove flto flag from EpoxyDuino (too many <optimized out>)
-CXXFLAGS = -Wextra -Wall -std=gnu++11 -fno-exceptions -fno-threadsafe-statics
 
 APP_NAME := local-tests
 ARDUINO_LIBS := AUnit AceCommon AceTime TinyMqtt EspMock ESP8266WiFi  ESPAsyncTCP TinyConsole

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,9 +49,9 @@ test(local_client_should_unregister_when_destroyed)
   assertEqual(broker.clientsCount(), (size_t)0);
 }
 
-test(local_client_do_not_disconnect_after_publishing)
+test(local_client_do_not_disconnect_after_publishing_and_long_inactivity)
 {
-  set_millis(0);
+  EpoxyTest::set_millis(0);
   MqttBroker broker(1883);
   MqttClient client(&broker, "client");
   MqttClient sender(&broker, "sender");
@@ -56,11 +65,16 @@ test(local_client_do_not_disconnect_after_publishing)
   sender.publish("test", "value");
   broker.loop();
 
-  add_seconds(60);
+  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);
@@ -68,27 +82,36 @@ test(local_client_do_not_disconnect_after_publishing)
   assertEqual(published.size(), (size_t)1);  // client has received something
 }
 
-#if 0
 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");
@@ -103,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");
 
@@ -128,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");
@@ -148,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");
@@ -160,7 +183,6 @@ test(local_nocallback_when_destroyed)
 
   assertEqual(published.size(), (size_t)1);  // Only one publish has been received
 }
-#endif
 
 //----------------------------------------------------------------------------
 // setup() and loop()

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

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
 }

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
+include ../Makefile.opts
-
-# Remove flto flag from EpoxyDuino (too many <optimized out>)
-CXXFLAGS = -Wextra -Wall -std=gnu++11 -fno-exceptions -fno-threadsafe-statics
 
 APP_NAME := nowifi-tests
 ARDUINO_LIBS := AUnit AceCommon AceTime TinyMqtt EspMock ESP8266WiFi  ESPAsyncTCP TinyConsole

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
 }

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

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

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

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 ");
+    std::cout << (expected ? " matches " : " unmatches ");
-  cout << tb.c_str() << endl;
+  std::cout << tb.c_str() << std::endl;
   return expected == match;
 }