EpoxyDuino upgrade

This change needs some modification in EpoxyDuino that are not yet accepted.

.github/workflows/aunit.yml

@@ -9,7 +9,7 @@ on: [push]
 jobs:
   build:
 
-    runs-on: ubuntu-18.04
+    runs-on: ubuntu-20.04
 
     steps:
     - uses: actions/checkout@v2
@@ -17,7 +17,8 @@ jobs:
     - name: Setup
       run: |
         cd ..
-        git clone https://github.com/bxparks/EpoxyDuino
+        git clone https://github.com/hsaturn/TinyConsole
+        git clone https://github.com/hsaturn/EpoxyDuino
         git clone https://github.com/bxparks/AceRoutine
         git clone https://github.com/bxparks/AUnit
         git clone https://github.com/bxparks/AceCommon

examples/advanced/mqtt_class_binder/mqtt_class_binder.ino

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

examples/simple-broker/simple-broker.ino

@@ -26,7 +26,7 @@ void setup()
   Serial.begin(115200);
 
 	if (strlen(ssid)==0)
-		Serial << "****** PLEASE MODIFY ssid/password *************" << endl;
+		Console << TinyConsole::red << "****** PLEASE MODIFY ssid/password *************" << endl;
 
   WiFi.mode(WIFI_STA);
   WiFi.begin(ssid, password);
@@ -35,10 +35,10 @@ void setup()
     Serial << '.';
     delay(500);
   }
-  Serial << "Connected to " << ssid << "IP address: " << WiFi.localIP() << endl;  
+  Console << TinyConsole::green << "Connected to " << ssid << "IP address: " << WiFi.localIP() << endl;
 
   broker.begin();
-  Serial << "Broker ready : " << WiFi.localIP() << " on port " << PORT << endl;
+  Console << "Broker ready : " << WiFi.localIP() << " on port " << PORT << endl;
 }
 
 void loop()

examples/simple-client/simple-client.ino

@@ -1,4 +1,5 @@
-#include "TinyMqtt.h"   // https://github.com/hsaturn/TinyMqtt
+#include "TinyMqtt.h"    // https://github.com/hsaturn/TinyMqtt
+#include "TinyStreaming.h" // https://github.com/hsaturn/TinyConsole
 
 /** Simple Client (The simplest configuration)
   *
@@ -55,7 +56,7 @@ void setup()
 
   Serial << "Connected to " << ssid << "IP address: " << WiFi.localIP() << endl;
 
-	client.connect(BROKER, BROKER_PORT);	// Put here your broker ip / port
+	client.connect(BROKER, BROKER_PORT);
 }
 
 void loop()

library.properties

@@ -1,5 +1,5 @@
 name=TinyMqtt
-version=0.9.5
+version=0.9.11
 author=Francois BIOT, HSaturn, <hsaturn@gmail.com>
 maintainer=Francois BIOT, HSaturn, <hsaturn@gmail.com>
 sentence=A tiny broker and client library for MQTT messaging.
@@ -7,4 +7,5 @@ paragraph=MQTT is a lightweight messaging protocol ideal for small devices. This
 category=Communication
 url=https://github.com/hsaturn/TinyMqtt
 architectures=*
+depends=TinyConsole
 includes=TinyMqtt.h

src/MqttClassBinder.h

@@ -0,0 +1,72 @@
+// MqttReceiver must implement onPublish(...)
+template <class MqttReceiver>
+class MqttClassBinder
+{
+  public:
+    MqttClassBinder()
+    {
+      unregister(this);
+    }
+    ~MqttClassBinder() { unregister(this); }
+
+    static void onUnpublished(MqttClient::CallBack handler)
+    {
+      unrouted_handler = handler;
+    }
+
+    static void onPublish(MqttClient* client, MqttReceiver* dest)
+    {
+      routes.insert(std::pair<MqttClient*, MqttReceiver*>(client, dest));
+      client->setCallback(onRoutePublish);
+    }
+
+    void onPublish(const MqttClient* client, const Topic& topic, const char* payload, size_t length)
+    {
+      static_cast<MqttReceiver*>(this)->MqttReceiver::onPublish(client, topic, payload, length);
+    }
+
+    static size_t size() { return routes.size(); }
+
+    static void reset() { routes.clear(); }
+
+  private:
+
+    static void onRoutePublish(const MqttClient* client, const Topic& topic, const char* payload, size_t length)
+    {
+      bool unrouted = true;
+      auto receivers = routes.equal_range(client);
+      for(auto it = receivers.first; it != receivers.second; ++it)
+      {
+        it->second->onPublish(client, topic, payload, length);
+        unrouted = false;
+      }
+
+      if (unrouted and unrouted_handler)
+      {
+        unrouted_handler(client, topic, payload, length);
+      }
+    }
+
+  private:
+    void unregister(MqttClassBinder<MqttReceiver>* which)
+    {
+      if (routes.size()==0) return;   // bug in map stl
+      for(auto it=routes.begin(); it!=routes.end(); it++)
+        if (it->second == which)
+        {
+          routes.erase(it);
+          return;
+        }
+    }
+
+  static std::multimap<const MqttClient*, MqttClassBinder<MqttReceiver>*> routes;
+  static MqttClient::CallBack unrouted_handler;
+
+};
+
+template<class MqttReceiver>
+std::multimap<const MqttClient*, MqttClassBinder<MqttReceiver>*> MqttClassBinder<MqttReceiver>::routes;
+
+template<class MqttReceiver>
+MqttClient::CallBack MqttClassBinder<MqttReceiver>::unrouted_handler = nullptr;
+

src/MqttStreaming.h

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

src/StringIndexer.h

@@ -1,3 +1,4 @@
+// vim: ts=2 sw=2 expandtab
 #pragma once
 #include <map>
 #include <string>

src/TinyMqtt.cpp

@@ -1,13 +1,23 @@
+// vim: ts=2 sw=2 expandtab
 #include "TinyMqtt.h"
 #include <sstream>
 
+#if TINY_MQTT_DEBUG
+static auto cyan = TinyConsole::cyan;
+static auto white = TinyConsole::white;
+static auto red = TinyConsole::red;
+static auto yellow = TinyConsole::yellow;
+
+int TinyMqtt::debug=2;
+#endif
+
 #ifdef EPOXY_DUINO
   std::map<MqttMessage::Type, int> MqttClient::counters;
 #endif
 
 MqttBroker::MqttBroker(uint16_t port)
 {
-  server = new TcpServer(port);
+  server.reset(new TcpServer(port));
 #ifdef TINY_MQTT_ASYNC
   server->onClient(onClient, this);
 #endif
@@ -19,134 +29,129 @@ MqttBroker::~MqttBroker()
   {
     delete clients[0];
   }
-  delete server;
 }
 
 // private constructor used by broker only
-MqttClient::MqttClient(MqttBroker* parent, TcpClient* new_client)
+MqttClient::MqttClient(MqttBroker* local_broker, TcpClient* new_client)
-  : parent(parent)
 {
+  dclass;
+  connect(local_broker);
+  debug("MqttClient private with broker");
 #ifdef TINY_MQTT_ASYNC
-  client = new_client;
+  tcp_client.reset(new_client);
-  client->onData(onData, this);
+  tcp_client->onData(onData, this);
   // client->onConnect() TODO
   // client->onDisconnect() TODO
 #else
-  client = new WiFiClient(*new_client);
+  tcp_client.reset(new WiFiClient(*new_client));
-#endif
-#ifdef EPOXY_DUINO
-  alive = millis()+500000;
-#else
-  alive = millis()+5000;  // TODO MAGIC client expires after 5s if no CONNECT msg
 #endif
+  alive = millis()+5000;
 }
 
-MqttClient::MqttClient(MqttBroker* parent, const std::string& id)
+MqttClient::MqttClient(MqttBroker* local_broker, const std::string& id)
-  : parent(parent), clientId(id)
+  : local_broker(local_broker), clientId(id)
 {
-    client = nullptr;
+  dclass;
+  alive = 0;
+  keep_alive = 0;
 
-    if (parent) parent->addClient(this);
+  if (local_broker) local_broker->addClient(this);
 }
 
 MqttClient::~MqttClient()
 {
+  dtor;
   close();
-  delete client;
+  debug("*** MqttClient delete()");
 }
 
 void MqttClient::close(bool bSendDisconnect)
 {
   debug("close " << id().c_str());
-  mqtt_connected = false;
+  mqtt_flags &= ~FlagConnected;
-  if (client)  // connected to a remote broker
+  if (tcp_client)  // connected to a remote broker
   {
-    if (bSendDisconnect and client->connected())
+    if (bSendDisconnect and tcp_client->connected())
     {
       message.create(MqttMessage::Type::Disconnect);
+      message.hexdump("close");
       message.sendTo(this);
     }
-    client->stop();
+    tcp_client->stop();
   }
 
-  if (parent)
+  if (local_broker)
   {
-    parent->removeClient(this);
+    local_broker->removeClient(this);
-    parent = nullptr;
+    local_broker = nullptr;
   }
 }
 
-void MqttClient::connect(MqttBroker* parentBroker)
+void MqttClient::connect(MqttBroker* local)
 {
+  debug("MqttClient::connect_local");
+  alive = 0;
   close();
-  parent = parentBroker;
+  local_broker = local;
+  clientAlive();
 }
 
 void MqttClient::connect(std::string broker, uint16_t port, uint16_t ka)
 {
-  debug("MqttClient::connect");
+  debug("MqttClient::connect_to_host " << broker << ':' << port);
   keep_alive = ka;
   close();
-  if (client) delete client;
+  tcp_client.reset(new TcpClient);
-  client = new TcpClient;
 
-  debug("Trying to connect to " << broker.c_str() << ':' << port);
 #ifdef TINY_MQTT_ASYNC
-  client->onData(onData, this);
+  tcp_client->onData(onData, this);
-  client->onConnect(onConnect, this);
+  tcp_client->onConnect(onConnect, this);
-  client->connect(broker.c_str(), port);
+  tcp_client->connect(broker.c_str(), port, ka);
 #else
-  if (client->connect(broker.c_str(), port))
+  if (tcp_client->connect(broker.c_str(), port))
   {
-    onConnect(this, client);
+    debug("link established");
+    onConnect(this, tcp_client.get());
+  }
+  else
+  {
+    debug("unable to connect.");
   }
 #endif
 }
 
-void MqttBroker::addClient(MqttClient* client)
-{
-    clients.push_back(client);
-}
-
 void MqttBroker::connect(const std::string& host, uint16_t port)
 {
-  if (broker == nullptr) broker = new MqttClient;
+  debug("MqttBroker::connect");
-  broker->connect(host, port);
+  if (remote_broker == nullptr) remote_broker = new MqttClient;
-  broker->parent = this;  // Because connect removed the link
+  remote_broker->connect(host, port);
+  remote_broker->local_broker = this;  // Because connect removed the link
 }
 
 void MqttBroker::removeClient(MqttClient* remove)
 {
-  for(auto it=clients.begin(); it!=clients.end(); it++)
+  local_clients.erase(remove);
-  {
+  for(auto it = clients.begin(); it!=clients.end(); it++)
-    auto client=*it;
+    if (*it == remove)
-    if (client==remove)
     {
-      // TODO if this broker is connected to an external broker
-      // we have to unsubscribe remove's topics.
-      // (but doing this, check that other clients are not subscribed...)
-      // Unless -> we could receive useless messages
-      //        -> we are using (memory) one IndexedString plus its string for nothing.
-      debug("Remove " << clients.size());
       clients.erase(it);
-      debug("Client removed " << clients.size());
+      break;
-      return;
     }
-  }
-  debug("Error cannot remove client");  // TODO should not occur
 }
 
 void MqttBroker::onClient(void* broker_ptr, TcpClient* client)
 {
+  debug("MqttBroker::onClient");
   MqttBroker* broker = static_cast<MqttBroker*>(broker_ptr);
 
-  broker->addClient(new MqttClient(broker, client));
+  broker->clients.push_back(new MqttClient(broker, client));
   debug("New client");
 }
 
 void MqttBroker::loop()
 {
 #ifndef TINY_MQTT_ASYNC
+  if (not server) return;
   WiFiClient client = server->available();
 
   if (client)
@@ -154,78 +159,74 @@ void MqttBroker::loop()
     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();
   }
 
-
+  // keep track on size because loop can remove a client from containers
-  // for(auto it=clients.begin(); it!=clients.end(); it++)
+  // loop on remote clients (connected through network)
-  // use index because size can change during the loop
+  auto size = clients.size();
-  for(size_t i=0; i<clients.size(); i++)
+  for(auto it = clients.begin(); it!=clients.end(); it++)
   {
-    auto client = clients[i];
+    MqttClient* client = *it;
     if (client->connected())
     {
       client->loop();
     }
     else
     {
-      debug("Client " << client->id().c_str() << "  Disconnected, parent=" << (dbg_ptr)client->parent);
+      debug("Client " << client->id().c_str() << "  Disconnected, local_broker=" << (dbg_ptr)client->local_broker);
       // Note: deleting a client not added by the broker itself will probably crash later.
-      delete client;
-      break;
     }
+    if (size != clients.size()) break;
+  }
+
+  // loop on local clients (on same device as the broker's)
+  size = local_clients.size();
+  for(auto& client: local_clients)
+  {
+    client->loop();
+    if (local_clients.size() != size) break;
   }
 }
 
 MqttError MqttBroker::subscribe(const Topic& topic, uint8_t qos)
 {
-  if (broker && broker->connected())
+  debug("MqttBroker::subscribe");
+  if (remote_broker && remote_broker->connected())
   {
-    return broker->subscribe(topic, qos);
+    return remote_broker->subscribe(topic, qos);
   }
   return MqttNowhereToSend;
 }
 
 MqttError MqttBroker::publish(const MqttClient* source, const Topic& topic, MqttMessage& msg) const
 {
-  MqttError retval = MqttOk;
+  MqttError retval = MqttOk;  // TODO here retval is badly computed
 
-  debug("publish ");
+  debug("MqttBroker::publish");
-  int i=0;
+
-  for(auto client: clients)
+  if (remote_broker == nullptr or source == remote_broker)  // external broker -> internal clients
   {
-    i++;
+    for(auto& client: clients)
-#ifdef TINY_MQTT_DEBUG
-    Serial << "brk_" << (broker && broker->connected() ? "con" : "dis") <<
-       "  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)
     {
-      // ext_broker -> clients or clients -> ext_broker
+      retval = client->publishIfSubscribed(topic, msg);
-      if (source == 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);
-        if (ret != MqttOk) retval = ret;
-      }
     }
-    else // Disconnected
+    for(auto& client: local_clients)
     {
-      doit = true;
+      retval = client->publishIfSubscribed(topic, msg);
+    }
+  }
+  else
+  {
+    if (remote_broker && remote_broker->connected())
+    {
+      MqttError ret = remote_broker->publishIfSubscribed(topic, msg);
+      if (ret != MqttOk) retval = ret;
     }
-#ifdef TINY_MQTT_DEBUG
-    Serial << ", doit=" << doit << ' ';
-#endif
-
-    if (doit) retval = client->publishIfSubscribed(topic, msg);
-    debug("");
   }
   return retval;
 }
@@ -242,19 +243,16 @@ bool MqttBroker::compareString(
 
 void MqttMessage::getString(const char* &buff, uint16_t& len)
 {
-  len = (buff[0]<<8)|(buff[1]);
+  len = getSize(buff);
   buff+=2;
 }
 
-void MqttClient::clientAlive(uint32_t more_seconds)
+void MqttClient::clientAlive()
 {
+  debug("MqttClient::clientAlive");
   if (keep_alive)
   {
-#ifdef EPOXY_DUINO
+    alive=millis()+1000*(keep_alive+(local_broker ? TINY_MQTT_CLIENT_ALIVE_TOLERANCE : 0));
-    alive=millis()+500000;
-#else
-    alive=millis()+1000*(keep_alive+more_seconds);
-#endif
   }
   else
     alive=0;
@@ -262,29 +260,30 @@ void MqttClient::clientAlive(uint32_t more_seconds)
 
 void MqttClient::loop()
 {
-  if (alive && (millis() > alive))
+  if (keep_alive && (millis() >= alive))
   {
-    if (parent)
+    if (local_broker)
     {
-      debug("timeout client");
+      Serial << "timeout client " << clientId << endl;
       close();
-      debug("closed");
+      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);
+
-      clientAlive(0);
+      tcp_client->write((const char*)(&pingreq), 2);
+      clientAlive();
 
       // TODO when many MqttClient passes through a local broker
       // there is no need to send one PingReq per instance.
     }
   }
 #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);
@@ -297,21 +296,21 @@ void MqttClient::loop()
 void MqttClient::onConnect(void *mqttclient_ptr, TcpClient*)
 {
   MqttClient* mqtt = static_cast<MqttClient*>(mqttclient_ptr);
-  debug("cnx: connecting");
+  debug("MqttClient::onConnect");
   MqttMessage msg(MqttMessage::Type::Connect);
   msg.add("MQTT",4);
   msg.add(0x4);  // Mqtt protocol version 3.1.1
   msg.add(0x0);  // Connect flags         TODO user / name
 
-  msg.add(0x00);      // keep_alive
+  msg.add((char)(mqtt->keep_alive >> 8));   // keep_alive
-  msg.add((char)mqtt->keep_alive);
+  msg.add((char)(mqtt->keep_alive & 0xFF));
   msg.add(mqtt->clientId);
   debug("cnx: mqtt connecting");
   msg.sendTo(mqtt);
   msg.reset();
-  debug("cnx: mqtt sent " << (dbg_ptr)mqtt->parent);
+  debug("cnx: mqtt sent " << (dbg_ptr)mqtt->local_broker);
 
-  mqtt->clientAlive(0);
+  mqtt->clientAlive();
 }
 
 #ifdef TINY_MQTT_ASYNC
@@ -354,29 +353,30 @@ void MqttClient::resubscribe()
 
 MqttError MqttClient::subscribe(Topic topic, uint8_t qos)
 {
-  debug("subsribe(" << topic.c_str() << ")");
+  debug("MqttClient::subsribe(" << topic.c_str() << ")");
   MqttError ret = MqttOk;
 
    subscriptions.insert(topic);
 
-  if (parent==nullptr) // remote broker
+  if (local_broker==nullptr) // remote broker
   {
     return sendTopic(topic, MqttMessage::Type::Subscribe, qos);
   }
   else
   {
-    return parent->subscribe(topic, qos);
+    return local_broker->subscribe(topic, qos);
   }
   return ret;
 }
 
 MqttError MqttClient::unsubscribe(Topic topic)
 {
+  debug("MqttClient::unsubscribe");
   auto it=subscriptions.find(topic);
   if (it != subscriptions.end())
   {
     subscriptions.erase(it);
-    if (parent==nullptr) // remote broker
+    if (local_broker==nullptr) // remote broker
     {
       return sendTopic(topic, MqttMessage::Type::UnSubscribe, 0);
     }
@@ -386,6 +386,7 @@ MqttError MqttClient::unsubscribe(Topic topic)
 
 MqttError MqttClient::sendTopic(const Topic& topic, MqttMessage::Type type, uint8_t qos)
 {
+  debug("MqttClient::sendTopic");
   MqttMessage msg(type, 2);
 
   // TODO manage packet identifier
@@ -401,17 +402,8 @@ MqttError MqttClient::sendTopic(const Topic& topic, MqttMessage::Type type, uint
 
 void MqttClient::processMessage(MqttMessage* mesg)
 {
-#ifdef TINY_MQTT_DEBUG
+#if TINY_MQTT_DEBUG
-if (mesg->type() != MqttMessage::Type::PingReq && mesg->type() != MqttMessage::Type::PingResp)
-{
-  #ifdef NOT_ESP_CORE
-    Serial << "---> INCOMING " << _HEX(mesg->type()) << " client(" << (dbg_ptr)client << ':' << clientId << ") mem=" << " ESP.getFreeHeap() "<< endl;
-  #else
-    Serial << "---> INCOMING " << _HEX(mesg->type()) << " client(" << (dbg_ptr)client << ':' << clientId << ") mem=" << ESP.getFreeHeap() << endl;
-  #endif
-  // mesg->hexdump("Incoming");
   mesg->hexdump("Incoming");
-}
 #endif
   auto header = mesg->getVHeader();
   const char* payload;
@@ -425,14 +417,15 @@ if (mesg->type() != MqttMessage::Type::PingReq && mesg->type() != MqttMessage::T
   switch(mesg->type())
   {
     case MqttMessage::Type::Connect:
-      if (mqtt_connected)
+      if (mqtt_flags & FlagConnected)
       {
         debug("already connected");
         break;
       }
       payload = header+10;
-      mqtt_flags = header[7];
+      // Todo should check that reserved == 0 (spec)
-      keep_alive = (header[8]<<8)|(header[9]);
+      mqtt_flags = header[7] & ~FlagConnected;
+      keep_alive = MqttMessage::getSize(header+8);
       if (strncmp("MQTT", header+2,4))
       {
         debug("bad mqtt header");
@@ -461,21 +454,21 @@ if (mesg->type() != MqttMessage::Type::PingReq && mesg->type() != MqttMessage::T
       if (mqtt_flags & FlagUserName)
       {
         mesg->getString(payload, len);
-        if (!parent->checkUser(payload, len)) break;
+        if (not local_broker->checkUser(payload, len)) break;
         payload += len;
       }
       if (mqtt_flags & FlagPassword)
       {
         mesg->getString(payload, len);
-        if (!parent->checkPassword(payload, len)) break;
+        if (not local_broker->checkPassword(payload, len)) break;
         payload += len;
       }
 
-      #ifdef TINY_MQTT_DEBUG
+      #if TINY_MQTT_DEBUG
-        Serial << "Connected client:" << clientId.c_str() << ", keep alive=" << keep_alive << '.' << endl;
+        Console << yellow << "Client " << clientId << " connected : keep alive=" << keep_alive << '.' << white << endl;
       #endif
       bclose = false;
-      mqtt_connected=true;
+      mqtt_flags |= FlagConnected;
       {
         MqttMessage msg(MqttMessage::Type::ConnAck);
         msg.add(0);  // Session present (not implemented)
@@ -485,14 +478,14 @@ if (mesg->type() != MqttMessage::Type::PingReq && mesg->type() != MqttMessage::T
       break;
 
     case MqttMessage::Type::ConnAck:
-      mqtt_connected = true;
+      mqtt_flags |= FlagConnected;
       bclose = false;
       resubscribe();
       break;
 
     case MqttMessage::Type::SubAck:
     case MqttMessage::Type::PubAck:
-      if (!mqtt_connected) break;
+      if (not (mqtt_flags & FlagConnected)) break;
       // Ignore acks
       bclose = false;
       break;
@@ -503,23 +496,24 @@ if (mesg->type() != MqttMessage::Type::PingReq && mesg->type() != MqttMessage::T
       break;
 
     case MqttMessage::Type::PingReq:
-      if (!mqtt_connected) break;
+      if (not (mqtt_flags & FlagConnected)) break;
-      if (client)
+      if (tcp_client)
       {
         uint16_t pingreq = MqttMessage::Type::PingResp;
-        client->write((const char*)(&pingreq), 2);
+        debug(cyan << "Ping response to client ");
+        tcp_client->write((const char*)(&pingreq), 2);
         bclose = false;
       }
       else
       {
-        debug("internal pingreq ?");
+        debug(red << "internal pingreq ?");
       }
       break;
 
     case MqttMessage::Type::Subscribe:
     case MqttMessage::Type::UnSubscribe:
       {
-        if (!mqtt_connected) break;
+        if (not (mqtt_flags & FlagConnected)) break;
         payload = header+2;
 
         debug("un/subscribe loop");
@@ -563,43 +557,48 @@ if (mesg->type() != MqttMessage::Type::PingReq && mesg->type() != MqttMessage::T
       break;
 
     case MqttMessage::Type::UnSuback:
-      if (!mqtt_connected) break;
+      if (not (mqtt_flags & FlagConnected)) break;
       bclose = false;
       break;
 
     case MqttMessage::Type::Publish:
-      #ifdef TINY_MQTT_DEBUG
+      #if TINY_MQTT_DEBUG
-        Serial << "publish " << mqtt_connected << '/' << (long) client << endl;
+        Console << "publish " << (mqtt_flags & FlagConnected) << '/' << (long) tcp_client.get() << endl;
       #endif
-      if (mqtt_connected or client == nullptr)
+      if ((mqtt_flags & FlagConnected) or tcp_client == nullptr)
       {
         uint8_t qos = mesg->flags();
         payload = header;
         mesg->getString(payload, len);
         Topic published(payload, len);
         payload += len;
-        // Serial << "Received Publish (" << published.str().c_str() << ") size=" << (int)len
+        #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;
         if (qos) payload+=2;  // ignore packet identifier if any
         len=mesg->end()-payload;
         // TODO reset DUP
         // TODO reset RETAIN
 
-        if (parent==nullptr or client==nullptr)  // internal MqttClient receives publish
+        if (local_broker==nullptr or tcp_client==nullptr)  // internal MqttClient receives publish
         {
-          #ifdef TINY_MQTT_DEBUG
+          #if TINY_MQTT_DEBUG
-            Serial << (isSubscribedTo(published) ? "not" : "") << " subscribed.\n";
+            if (TinyMqtt::debug >= 2)
-            Serial << "has " << (callback ? "" : "no ") << " callback.\n";
+            {
+              Console << (isSubscribedTo(published) ? "not" : "") << " subscribed.\n";
+              Console << "has " << (callback ? "" : "no ") << " callback.\n";
+            }
           #endif
           if (callback and isSubscribedTo(published))
           {
             callback(this, published, payload, len);  // TODO send the real payload
           }
         }
-        else if (parent) // from outside to inside
+        else if (local_broker) // from outside to inside
         {
-          debug("publishing to parent");
+          debug("publishing to local_broker");
-          parent->publish(this, published, *mesg);
+          local_broker->publish(this, published, *mesg);
         }
         bclose = false;
       }
@@ -607,8 +606,8 @@ if (mesg->type() != MqttMessage::Type::PingReq && mesg->type() != MqttMessage::T
 
     case MqttMessage::Type::Disconnect:
       // TODO should discard any will msg
-      if (!mqtt_connected) break;
+      if (not (mqtt_flags & FlagConnected)) break;
-      mqtt_connected = false;
+      mqtt_flags &= ~FlagConnected;
       close(false);
       bclose=false;
       break;
@@ -619,17 +618,17 @@ if (mesg->type() != MqttMessage::Type::PingReq && mesg->type() != MqttMessage::T
   };
   if (bclose)
   {
-    #ifdef TINY_MQTT_DEBUG
+    #if TINY_MQTT_DEBUG
-      Serial << "*************** Error msg 0x" << _HEX(mesg->type());
+      Console << red << "*************** Error msg 0x" << _HEX(mesg->type());
       mesg->hexdump("-------ERROR ------");
       dump();
-      Serial << endl;
+      Console << white << endl;
     #endif
     close();
   }
   else
   {
-    clientAlive(parent ? 5 : 0);
+    clientAlive();
   }
 }
 
@@ -704,11 +703,11 @@ MqttError MqttClient::publish(const Topic& topic, const char* payload, size_t pa
   msg.add(payload, pay_length, false);
   msg.complete();
 
-  if (parent)
+  if (local_broker)
   {
-    return parent->publish(this, topic, msg);
+    return local_broker->publish(this, topic, msg);
   }
-  else if (client)
+  else if (tcp_client)
     return msg.sendTo(this);
   else
     return MqttNowhereToSend;
@@ -719,17 +718,17 @@ MqttError MqttClient::publishIfSubscribed(const Topic& topic, MqttMessage& msg)
 {
   MqttError retval=MqttOk;
 
-  debug("mqttclient publish " << subscriptions.size());
+  debug("mqttclient publishIfSubscribed " << topic.c_str() << ' ' << subscriptions.size());
   if (isSubscribedTo(topic))
   {
-    if (client)
+    if (tcp_client)
       retval = msg.sendTo(this);
     else
     {
       processMessage(&msg);
 
-      #ifdef TINY_MQTT_DEBUG
+      #if TINY_MQTT_DEBUG
-        Serial << "Should call the callback ?\n";
+        Console << "Should call the callback ?\n";
       #endif
       // callback(this, topic, nullptr, 0);  // TODO Payload
     }
@@ -797,8 +796,8 @@ void MqttMessage::incoming(char in_byte)
       break;
     case Complete:
     default:
-      #ifdef TINY_MQTT_DEBUG
+      #if TINY_MQTT_DEBUG
-        Serial << "Spurious " << _HEX(in_byte) << endl;
+        Console << red << "Spurious " << _HEX(in_byte) << white << endl;
         hexdump("spurious");
       #endif
       reset();
@@ -824,6 +823,7 @@ void MqttMessage::add(const char* p, size_t len, bool addLength)
 
 void MqttMessage::encodeLength()
 {
+  debug("encodingLength");
   if (state != Complete)
   {
     int length = buffer.size()-3;  // 3 = 1 byte for header + 2 bytes for pre-reserved length field.
@@ -849,14 +849,14 @@ MqttError MqttMessage::sendTo(MqttClient* client)
 {
   if (buffer.size())
   {
-    debug("sending " << buffer.size() << " bytes");
+    debug(cyan << "sending " << buffer.size() << " bytes to " << client->id());
     encodeLength();
-    // hexdump("snd");
+    hexdump("Sending ");
     client->write(&buffer[0], buffer.size());
   }
   else
   {
-    debug("??? Invalid send");
+    debug(red << "??? Invalid send");
     return MqttInvalidMessage;
   }
   return MqttOk;
@@ -865,7 +865,33 @@ MqttError MqttMessage::sendTo(MqttClient* client)
 void MqttMessage::hexdump(const char* prefix) const
 {
   (void)prefix;
-#ifdef TINY_MQTT_DEBUG
+#if TINY_MQTT_DEBUG
+  if (TinyMqtt::debug<2) return;
+  static std::map<Type, std::string> tts={
+    { Connect, "Connect" },
+    { ConnAck, "Connack" },
+    { Publish, "Publish" },
+    { PubAck,  "Puback" },
+    { Subscribe, "Subscribe" },
+    { SubAck,   "Suback" },
+    { UnSubscribe, "Unsubscribe" },
+    { UnSuback, "Unsuback" },
+    { PingReq, "Pingreq" },
+    { PingResp, "Pingresp" },
+    { Disconnect, "Disconnect" }
+  };
+  std::string t("Unknown");
+  Type typ=static_cast<Type>(buffer[0] & 0xF0);
+  if (tts.find(typ) != tts.end())
+    t=tts[typ];
+  Console.fg(cyan);
+#ifdef NOT_ESP_CORE
+  Console << "---> MESSAGE " << t << ' ' << _HEX(typ) << ' ' << " mem=???" << endl;
+#else
+  Console << "---> MESSAGE " << t << ' ' << _HEX(typ) << ' ' << " mem=" << ESP.getFreeHeap() << endl;
+#endif
+  Console.fg(white);
+
   uint16_t addr=0;
   const int bytes_per_row = 8;
   const char* hex_to_str = " | ";
@@ -873,19 +899,19 @@ void MqttMessage::hexdump(const char* prefix) const
   const char* half_sep = " - ";
   std::string ascii;
 
-  Serial << prefix << " size(" << buffer.size() << "), state=" << state << endl;
+  Console << prefix << " size(" << buffer.size() << "), state=" << state << endl;
 
   for(const char chr: buffer)
   {
     if ((addr % bytes_per_row) == 0)
     {
-      if (ascii.length()) Serial << hex_to_str << ascii << separator << endl;
+      if (ascii.length()) Console << hex_to_str << ascii << separator << endl;
-      if (prefix) Serial << prefix << separator;
+      if (prefix) Console << prefix << separator;
       ascii.clear();
     }
     addr++;
-    if (chr<16) Serial << '0';
+    if (chr<16) Console << '0';
-    Serial << _HEX(chr) << ' ';
+    Console << _HEX(chr) << ' ';
 
     ascii += (chr<32 ? '.' : chr);
     if (ascii.length() == (bytes_per_row/2)) ascii += half_sep;
@@ -894,12 +920,12 @@ void MqttMessage::hexdump(const char* prefix) const
   {
     while(ascii.length() < bytes_per_row+strlen(half_sep))
     {
-      Serial << "   ";  // spaces per hexa byte
+      Console << "   ";  // spaces per hexa byte
       ascii += ' ';
     }
-    Serial << hex_to_str << ascii << separator;
+    Console << hex_to_str << ascii << separator;
   }
 
-  Serial << endl;
+  Console << endl;
 #endif
 }

src/TinyMqtt.h

@@ -1,5 +1,14 @@
+// vim: ts=2 sw=2 expandtab
 #pragma once
 
+#ifndef TINY_MQTT_DEBUG
+#define TINY_MQTT_DEBUG 0
+#endif
+#ifndef TINY_MQTT_DEFAULT_ALIVE
+#define TINY_MQTT_DEFAULT_ALIVE 10
+#endif
+#define TINY_MQTT_CLIENT_ALIVE_TOLERANCE 5
+
 // 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
 
@@ -32,16 +41,31 @@
 #include <set>
 #include <string>
 #include "StringIndexer.h"
-#include <MqttStreaming.h>
 
-// #define TINY_MQTT_DEBUG
+#define TINY_MQTT_DEFAULT_CLIENT_ID "Tiny"
 
-#ifdef TINY_MQTT_DEBUG
+#include <TinyStreaming.h>
-  #define debug(what) { Serial << (int)__LINE__ << ' ' << what << endl; delay(100); }
+#if TINY_MQTT_DEBUG
+  #include <TinyConsole.h>    // https://github.com/hsaturn/TinyConsole
+  struct TinyMqtt
+  {
+    static int debug;
+  };
+
+  #define debug(what) { if (TinyMqtt::debug>=1) Console << (int)__LINE__ << ' ' << what << TinyConsole::white << endl; delay(100); }
 #else
   #define debug(what) {}
 #endif
 
+#include <TinyConsole.h>
+#if 0
+#define dclass { Console << __LINE__ << ':' << __PRETTY_FUNCTION__ <<  ", this=" << (long)this << endl; }
+#define dtor { Console << __LINE__ << ": ~" << __PRETTY_FUNCTION__ << ", this=" << (long)this << endl; }
+#else
+#define dclass
+#define dtor
+#endif
+
 #ifdef TINY_MQTT_ASYNC
   using TcpClient = AsyncClient;
   using TcpServer = AsyncServer;
@@ -89,6 +113,7 @@ class MqttMessage
       PingResp    = 0xD0,
       Disconnect  = 0xE0
     };
+
     enum __attribute__((packed)) State
     {
       FixedHeader=0,
@@ -100,6 +125,11 @@ class MqttMessage
       Create=6
     };
 
+    static inline uint32_t getSize(const char* buffer)
+    {
+      const unsigned char* bun = (const unsigned char*)buffer;
+      return (*bun << 8) | bun[1]; }
+
     MqttMessage() { reset(); }
     MqttMessage(Type t, uint8_t bits_d3_d0=0) { create(t); buffer[0] |= bits_d3_d0; }
     void incoming(char byte);
@@ -148,38 +178,47 @@ 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,
     FlagPassword = 64,
-    FlagWillRetain = 32,  // unsupported
+    FlagWillRetain = 32,   // unsupported
-    FlagWillQos = 16 | 8, // unsupported
+    FlagWillQos = 16 | 8,  // unsupported
     FlagWill = 4,          // unsupported
     FlagCleanSession = 2,  // unsupported
-    FlagReserved = 1
+
+    FlagReserved = 1,      // use reserved as connected (save 1 byte)
+    FlagConnected = 1
   };
   public:
-    /** Constructor. If broker is not null, this is the adress of a local broker.
+
+    using CallBack = void (*)(const MqttClient* source, const Topic& topic, const char* payload, size_t payload_length);
+
+    /** Constructor. Broker is the adress of a local broker if not null
         If you want to connect elsewhere, leave broker null and use connect() **/
-    MqttClient(MqttBroker* broker = nullptr, const std::string& id="");
+    MqttClient(MqttBroker* broker = nullptr, const std::string& id = TINY_MQTT_DEFAULT_CLIENT_ID);
-    MqttClient(const std::string& id) : MqttClient(nullptr, id){}
+    MqttClient(const std::string& id) : MqttClient(nullptr, id){ dclass; }
 
     ~MqttClient();
 
-    void connect(MqttBroker* parent);
+    void connect(MqttBroker* local_broker);
-    void connect(std::string broker, uint16_t port, uint16_t keep_alive = 10);
+    void connect(std::string broker, uint16_t port, uint16_t keep_alive = TINY_MQTT_DEFAULT_ALIVE);
 
     // TODO it seems that connected returns true in tcp mode even if
-    // no negociation occured (only if tcp link is established)
+    // no negociation occurred
-    bool connected() { return
+    bool connected()
-      (parent!=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(std::string& new_id) { clientId = new_id; }
+    void id(const std::string& new_id) { clientId = new_id; }
 
     /** Should be called in main loop() */
     void loop();
@@ -187,8 +226,8 @@ class MqttClient
     void setCallback(CallBack fun)
     {
       callback=fun;
-      #ifdef TINY_MQTT_DEBUG
+      #if TINY_MQTT_DEBUG
-        Serial << "Callback set to " << (long)fun << endl;
+        Console << TinyConsole::magenta << "Callback set to " << (long)fun << TinyConsole::white << endl;
         if (callback) callback(this, "test/topic", "value", 5);
       #endif
     };
@@ -206,35 +245,43 @@ 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)indent;
-      #ifdef TINY_MQTT_DEBUG
+      #if TINY_MQTT_DEBUG
         uint32_t ms=millis();
-        Serial << indent << "+-- " << '\'' << clientId.c_str() << "' " << (connected() ? " ON " : " OFF");
+        Console << indent << "+-- " << '\'' << clientId.c_str() << "' " << (connected() ? " ON " : " OFF");
-        Serial << ", alive=" << alive << '/' << ms << ", ka=" << keep_alive << ' ';
+        Console << ", alive=" << alive << '/' << ms << ", ka=" << keep_alive << ' ';
-        Serial << (client && client->connected() ? "" : "dis") << "connected";
+        if (tcp_client)
+        {
+          if (tcp_client->connected())
+            Console << TinyConsole::green << "connected";
+          else
+            Console << TinyConsole::red << "disconnected";
+          Console << TinyConsole::white;
+        }
         if (subscriptions.size())
         {
           bool c = false;
-          Serial << " [";
+          Console << " [";
           for(auto s: subscriptions)
           {
-            if (c) Serial << ", ";
+            if (c) Console << ", ";
-            Serial << s.str().c_str();
+            Console << s.str().c_str();
             c=true;
           }
-          Serial << ']';
+          Console << ']';
         }
-        Serial << endl;
+        Console << TinyConsole::erase_to_end << endl;
       #endif
     }
 
 #ifdef EPOXY_DUINO
     static std::map<MqttMessage::Type, int> counters;  // Number of processed messages
 #endif
+    uint32_t keepAlive() const { return keep_alive; }
 
   private:
 
@@ -247,26 +294,26 @@ class MqttClient
     void resubscribe();
 
     friend class MqttBroker;
-    MqttClient(MqttBroker* parent, TcpClient* client);
+    MqttClient(MqttBroker* local_broker, TcpClient* client);
     // republish a received publish if topic matches any in subscriptions
     MqttError publishIfSubscribed(const Topic& topic, MqttMessage& msg);
 
-    void clientAlive(uint32_t more_seconds);
+    void clientAlive();
     void processMessage(MqttMessage* message);
 
-    bool mqtt_connected = false;
+    char mqtt_flags = 0;
-    char mqtt_flags;
+    uint16_t keep_alive = 30;
-    uint32_t keep_alive = 60;
+    // for client connected to remote broker, PingReq is sent when millis() >= alive
-    uint32_t alive;
+    // for a client managed by a broker, disconnect it if millis() >= alive
+    uint32_t alive; // PingReq if millis() > alive,
     MqttMessage message;
 
-    // TODO  having a pointer on MqttBroker may produce larger binaries
+    // connection to local broker, or link to the parent
-    // due to unecessary function linked if ever parent is not used
+    // when MqttBroker uses MqttClient for each external connexion
-    // (this is the case when MqttBroker isn't used except here)
+    MqttBroker* local_broker=nullptr;
-    MqttBroker* parent=nullptr;    // connection to local broker
 
-    TcpClient* client=nullptr;    // connection to remote broker
+    std::unique_ptr<TcpClient> tcp_client;    // connection to remote broker
-    std::set<Topic>  subscriptions;
+    std::set<Topic> subscriptions;
     std::string clientId;
     CallBack callback = nullptr;
 };
@@ -284,7 +331,7 @@ class MqttBroker
     MqttBroker(uint16_t port);
     ~MqttBroker();
 
-    void begin() { server->begin(); }
+    void begin() { if (server) server->begin(); }
     void loop();
 
     void connect(const std::string& host, uint16_t port=1883);
@@ -294,10 +341,14 @@ class MqttBroker
 
     void dump(std::string indent="")
     {
-      for(auto client: clients)
+      for(auto& client: clients)
         client->dump(indent);
     }
 
+    size_t localClientsCount() const { return local_clients.size(); }
+    using Clients = std::vector<MqttClient*>;
+    const Clients& getClients() const { return clients; }
+
   private:
     friend class MqttClient;
 
@@ -313,17 +364,20 @@ class MqttBroker
 
     MqttError subscribe(const Topic& topic, uint8_t qos);
 
-    // For clients that are added not by the broker itself
+    // For clients that are added not by the broker itself (local clients)
-    void addClient(MqttClient* client);
+    void addClient(MqttClient* local) { local_clients.insert(local); }
     void removeClient(MqttClient* client);
 
     bool compareString(const char* good, const char* str, uint8_t str_len) const;
-    std::vector<MqttClient*>  clients;
+    Clients clients;
-    TcpServer* server;
+    std::set<MqttClient*> local_clients;
+
+  private:
+    std::unique_ptr<TcpServer> server;
 
     const char* auth_user = "guest";
     const char* auth_password = "guest";
-    State state = Disconnected;
+    MqttClient* remote_broker = nullptr;
 
-    MqttClient* broker = nullptr;
+    State state = Disconnected;
 };

src/my_credentials.h

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

tests/Makefile

@@ -1,28 +1,30 @@
+SUB=
+
 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
 
 debugtest:
-	set -e; \
+	@set -e; \
 	$(MAKE) clean; \
 	$(MAKE) -C debug-mode -j; \
 	debug-mode/debug-tests.out
 
 runtests: debugtest
-	$(MAKE) clean
+	@$(MAKE) clean
-	$(MAKE) tests
+	@$(MAKE) tests
-	set -e; \
+	@set -e; \
-	for i in *-tests/Makefile; do \
+	for i in ${SUB}*-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/classbind-tests/Makefile

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

tests/classbind-tests/classbind-tests.ino

@@ -0,0 +1,397 @@
+// vim: ts=2 sw=2 expandtab
+#include <Arduino.h>
+#include <AUnit.h>
+#include <TinyMqtt.h>
+#include <MqttClassBinder.h>
+#include <map>
+#include <iostream>
+#include <iomanip>
+#include <sstream>
+#include <string>
+#include <iostream>
+
+// --------------------- CUT HERE - MQTT MESSAGE ROUTER FILE ----------------------------
+
+class TestReceiver : public MqttClassBinder<TestReceiver>
+{
+  public:
+    TestReceiver(const char* name) : MqttClassBinder(), name_(name) {}
+
+    void onPublish(const MqttClient* /* source */, const Topic& topic, const char* payload, size_t /* length */)
+    {
+      Serial << "--> routed message received by " << name_ << ':' << topic.c_str() << " = " << payload << endl;
+      messages[name_]++;
+    }
+
+  private:
+    const std::string name_;
+
+  public:
+    static std::map<std::string, int> messages;
+};
+
+std::map<std::string, int> TestReceiver::messages;
+
+static int unrouted = 0;
+void onUnrouted(const MqttClient*, const Topic& topic, const char*, size_t)
+{
+  Serial << "--> unrouted: " << topic.c_str() << endl;
+  unrouted++;
+}
+
+
+static std::string topic="sensor/temperature";
+
+/**
+  * TinyMqtt network unit tests.
+  *
+  * No wifi connection unit tests.
+  * Checks with a local broker. Clients must connect to the local broker
+  **/
+
+// if ascii_pos = 0, no ascii dump, else ascii dump starts after column ascii_pos
+std::string bufferToHexa(const uint8_t* buffer, size_t length, char sep = 0, size_t ascii_pos = 0)
+{
+  std::stringstream out;
+  std::string ascii;
+  std::string h("0123456789ABCDEF");
+  for(size_t i=0; i<length; i++)
+  {
+    uint8_t c = buffer[i];
+    out << h[ c >> 4] << h[ c & 0x0F ];
+    if (sep) out << sep;
+    if (ascii_pos)
+    {
+      if (c>=32)
+        ascii += c;
+      else
+        ascii +='.';
+    }
+  }
+  std::string ret(out.str());
+  if (ascii_pos)
+  {
+    while(ret.length() < ascii_pos)
+      ret += ' ';
+    ret +='[' + ascii + ']';
+  }
+  return ret;
+}
+
+void dumpMqttMessage(const uint8_t* buffer, size_t length)
+{
+  std::map<int, std::string> pkt =
+  { { MqttMessage::Unknown     , "Unknown     " },
+    { MqttMessage::Connect     , "Connect     " },
+    { MqttMessage::ConnAck     , "ConnAck     " },
+    { MqttMessage::Publish     , "Publish     " },
+    { MqttMessage::PubAck      , "PubAck      " },
+    { MqttMessage::Subscribe   , "Subscribe   " },
+    { MqttMessage::SubAck      , "SubAck      " },
+    { MqttMessage::UnSubscribe , "Unsubscribe " },
+    { MqttMessage::UnSuback    , "UnSubAck    " },
+    { MqttMessage::PingReq     , "PingReq     " },
+    { MqttMessage::PingResp    , "PingResp    " },
+    { MqttMessage::Disconnect  , "Disconnect  " } };
+
+  std::cout << "       |   data sent " << std::setw(3) << length << " : ";
+  auto it = pkt.find(buffer[0] & 0xF0);
+  if (it == pkt.end())
+    std::cout << pkt[MqttMessage::Unknown];
+  else
+    std::cout << it->second;
+
+  std::cout << bufferToHexa(buffer, length, ' ', 60) << std::endl;
+}
+
+String toString(const IPAddress& ip)
+{
+  return String(ip[0])+'.'+String(ip[1])+'.'+String(ip[2])+'.'+String(ip[3]);
+}
+
+MqttBroker broker(1883);
+
+void reset_and_start_servers(int n, bool early_accept = true)
+{
+  MqttClassBinder<TestReceiver>::reset();
+  TestReceiver::messages.clear();
+  unrouted = 0;
+
+  ESP8266WiFiClass::resetInstances();
+  ESP8266WiFiClass::earlyAccept = early_accept;
+  while(n)
+  {
+    ESP8266WiFiClass::selectInstance(n--);
+    WiFi.mode(WIFI_STA);
+    WiFi.begin("fake_ssid", "fake_pwd");
+  }
+}
+
+test(classbind_two_subscribers_binded_one_sender_wildcard)
+{
+  EpoxyTest::set_millis(0);
+  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 mqtt_a(&broker, "mqtt_a");
+  MqttClient mqtt_b(&broker, "mqtt_a");
+  MqttClient mqtt_sender(&broker, "sender");
+
+  broker.loop();
+
+  assertTrue(mqtt_a.connected());
+  assertTrue(mqtt_b.connected());
+
+  TestReceiver receiver("receiver");
+  MqttClassBinder<TestReceiver>::onPublish(&mqtt_a, &receiver);
+  MqttClassBinder<TestReceiver>::onPublish(&mqtt_b, &receiver);
+
+  mqtt_a.subscribe("#");
+  mqtt_b.subscribe("#");
+  mqtt_sender.publish("a/b", "ab");
+
+  for (int i =0; i<10; i++)
+  {
+    EpoxyTest::add_millis(100);
+    mqtt_a.loop();
+    mqtt_b.loop();
+    mqtt_sender.loop();
+    broker.loop();
+  }
+
+  assertEqual(TestReceiver::messages["receiver"], 2);
+  assertEqual(unrouted, 0);
+  EpoxyTest::set_real_time();
+}
+
+test(classbind_one_client_receives_the_message)
+{
+  EpoxyTest::set_millis(0);
+  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("sender");
+  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++)
+  {
+    EpoxyTest::add_millis(100);
+    client.loop();
+    broker.loop();
+  }
+
+  assertEqual(TestReceiver::messages["receiver"], 1);
+  assertEqual(unrouted, 0);
+  EpoxyTest::set_real_time();
+}
+
+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("=============[ CLASS BINDER TinyMqtt TESTS       ]========================");
+
+  WiFi.mode(WIFI_STA);
+  WiFi.begin("network", "password");
+}
+
+void loop() {
+  aunit::TestRunner::run();
+
+  if (Serial.available()) ESP.reset();
+}

tests/debug-mode/Makefile

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

tests/length-tests.todo/Makefile

@@ -4,7 +4,7 @@
 EXTRA_CXXFLAGS=-g3 -O0
 
 APP_NAME := length-tests
-ARDUINO_LIBS := AUnit AceCommon AceTime TinyMqtt EspMock ESP8266WiFi  ESPAsyncTCP
+ARDUINO_LIBS := AUnit AceCommon AceTime TinyMqtt EspMock ESP8266WiFi  ESPAsyncTCP TinyConsole
 ARDUINO_LIB_DIRS := ../../../EspMock/libraries
 EPOXY_CORE := EPOXY_CORE_ESP8266
 include ../../../EpoxyDuino/EpoxyDuino.mk

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

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

tests/local-tests/Makefile

@@ -1,13 +1,13 @@
 # See https://github.com/bxparks/EpoxyDuino for documentation about this
 # Makefile to compile and run Arduino programs natively on Linux or MacOS.
 
-EXTRA_CXXFLAGS=-g3 -O0
+EXTRA_CXXFLAGS=-g3 -O0 -DTINY_MQTT_DEFAULT_ALIVE=1 -DEPOXY_TEST
 
 # 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
+ARDUINO_LIBS := AUnit AceCommon AceTime TinyMqtt EspMock ESP8266WiFi  ESPAsyncTCP TinyConsole
 ARDUINO_LIB_DIRS := ../../../EspMock/libraries
 EPOXY_CORE := EPOXY_CORE_ESP8266
 include ../../../EpoxyDuino/EpoxyDuino.mk

tests/local-tests/local-tests.ino

@@ -14,7 +14,6 @@
 
 using namespace std;
 
-MqttBroker broker(1883);
 
 std::map<std::string, std::map<Topic, int>>  published;    // map[client_id] => map[topic] = count
 
@@ -31,49 +30,85 @@ void onPublish(const MqttClient* srce, const Topic& topic, const char* payload,
 
 test(local_client_should_unregister_when_destroyed)
 {
-  assertEqual(broker.clientsCount(), (size_t)0);
+  MqttBroker broker(1883);
+  assertEqual(broker.localClientsCount(), (size_t)0);
   {
-    assertEqual(broker.clientsCount(), (size_t)0);  // Ensure client is not yet connected
     MqttClient client(&broker);
-    assertEqual(broker.clientsCount(), (size_t)1);  // Ensure client is now connected
+    assertEqual(broker.localClientsCount(), (size_t)1);  // Ensure client is now connected
   }
-  assertEqual(broker.clientsCount(), (size_t)0);
+  assertEqual(broker.localClientsCount(), (size_t)0);
+}
+
+test(local_client_alive)
+{
+  EpoxyTest::set_millis(0);
+  MqttBroker broker(1883);
+  MqttClient client(&broker);
+
+  broker.loop();
+  assertEqual(broker.localClientsCount(), (size_t)1);  // Ensure client is now connected
+
+  EpoxyTest::add_millis(TINY_MQTT_DEFAULT_ALIVE*1000/2);
+  broker.loop();
+  assertEqual(broker.localClientsCount(), (size_t)1);  // Ensure client is still connected
+
+  EpoxyTest::add_seconds(TINY_MQTT_DEFAULT_ALIVE*5);
+  broker.loop();
+  assertEqual(broker.localClientsCount(), (size_t)1);  // Ensure client is still connected
+}
+
+test(local_wildcard_subscribe)
+{
+  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.localClientsCount(), (size_t)2);
+
+  sender.publish("test", "value");
+  broker.loop();
+
+  assertEqual(published.size(), (size_t)1);  // client has received something
+}
+
+test(local_client_do_not_disconnect_after_publishing)
+{
+  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.localClientsCount(), (size_t)2);
+
+  sender.publish("test", "value");
+  broker.loop();
+
+  EpoxyTest::add_seconds(60);
+  client.loop();
+  sender.loop();
+  broker.loop();
+
+  assertEqual(broker.localClientsCount(), (size_t)2);
+  assertEqual(sender.connected(), true);
+  assertEqual(client.connected(), true);
+
+  assertEqual(published.size(), (size_t)1);  // client has received something
 }
 
 #if 0
-test(local_connect)
-{
-  assertEqual(broker.clientsCount(), (size_t)0);
-
-  MqttClient client;
-  assertTrue(client.connected());
-  assertEqual(broker.clientsCount(), (size_t)1);
-}
-
-test(local_publish_should_be_dispatched)
-{
-  published.clear();
-  assertEqual(broker.clientsCount(), (size_t)0);
-
-  MqttClient subscriber;
-  subscriber.subscribe("a/b");
-  subscriber.subscribe("a/c");
-  subscriber.setCallback(onPublish);
-
-  MqttClient publisher;
-  publisher.publish("a/b");
-  publisher.publish("a/c");
-  publisher.publish("a/c");
-
-  assertEqual(published.size(), (size_t)1);  // 1 client has received something
-  assertEqual(published[""]["a/b"], 1);
-  assertEqual(published[""]["a/c"], 2);
-}
-
 test(local_publish_should_be_dispatched_to_local_clients)
 {
   published.clear();
-  assertEqual(broker.clientsCount(), (size_t)0);
+  assertEqual(broker.localClientsCount(), (size_t)0);
 
   MqttClient subscriber_a("A");
   subscriber_a.setCallback(onPublish);
@@ -98,7 +133,7 @@ test(local_publish_should_be_dispatched_to_local_clients)
 test(local_unsubscribe)
 {
   published.clear();
-  assertEqual(broker.clientsCount(), (size_t)0);
+  assertEqual(broker.localClientsCount(), (size_t)0);
 
   MqttClient subscriber;
   subscriber.setCallback(onPublish);
@@ -118,7 +153,7 @@ test(local_unsubscribe)
 test(local_nocallback_when_destroyed)
 {
   published.clear();
-  assertEqual(broker.clientsCount(), (size_t)0);
+  assertEqual(broker.localClientsCount(), (size_t)0);
 
   MqttClient publisher;
   {

tests/network-tests/Makefile

@@ -4,10 +4,10 @@
 EXTRA_CXXFLAGS=-g3 -O0
 
 # 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 -DEPOXY_TEST
 
 APP_NAME := network-tests
-ARDUINO_LIBS := AUnit AceCommon AceTime TinyMqtt EspMock ESP8266WiFi  ESPAsyncTCP
+ARDUINO_LIBS := AUnit AceCommon AceTime TinyMqtt EspMock ESP8266WiFi  ESPAsyncTCP TinyConsole
 ARDUINO_LIB_DIRS := ../../../EspMock/libraries
 EPOXY_CORE := EPOXY_CORE_ESP8266
 include ../../../EpoxyDuino/EpoxyDuino.mk

tests/network-tests/network-tests.ino

@@ -1,3 +1,4 @@
+// vim: ts=2 sw=2 expandtab
 #include <Arduino.h>
 #include <AUnit.h>
 #include <TinyMqtt.h>
@@ -6,13 +7,24 @@
 #include <iomanip>
 #include <sstream>
 #include <string>
+#include <iostream>
+
+uint32_t getClientKeepAlive(MqttBroker& broker)
+{
+  if (broker.getClients().size() == 1)
+    for (auto& it : broker.getClients())
+      return it->keepAlive();
+
+  return 9999;
+}
+
 
 /**
   * TinyMqtt network unit tests.
-	*
+  *
-	* No wifi connection 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)
@@ -76,7 +88,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<std::string, std::map<Topic, int>>  published;    // map[client_id] => map[topic] = count
 
 char* lastPayload = nullptr;
 size_t lastLength;
@@ -95,12 +107,12 @@ void start_servers(int n, bool early_accept = true)
 
 void onPublish(const MqttClient* srce, const Topic& topic, const char* payload, size_t length)
 {
-	if (srce)
+  if (srce)
-		published[srce->id()][topic]++;
+    published[srce->id()][topic]++;
 
-	if (lastPayload) free(lastPayload);
+  if (lastPayload) free(lastPayload);
   lastPayload = strdup(payload);
-	lastLength = length;
+  lastLength = length;
 }
 
 test(network_single_broker_begin)
@@ -140,6 +152,81 @@ test(suback)
   assertEqual(MqttClient::counters[MqttMessage::Type::SubAck], 1);
 }
 
+test(network_client_alive)
+{
+  const uint32_t keep_alive=1;
+  start_servers(2, true);
+  assertEqual(WiFi.status(), WL_CONNECTED);
+  EpoxyTest::set_millis(0); // Enter simulated time
+
+  MqttBroker broker(1883);
+  broker.begin();
+  IPAddress broker_ip = WiFi.localIP();
+
+  ESP8266WiFiClass::selectInstance(2);
+  MqttClient client;
+  client.connect(broker_ip.toString().c_str(), 1883, keep_alive);
+  broker.loop();
+  client.loop();
+
+  assertTrue(broker.clientsCount() == 1);
+  assertTrue(client.connected());
+
+  uint32_t ka = getClientKeepAlive(broker);
+  assertEqual(ka, keep_alive);
+  assertEqual(broker.clientsCount(), (size_t)1);
+
+  // All is going well if we call client.loop()
+  // The client is able to send PingReq to the broker
+  EpoxyTest::add_seconds(keep_alive);
+  client.loop();
+  broker.loop();
+  assertEqual(broker.clientsCount(), (size_t)1);
+
+  // Now simulate that the client is frozen for
+  // a too long time
+  EpoxyTest::add_seconds(TINY_MQTT_CLIENT_ALIVE_TOLERANCE*2);
+  broker.loop();
+  assertEqual(broker.clientsCount(), (size_t)0);
+
+  EpoxyTest::set_real_time();
+}
+
+test(network_client_keep_alive_high)
+{
+  const uint32_t keep_alive=1000;
+  start_servers(2, true);
+  assertEqual(WiFi.status(), WL_CONNECTED);
+
+  MqttBroker broker(1883);
+  broker.begin();
+  IPAddress broker_ip = WiFi.localIP();
+
+  ESP8266WiFiClass::selectInstance(2);
+  MqttClient client;
+  client.connect(broker_ip.toString().c_str(), 1883, keep_alive);
+  broker.loop();
+
+  assertTrue(broker.clientsCount() == 1);
+  assertTrue(client.connected());
+
+  MqttClient::counters[MqttMessage::Type::SubAck] = 0;
+  client.subscribe("a/b");
+
+  // TODO how to avoid these loops ???
+  broker.loop();
+  client.loop();
+
+  assertEqual(MqttClient::counters[MqttMessage::Type::SubAck], 1);
+
+  uint32_t sz = broker.getClients().size();
+  assertEqual(sz , (uint32_t)1);
+
+  uint32_t ka = getClientKeepAlive(broker);
+  assertEqual(ka, keep_alive);
+
+}
+
 test(network_client_to_broker_connexion)
 {
   start_servers(2, true);
@@ -225,14 +312,14 @@ test(network_one_client_one_broker_hudge_publish_and_subscribe_through_network)
   assertEqual((unsigned int)lastLength, (unsigned int)sent.size());
 }
 
-test(network_client_should_unregister_when_destroyed)
+test(network_local_client_should_unregister_when_destroyed)
 {
-	assertEqual(broker.clientsCount(), (size_t)0);
+  assertEqual(broker.clientsCount(), (size_t)0);
-	{
+  {
-		MqttClient client(&broker);
+    MqttClient client(&broker);
-		assertEqual(broker.clientsCount(), (size_t)1);
+    assertEqual(broker.localClientsCount(), (size_t)1);
-	}
+  }
-	assertEqual(broker.clientsCount(), (size_t)0);
+  assertEqual(broker.localClientsCount(), (size_t)0);
 }
 
 
@@ -241,135 +328,138 @@ test(network_client_should_unregister_when_destroyed)
 
 test(network_connect)
 {
-	assertEqual(broker.clientsCount(), (size_t)0);
+  assertEqual(broker.clientsCount(), (size_t)0);
 
-	MqttClient client(&broker);
+  MqttClient client(&broker);
-	assertTrue(client.connected());
+  assertTrue(client.connected());
-	assertEqual(broker.clientsCount(), (size_t)1);
+  assertEqual(broker.localClientsCount(), (size_t)1);
 }
 
 test(network_publish_should_be_dispatched)
 {
-	published.clear();
+  published.clear();
-	assertEqual(broker.clientsCount(), (size_t)0);
+  assertEqual(broker.localClientsCount(), (size_t)0);
 
-	MqttClient subscriber(&broker);
+  MqttClient subscriber(&broker);
-	subscriber.subscribe("a/b");
+  subscriber.subscribe("a/b");
-	subscriber.subscribe("a/c");
+  subscriber.subscribe("a/c");
-	subscriber.setCallback(onPublish);
+  subscriber.setCallback(onPublish);
 
-	MqttClient publisher(&broker);
+  MqttClient publisher(&broker);
-	publisher.publish("a/b");
+  publisher.publish("a/b");
-	publisher.publish("a/c");
+  publisher.publish("a/c");
-	publisher.publish("a/c");
+  publisher.publish("a/c");
 
-	assertEqual(published.size(), (size_t)1);	// 1 client has received something
+  assertEqual(published.size(), (size_t)1);  // 1 client has received something
-	assertEqual(published[""]["a/b"], 1);
+  assertEqual(published[TINY_MQTT_DEFAULT_CLIENT_ID]["a/b"], 1);
-	assertEqual(published[""]["a/c"], 2);
+  assertEqual(published[TINY_MQTT_DEFAULT_CLIENT_ID]["a/c"], 2);
 }
 
 test(network_publish_should_be_dispatched_to_clients)
 {
-	published.clear();
+  published.clear();
-	assertEqual(broker.clientsCount(), (size_t)0);
+  assertEqual(broker.clientsCount(), (size_t)0);
 
-	MqttClient subscriber_a(&broker, "A");
+  MqttClient subscriber_a(&broker, "A");
-	subscriber_a.setCallback(onPublish);
+  subscriber_a.setCallback(onPublish);
-	subscriber_a.subscribe("a/b");
+  subscriber_a.subscribe("a/b");
-	subscriber_a.subscribe("a/c");
+  subscriber_a.subscribe("a/c");
 
-	MqttClient subscriber_b(&broker, "B");
+  MqttClient subscriber_b(&broker, "B");
-	subscriber_b.setCallback(onPublish);
+  subscriber_b.setCallback(onPublish);
-	subscriber_b.subscribe("a/b");
+  subscriber_b.subscribe("a/b");
 
-	MqttClient publisher(&broker);
+  MqttClient publisher(&broker);
-	publisher.publish("a/b");		// A and B should receive this
+  publisher.publish("a/b");    // A and B should receive this
-	publisher.publish("a/c");		// A should receive this 
+  publisher.publish("a/c");    // A should receive this
 
-	assertEqual(published.size(), (size_t)2);	// 2 clients have received something
+  assertEqual(published.size(), (size_t)2);  // 2 clients have received something
-	assertEqual(published["A"]["a/b"], 1);
+  assertEqual(published["A"]["a/b"], 1);
-	assertEqual(published["A"]["a/c"], 1);
+  assertEqual(published["A"]["a/c"], 1);
-	assertEqual(published["B"]["a/b"], 1);
+  assertEqual(published["B"]["a/b"], 1);
-	assertEqual(published["B"]["a/c"], 0);
+  assertEqual(published["B"]["a/c"], 0);
 }
 
 test(network_unsubscribe)
 {
-	published.clear();
+  published.clear();
-	assertEqual(broker.clientsCount(), (size_t)0);
+  assertEqual(broker.clientsCount(), (size_t)0);
 
-	MqttClient subscriber(&broker);
+  MqttClient subscriber(&broker);
-	subscriber.setCallback(onPublish);
+  subscriber.setCallback(onPublish);
-	subscriber.subscribe("a/b");
+  subscriber.subscribe("a/b");
 
-	MqttClient publisher(&broker);
+  MqttClient publisher(&broker);
-	publisher.publish("a/b");		// This publish is received
+  publisher.publish("a/b");    // This publish is received
 
-	subscriber.unsubscribe("a/b");
+  subscriber.unsubscribe("a/b");
 
-	publisher.publish("a/b");		// Those one, no (unsubscribed)
+  publisher.publish("a/b");    // Those one, no (unsubscribed)
-	publisher.publish("a/b");
+  publisher.publish("a/b");
 
-	assertEqual(published[""]["a/b"], 1);	// Only one publish has been received
+  assertEqual(published[TINY_MQTT_DEFAULT_CLIENT_ID]["a/b"], 1);  // Only one publish has been received
 }
 
 test(network_nocallback_when_destroyed)
 {
-	published.clear();
+  published.clear();
-	assertEqual(broker.clientsCount(), (size_t)0);
+  assertEqual(broker.clientsCount(), (size_t)0);
 
-	MqttClient publisher(&broker);
+  MqttClient publisher(&broker);
 
-	{
+  {
-		MqttClient subscriber(&broker);
+    MqttClient subscriber(&broker);
-		subscriber.setCallback(onPublish);
+    subscriber.setCallback(onPublish);
-		subscriber.subscribe("a/b");
+    subscriber.subscribe("a/b");
-		publisher.publish("a/b");
+    publisher.publish("a/b");
-	}
+  }
 
-	publisher.publish("a/b");
+  publisher.publish("a/b");
 
-	assertEqual(published.size(), (size_t)1);	// Only one publish has been received
+  assertEqual(published.size(), (size_t)1);  // Only one publish has been received
 }
 
 test(network_small_payload)
 {
-	published.clear();
+  published.clear();
 
-	const char* payload="abcd";
+  const char* payload="abcd";
 
-	MqttClient subscriber(&broker);
+  MqttClient subscriber(&broker);
-	subscriber.setCallback(onPublish);
+  subscriber.setCallback(onPublish);
-	subscriber.subscribe("a/b");
+  subscriber.subscribe("a/b");
 
-	MqttClient publisher(&broker);
+  MqttClient publisher(&broker);
-	publisher.publish("a/b", payload, strlen(payload));		// This publish is received
+  publisher.publish("a/b", payload, strlen(payload));    // This publish is received
 
   // coming from MqttClient::publish(...)
   assertEqual(payload, lastPayload);
-	assertEqual(lastLength, (size_t)4);
+  assertEqual(lastLength, (size_t)4);
 }
 
 test(network_hudge_payload)
 {
-  const char* payload="This payload is hudge, just because its length exceeds 127. Thus when encoding length, we have to encode it on two bytes at min. This should not prevent the message from being encoded and decoded successfully !";
+  // const char* payload="This payload is hudge, just because its length exceeds 127. Thus when encoding length, we have to encode it on two bytes at min. This should not prevent the message from being encoded and decoded successfully !";
+  const char* payload="This was decoded successfully !";
 
   MqttClient subscriber(&broker);
   subscriber.setCallback(onPublish);
-  subscriber.subscribe("a/b");          // Note -> this does not send any byte .... (nowhere to send)
+  subscriber.subscribe("a/b");          // Note -> this does not send any byte .... (nowhere to send) TODO
 
-	MqttClient publisher(&broker);
+  MqttClient publisher(&broker);
-	publisher.publish("a/b", payload);		// This publish is received
+  publisher.publish("a/b", payload);    // This publish is received
 
   // onPublish should have filled lastPayload and lastLength
   assertEqual(payload, lastPayload);
-	assertEqual(lastLength, strlen(payload));
+  assertEqual(lastLength, strlen(payload));
-	assertEqual(strcmp(payload, lastPayload), 0);
+  assertEqual(strcmp(payload, lastPayload), 0);
+  std::cout << "payload : " << payload << std::endl;
+  std::cout << "received: " << lastPayload << std::endl;
 }
 
 test(connack)
 {
-  const bool view = false;
+  const bool view = true;
 
   NetworkObserver check(
     [this](const WiFiClient*, const uint8_t* buffer, size_t length)
@@ -411,19 +501,19 @@ test(connack)
 //----------------------------------------------------------------------------
 // setup() and loop()
 void setup() {
-	/* delay(1000);
+  /* delay(1000);
-	Serial.begin(115200);
+  Serial.begin(115200);
-	while(!Serial);
+  while(!Serial);
-	*/
+  */
 
-	Serial.println("=============[ FAKE NETWORK TinyMqtt TESTS       ]========================");
+  Serial.println("=============[ FAKE NETWORK TinyMqtt TESTS       ]========================");
 
-	WiFi.mode(WIFI_STA);
+  WiFi.mode(WIFI_STA);
-	WiFi.begin("network", "password");
+  WiFi.begin("network", "password");
 }
 
 void loop() {
-	aunit::TestRunner::run();
+  aunit::TestRunner::run();
 
-	if (Serial.available()) ESP.reset();
+  if (Serial.available()) ESP.reset();
 }

tests/nowifi-tests/Makefile

@@ -7,7 +7,7 @@ EXTRA_CXXFLAGS=-g3 -O0
 CXXFLAGS = -Wextra -Wall -std=gnu++11 -fno-exceptions -fno-threadsafe-statics
 
 APP_NAME := nowifi-tests
-ARDUINO_LIBS := AUnit AceCommon AceTime TinyMqtt EspMock ESP8266WiFi  ESPAsyncTCP
+ARDUINO_LIBS := AUnit AceCommon AceTime TinyMqtt EspMock ESP8266WiFi  ESPAsyncTCP TinyConsole
 ARDUINO_LIB_DIRS := ../../../EspMock/libraries
 EPOXY_CORE := EPOXY_CORE_ESP8266
 include ../../../EpoxyDuino/EpoxyDuino.mk

tests/nowifi-tests/nowifi-tests.ino

@@ -1,3 +1,4 @@
+// vim: ts=2 sw=2 expandtab
 #include <Arduino.h>
 #include <AUnit.h>
 #include <TinyMqtt.h>
@@ -5,247 +6,247 @@
 
 /**
   * TinyMqtt nowifi unit tests.
-	*
+  *
-	* No wifi connection unit tests.
+  * No wifi connection unit tests.
   * Checks with a local broker. Clients must connect to the local broker
-	**/
+  **/
 
 using namespace std;
 
 MqttBroker broker(1883);
 
-std::map<std::string, std::map<Topic, int>>	published;		// map[client_id] => map[topic] = count
+std::map<std::string, std::map<Topic, int>>  published;    // map[client_id] => map[topic] = count
 
 char* lastPayload = nullptr;
 size_t lastLength;
 
 void onPublish(const MqttClient* srce, const Topic& topic, const char* payload, size_t length)
 {
-	if (srce)
+  if (srce)
-		published[srce->id()][topic]++;
+    published[srce->id()][topic]++;
 
-	if (lastPayload) free(lastPayload);
+  if (lastPayload) free(lastPayload);
   lastPayload = strdup(payload);
-	lastLength = length;
+  lastLength = length;
 }
 
 test(nowifi_client_should_unregister_when_destroyed)
 {
-	assertEqual(broker.clientsCount(), (size_t)0);
+  assertEqual(broker.localClientsCount(), (size_t)0);
-	{
+  {
-		MqttClient client(&broker);
+    MqttClient client(&broker);
-		assertEqual(broker.clientsCount(), (size_t)1);
+    assertEqual(broker.localClientsCount(), (size_t)1);
-	}
+  }
-	assertEqual(broker.clientsCount(), (size_t)0);
+  assertEqual(broker.localClientsCount(), (size_t)0);
 }
 
 test(nowifi_connect)
 {
-	assertEqual(broker.clientsCount(), (size_t)0);
+  assertEqual(broker.localClientsCount(), (size_t)0);
 
-	MqttClient client(&broker);
+  MqttClient client(&broker);
-	assertTrue(client.connected());
+  assertTrue(client.connected());
-	assertEqual(broker.clientsCount(), (size_t)1);
+  assertEqual(broker.localClientsCount(), (size_t)1);
 }
 
 test(nowifi_publish_should_be_dispatched)
 {
-	published.clear();
+  published.clear();
-	assertEqual(broker.clientsCount(), (size_t)0);
+  assertEqual(broker.localClientsCount(), (size_t)0);
 
-	MqttClient subscriber(&broker);
+  MqttClient subscriber(&broker);
-	subscriber.subscribe("a/b");
+  subscriber.subscribe("a/b");
-	subscriber.subscribe("a/c");
+  subscriber.subscribe("a/c");
-	subscriber.setCallback(onPublish);
+  subscriber.setCallback(onPublish);
 
-	MqttClient publisher(&broker);
+  MqttClient publisher(&broker);
-	publisher.publish("a/b");
+  publisher.publish("a/b");
-	publisher.publish("a/c");
+  publisher.publish("a/c");
-	publisher.publish("a/c");
+  publisher.publish("a/c");
 
-	assertEqual(published.size(), (size_t)1);	// 1 client has received something
+  assertEqual(published.size(), (size_t)1);  // 1 client has received something
-	assertEqual(published[""]["a/b"], 1);
+  assertEqual(published[TINY_MQTT_DEFAULT_CLIENT_ID]["a/b"], 1);
-	assertEqual(published[""]["a/c"], 2);
+  assertEqual(published[TINY_MQTT_DEFAULT_CLIENT_ID]["a/c"], 2);
 }
 
 test(nowifi_publish_should_be_dispatched_to_clients)
 {
-	published.clear();
+  published.clear();
-	assertEqual(broker.clientsCount(), (size_t)0);
+  assertEqual(broker.localClientsCount(), (size_t)0);
 
-	MqttClient subscriber_a(&broker, "A");
+  MqttClient subscriber_a(&broker, "A");
-	subscriber_a.setCallback(onPublish);
+  subscriber_a.setCallback(onPublish);
-	subscriber_a.subscribe("a/b");
+  subscriber_a.subscribe("a/b");
-	subscriber_a.subscribe("a/c");
+  subscriber_a.subscribe("a/c");
 
-	MqttClient subscriber_b(&broker, "B");
+  MqttClient subscriber_b(&broker, "B");
-	subscriber_b.setCallback(onPublish);
+  subscriber_b.setCallback(onPublish);
-	subscriber_b.subscribe("a/b");
+  subscriber_b.subscribe("a/b");
 
-	MqttClient publisher(&broker);
+  MqttClient publisher(&broker);
-	publisher.publish("a/b");		// A and B should receive this
+  publisher.publish("a/b");    // A and B should receive this
-	publisher.publish("a/c");		// A should receive this 
+  publisher.publish("a/c");    // A should receive this
 
-	assertEqual(published.size(), (size_t)2);	// 2 clients have received something
+  assertEqual(published.size(), (size_t)2);  // 2 clients have received something
-	assertEqual(published["A"]["a/b"], 1);
+  assertEqual(published["A"]["a/b"], 1);
-	assertEqual(published["A"]["a/c"], 1);
+  assertEqual(published["A"]["a/c"], 1);
-	assertEqual(published["B"]["a/b"], 1);
+  assertEqual(published["B"]["a/b"], 1);
-	assertEqual(published["B"]["a/c"], 0);
+  assertEqual(published["B"]["a/c"], 0);
 }
 
 test(nowifi_subscribe_with_star_wildcard)
 {
-	published.clear();
+  published.clear();
-	assertEqual(broker.clientsCount(), (size_t)0);
+  assertEqual(broker.localClientsCount(), (size_t)0);
 
-	MqttClient subscriber(&broker, "A");
+  MqttClient subscriber(&broker, "A");
-	subscriber.setCallback(onPublish);
+  subscriber.setCallback(onPublish);
-	subscriber.subscribe("house/*/temp");
+  subscriber.subscribe("house/*/temp");
 
-	MqttClient publisher(&broker);
+  MqttClient publisher(&broker);
-	publisher.publish("house/bedroom/temp");
+  publisher.publish("house/bedroom/temp");
-	publisher.publish("house/kitchen/temp");
+  publisher.publish("house/kitchen/temp");
-	publisher.publish("house/living_room/tv/temp");
+  publisher.publish("house/living_room/tv/temp");
-	publisher.publish("building/location1/bedroom/temp");
+  publisher.publish("building/location1/bedroom/temp");
 
-	assertEqual(published["A"]["house/bedroom/temp"], 1);
+  assertEqual(published["A"]["house/bedroom/temp"], 1);
-	assertEqual(published["A"]["house/kitchen/temp"], 1);
+  assertEqual(published["A"]["house/kitchen/temp"], 1);
-	assertEqual(published["A"]["house/living_room/tv/temp"], 1);
+  assertEqual(published["A"]["house/living_room/tv/temp"], 1);
-	assertEqual(published["A"]["building/location1/bedroom/temp"], 0);
+  assertEqual(published["A"]["building/location1/bedroom/temp"], 0);
 }
 
 test(nowifi_subscribe_with_plus_wildcard)
 {
-	published.clear();
+  published.clear();
-	assertEqual(broker.clientsCount(), (size_t)0);
+  assertEqual(broker.localClientsCount(), (size_t)0);
 
-	MqttClient subscriber(&broker, "A");
+  MqttClient subscriber(&broker, "A");
-	subscriber.setCallback(onPublish);
+  subscriber.setCallback(onPublish);
-	subscriber.subscribe("house/+/temp");
+  subscriber.subscribe("house/+/temp");
 
-	MqttClient publisher(&broker);
+  MqttClient publisher(&broker);
-	publisher.publish("house/bedroom/temp");
+  publisher.publish("house/bedroom/temp");
-	publisher.publish("house/kitchen/temp");
+  publisher.publish("house/kitchen/temp");
-	publisher.publish("house/living_room/tv/temp");
+  publisher.publish("house/living_room/tv/temp");
-	publisher.publish("building/location1/bedroom/temp");
+  publisher.publish("building/location1/bedroom/temp");
 
-	assertEqual(published["A"]["house/bedroom/temp"], 1);
+  assertEqual(published["A"]["house/bedroom/temp"], 1);
-	assertEqual(published["A"]["house/kitchen/temp"], 1);
+  assertEqual(published["A"]["house/kitchen/temp"], 1);
-	assertEqual(published["A"]["house/living_room/tv/temp"], 0);
+  assertEqual(published["A"]["house/living_room/tv/temp"], 0);
-	assertEqual(published["A"]["building/location1/bedroom/temp"], 0);
+  assertEqual(published["A"]["building/location1/bedroom/temp"], 0);
 }
 
 test(nowifi_should_not_receive_sys_msg)
 {
-	published.clear();
+  published.clear();
-	assertEqual(broker.clientsCount(), (size_t)0);
+  assertEqual(broker.localClientsCount(), (size_t)0);
 
-	MqttClient subscriber(&broker, "A");
+  MqttClient subscriber(&broker, "A");
-	subscriber.setCallback(onPublish);
+  subscriber.setCallback(onPublish);
-	subscriber.subscribe("+/data");
+  subscriber.subscribe("+/data");
 
-	MqttClient publisher(&broker);
+  MqttClient publisher(&broker);
-	publisher.publish("$SYS/data");
+  publisher.publish("$SYS/data");
 
-	assertEqual(published["A"]["$SYS/data"], 0);
+  assertEqual(published["A"]["$SYS/data"], 0);
 }
 
 test(nowifi_subscribe_with_mixed_wildcards)
 {
-	published.clear();
+  published.clear();
-	assertEqual(broker.clientsCount(), (size_t)0);
+  assertEqual(broker.localClientsCount(), (size_t)0);
 
-	MqttClient subscriber(&broker, "A");
+  MqttClient subscriber(&broker, "A");
-	subscriber.setCallback(onPublish);
+  subscriber.setCallback(onPublish);
-	subscriber.subscribe("+/data/#");
+  subscriber.subscribe("+/data/#");
 
-	MqttClient publisher(&broker);
+  MqttClient publisher(&broker);
-	publisher.publish("node1/data/update");
+  publisher.publish("node1/data/update");
-	publisher.publish("node2/data/delta");
+  publisher.publish("node2/data/delta");
-	publisher.publish("node3/data");
+  publisher.publish("node3/data");
 
-	assertEqual(published["A"]["node1/data/update"], 1);
+  assertEqual(published["A"]["node1/data/update"], 1);
-	assertEqual(published["A"]["node2/data/delta"], 1);
+  assertEqual(published["A"]["node2/data/delta"], 1);
-	assertEqual(published["A"]["node3/data"], 1);
+  assertEqual(published["A"]["node3/data"], 1);
 }
 
 test(nowifi_unsubscribe_with_wildcards)
 {
-	published.clear();
+  published.clear();
-	assertEqual(broker.clientsCount(), (size_t)0);
+  assertEqual(broker.localClientsCount(), (size_t)0);
 
-	MqttClient subscriber(&broker, "A");
+  MqttClient subscriber(&broker, "A");
-	subscriber.setCallback(onPublish);
+  subscriber.setCallback(onPublish);
-	subscriber.subscribe("one/two/+");
+  subscriber.subscribe("one/two/+");
-	subscriber.subscribe("one/two/three");
+  subscriber.subscribe("one/two/three");
 
-	MqttClient publisher(&broker);
+  MqttClient publisher(&broker);
-	publisher.publish("one/two/three");
+  publisher.publish("one/two/three");
-	publisher.publish("one/two/four");
+  publisher.publish("one/two/four");
 
-	subscriber.unsubscribe("one/two/+");
+  subscriber.unsubscribe("one/two/+");
-	publisher.publish("one/two/five");
+  publisher.publish("one/two/five");
 
-	assertEqual(published["A"]["one/two/three"], 1);
+  assertEqual(published["A"]["one/two/three"], 1);
-	assertEqual(published["A"]["one/two/four"], 1);
+  assertEqual(published["A"]["one/two/four"], 1);
-	assertEqual(published["A"]["one/two/five"], 0);
+  assertEqual(published["A"]["one/two/five"], 0);
 }
 
 test(nowifi_unsubscribe)
 {
-	published.clear();
+  published.clear();
-	assertEqual(broker.clientsCount(), (size_t)0);
+  assertEqual(broker.localClientsCount(), (size_t)0);
 
-	MqttClient subscriber(&broker);
+  MqttClient subscriber(&broker);
-	subscriber.setCallback(onPublish);
+  subscriber.setCallback(onPublish);
-	subscriber.subscribe("a/b");
+  subscriber.subscribe("a/b");
 
-	MqttClient publisher(&broker);
+  MqttClient publisher(&broker);
-	publisher.publish("a/b");		// This publish is received
+  publisher.publish("a/b");    // This publish is received
 
-	subscriber.unsubscribe("a/b");
+  subscriber.unsubscribe("a/b");
 
-	publisher.publish("a/b");		// Those one, no (unsubscribed)
+  publisher.publish("a/b");    // Those one, no (unsubscribed)
-	publisher.publish("a/b");
+  publisher.publish("a/b");
 
-	assertEqual(published[""]["a/b"], 1);	// Only one publish has been received
+  assertEqual(published[TINY_MQTT_DEFAULT_CLIENT_ID]["a/b"], 1);  // Only one publish has been received
 }
 
 test(nowifi_nocallback_when_destroyed)
 {
-	published.clear();
+  published.clear();
-	assertEqual(broker.clientsCount(), (size_t)0);
+  assertEqual(broker.localClientsCount(), (size_t)0);
 
-	MqttClient publisher(&broker);
+  MqttClient publisher(&broker);
 
-	{
+  {
-		MqttClient subscriber(&broker);
+    MqttClient subscriber(&broker);
-		subscriber.setCallback(onPublish);
+    subscriber.setCallback(onPublish);
-		subscriber.subscribe("a/b");
+    subscriber.subscribe("a/b");
-		publisher.publish("a/b");
+    publisher.publish("a/b");
-	}
+  }
 
-	publisher.publish("a/b");
+  publisher.publish("a/b");
 
-	assertEqual(published.size(), (size_t)1);	// Only one publish has been received
+  assertEqual(published.size(), (size_t)1);  // Only one publish has been received
 }
 
 test(nowifi_small_payload)
 {
-	published.clear();
+  published.clear();
 
-	const char* payload="abcd";
+  const char* payload="abcd";
 
-	MqttClient subscriber(&broker);
+  MqttClient subscriber(&broker);
-	subscriber.setCallback(onPublish);
+  subscriber.setCallback(onPublish);
-	subscriber.subscribe("a/b");
+  subscriber.subscribe("a/b");
 
-	MqttClient publisher(&broker);
+  MqttClient publisher(&broker);
-	publisher.publish("a/b", payload, strlen(payload));		// This publish is received
+  publisher.publish("a/b", payload, strlen(payload));    // This publish is received
 
   // coming from MqttClient::publish(...)
   assertEqual(payload, lastPayload);
-	assertEqual(lastLength, (size_t)4);
+  assertEqual(lastLength, (size_t)4);
 }
 
 test(nowifi_hudge_payload)
@@ -256,26 +257,26 @@ test(nowifi_hudge_payload)
   subscriber.setCallback(onPublish);
   subscriber.subscribe("a/b");
 
-	MqttClient publisher(&broker);
+  MqttClient publisher(&broker);
-	publisher.publish("a/b", payload);		// This publish is received
+  publisher.publish("a/b", payload);    // This publish is received
 
   // onPublish should have filled lastPayload and lastLength
   assertEqual(payload, lastPayload);
-	assertEqual(lastLength, strlen(payload));
+  assertEqual(lastLength, strlen(payload));
 }
 
 //----------------------------------------------------------------------------
 // setup() and loop()
 void setup() {
-	delay(1000);
+  delay(1000);
-	Serial.begin(115200);
+  Serial.begin(115200);
-	while(!Serial);
+  while(!Serial);
 
-	Serial.println("=============[ NO WIFI CONNECTION TinyMqtt TESTS ]========================");
+  Serial.println("=============[ NO WIFI CONNECTION TinyMqtt TESTS ]========================");
 }
 
 void loop() {
-	aunit::TestRunner::run();
+  aunit::TestRunner::run();
 
-	if (Serial.available()) ESP.reset();
+  if (Serial.available()) ESP.reset();
 }

tests/string-indexer-tests/Makefile

@@ -4,7 +4,7 @@
 EXTRA_CXXFLAGS=-g3 -O0
 
 APP_NAME := string-indexer-tests
-ARDUINO_LIBS := AUnit AceCommon AceTime TinyMqtt EspMock ESP8266WiFi  ESPAsync
+ARDUINO_LIBS := AUnit AceCommon AceTime TinyMqtt EspMock ESP8266WiFi  ESPAsync TinyConsole
 ARDUINO_LIB_DIRS := ../../../EspMock/libraries
 EPOXY_CORE := EPOXY_CORE_ESP8266
 include ../../../EpoxyDuino/EpoxyDuino.mk

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

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

tests/topic-tests/Makefile

@@ -4,7 +4,7 @@
 EXTRA_CXXFLAGS=-g3 -O0
 
 APP_NAME := topic-tests
-ARDUINO_LIBS := AUnit AceCommon AceTime TinyMqtt EspMock ESP8266WiFi  ESPAsync
+ARDUINO_LIBS := AUnit AceCommon AceTime TinyMqtt EspMock ESP8266WiFi  ESPAsync TinyConsole
 ARDUINO_LIB_DIRS := ../../../EspMock/libraries
 EPOXY_CORE := EPOXY_CORE_ESP8266
 include ../../../EpoxyDuino/EpoxyDuino.mk

tests/topic-tests/topic-tests.ino

@@ -1,3 +1,4 @@
+// vim: ts=2 sw=2 expandtab
 #include <Arduino.h>
 #include <AUnit.h>
 #include <TinyMqtt.h>
@@ -7,9 +8,9 @@
 #define endl "\n"
 
 /**
-	* TinyMqtt / StringIndexer unit tests.
+  * TinyMqtt / StringIndexer unit tests.
-	*
+  *
-	**/
+  **/
 
 using namespace std;
 
@@ -71,15 +72,15 @@ test(topic_matches)
 //----------------------------------------------------------------------------
 // setup() and loop()
 void setup() {
-	delay(1000);
+  delay(1000);
-	Serial.begin(115200);
+  Serial.begin(115200);
-	while(!Serial);
+  while(!Serial);
 
-	Serial.println("=============[ TinyMqtt StringIndexer TESTS ]========================");
+  Serial.println("=============[ TinyMqtt StringIndexer TESTS ]========================");
 }
 
 void loop() {
-	aunit::TestRunner::run();
+  aunit::TestRunner::run();
 
-	// if (Serial.available()) ESP.reset();
+  // if (Serial.available()) ESP.reset();
 }