Ooops bad tag

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

.github/workflows/superlinter.yml

@@ -1,26 +1,52 @@
-name: Super-Linter
+---
+#################################
+#################################
+## Super Linter GitHub Actions ##
+#################################
+#################################
+name: Lint Code Base
 
-# Run this workflow every time a new commit pushed to your repository
 #
+# Documentation:
+# https://docs.github.com/en/actions/learn-github-actions/workflow-syntax-for-github-actions
+#
+
+#############################
+# Start the job on all push #
+#############################
 on: push
 
+###############
+# Set the Job #
+###############
 jobs:
-  # Set the job key. The key is displayed as the job name
+  build:
-  # when a job name is not provided
-  super-lint:
     # Name the Job
-    name: Lint code base
+    name: Lint Code Base
-    # Set the type of machine to run on
+    # Set the agent to run on
     runs-on: ubuntu-latest
 
+    ##################
+    # Load all steps #
+    ##################
     steps:
-      # Checks out a copy of your repository on the ubuntu-latest machine
+      ##########################
-      - name: Checkout code
+      # Checkout the code base #
-        uses: actions/checkout@v2
+      ##########################
+      - name: Checkout Code
+        uses: actions/checkout@v3
+        with:
+          # Full git history is needed to get a proper
+          # list of changed files within `super-linter`
+          fetch-depth: 0
 
-      # Runs the Super-Linter action
+      ################################
-      - name: Run Super-Linter
+      # Run Linter against code base #
-        uses: github/super-linter@v3
+      ################################
+      - name: Lint Code Base
+        uses: github/super-linter/slim@v4
         env:
+          VALIDATE_ALL_CODEBASE: false
+          # Change to 'master' if your main branch differs
           DEFAULT_BRANCH: main
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

README.md

@@ -17,11 +17,20 @@ TinyMqtt is a small, fast and capable Mqtt Broker and Client for Esp8266 / Esp32
   The max I've seen was 2k msg/s (1 client 1 subscription)
 - Act as as a mqtt broker and/or a mqtt client
 - Mqtt 3.1.1 / Qos 0 supported
+- Wildcards supported (+ # $ and * (even if not part of the spec...))
 - Standalone (can work without WiFi) (degraded/local mode)
 - Brokers can connect to another broker and becomes then a
   proxy for clients that are connected to it.
 - zeroconf, this is a strange but very powerful mode where
   all brokers tries to connect together on the same local network.
+- small memory footprint (very efficient topic storage)
+- long messages are supported (>127 bytes)
+- TinyMQTT is largely unit tested, so once a bug is fixed, it is fixed forever
+
+## Limitations
+
+- Max of 255 different topics can be stored (change index_t type to allow more)
+- No Qos because messages are not queued but immediately sent to clients
 
 ## Quickstart
 
@@ -33,10 +42,11 @@ TinyMqtt is a small, fast and capable Mqtt Broker and Client for Esp8266 / Esp32
 
 | Example             | Description                                |
 | ------------------- | ------------------------------------------ |
-| client-without-wifi | standalone example                         |
+| [client-with-wifi](https://github.com/hsaturn/TinyMqtt/tree/main/examples/client-with-wifi/client-with-wifi.ino) | standalone example                         |
-| simple-client       | Connect the ESP to an external Mqtt broker |
+| [client-without-wifi](https://github.com/hsaturn/TinyMqtt/tree/main/examples/client-without-wifi/client-without-wifi.ino) | standalone example                         |
-| simple-broker       | Simple Mqtt broker with your ESP           |
+| [simple-client](https://github.com/hsaturn/TinyMqtt/tree/main/examples/simple-client/simple-client.ino)       | Connect the ESP to an external Mqtt broker |
-| tinymqtt-test       | Complex console example                    |
+| [simple-broker](https://github.com/hsaturn/TinyMqtt/tree/main/examples/simple-broker/simple-broker.ino)       | Simple Mqtt broker with your ESP           |
+| [tinymqtt-test](https://github.com/hsaturn/TinyMqtt/tree/main/examples/tinymqtt-test/tinymqtt-test.ino)       | Complex console example                    |
 
 - tinymqtt-test : This is a complex sketch with a terminal console
   that allows to add clients publish, connect etc with interpreted commands.
@@ -59,7 +69,7 @@ no need for having tons of clients (also RAM is the problem with many clients)
 * ~~MqttClient auto re-subscribe (::resubscribe works bad on broker.emqx.io)~~
 * MqttClient auto reconnection
 * MqttClient user/password
-* Wildcards (I may implement only # as I'm not interrested by a clever and cpu consuming matching)
+* ~~Wildcards (I may implement only # as I'm not interrested by a clever and cpu consuming matching)~~
 * I suspect that MqttClient::parent could be removed and replaced with a simple boolean
   (this'll need to rewrite a few functions)
 

examples/tinymqtt-test/tinymqtt-test.ino

@@ -1,3 +1,5 @@
+// vim: ts=2 sw=2
+#define TINY_MQTT_DEBUG
 #include <TinyMqtt.h>       // https://github.com/hsaturn/TinyMqtt
 #include <MqttStreaming.h>
 #if defined(ESP8266)
@@ -33,14 +35,19 @@ std::string topic="sensor/temperature";
 void onPublish(const MqttClient* srce, const Topic& topic, const char* payload, size_t length)
 {
 	Serial << "--> " << srce->id().c_str() << ": ======> received " << topic.c_str();
-	if (payload) Serial << ", payload[" << length << "]=[";
+	if (payload)
-	while(length--)
 	{
-		const char c=*payload++;
+		Serial << ", payload[" << length << "]=[";
-		if (c!=10 and c!=13 and c <32) Serial << '?';
+		while(length--)
-		Serial << *payload++;
+		{
+			const char c=*payload++;
+			if (c<32)
+				Serial << '?';
+			else
+				Serial << c;
+		}
+		Serial << ']' << endl;
 	}
-	Serial<< endl;
 }
 
 std::map<std::string, MqttClient*> clients;
@@ -673,7 +680,12 @@ void eval(std::string& cmd)
 		else if (compare(s, "broker"))
 		{
 			std::string id=getword(cmd);
-			if (id.length() or brokers.find(id)!=brokers.end())
+      if (clients.find(id) != clients.end())
+      {
+        Serial << "A client already have that name" << endl;
+        cmd.clear();
+      }
+			else if (id.length() or brokers.find(id)!=brokers.end())
 			{
 				int port=getint(cmd, 0);
 				if (port)
@@ -685,16 +697,26 @@ void eval(std::string& cmd)
 					Serial << "new broker (" << id.c_str() << ")" << endl;
 				}
 				else
+        {
 					Serial << "Missing port" << endl;
+          cmd.clear();
+        }
 			}
 			else
+      {
 				Serial << "Missing or existing broker name (" << id.c_str() << ")" << endl;
-			cmd+=" ls";
+        cmd.clear();
+      }
 		}
 		else if (compare(s, "client"))
 		{
 			std::string id=getword(cmd);
-			if (id.length() or clients.find(id)!=clients.end())
+      if (brokers.find(id) != brokers.end())
+      {
+				Serial << "A broker have that name" << endl;
+				cmd.clear();
+      }
+			else if (id.length() or clients.find(id)!=clients.end())
 			{
 				s=getword(cmd);	// broker name
 				if (s=="" or brokers.find(s) != brokers.end())
@@ -711,11 +733,14 @@ void eval(std::string& cmd)
 				else if (s.length())
 				{
 					Serial << " not found." << endl;
+				  cmd.clear();
 				}
 			}
 			else
+      {
 				Serial << "Missing or existing client name" << endl;
-			cmd+=" ls";
+        cmd.clear();
+ 			}
 		}
 		else if (compare(s, "set"))
 		{
@@ -766,7 +791,9 @@ void eval(std::string& cmd)
 		{
 			Serial << "syntax:" << endl;
 			Serial << "  MqttBroker:" << endl;
-			Serial << "    broker {name} {port} : create a new broker" << endl;
+			Serial << "    broker {broker_name} {port} : create a new broker" << endl;
+      Serial << "      broker_name.delete : delete a broker (buggy)" << endl;
+      Serial << "      broker_name.view   : dump a broker" << endl;
 			Serial << endl;
 			Serial << "  MqttClient:" << endl;
 			Serial << "    client {name} {parent broker} : create a client then" << endl;
@@ -775,17 +802,18 @@ void eval(std::string& cmd)
 			Serial << "      name.publish [topic][payload]" << endl;
 			Serial << "      name.view" << endl;
 			Serial << "      name.delete" << endl;
+			Serial << endl;
 
 			automatic::help();
 			Serial << endl;
-			Serial << "    help" << endl;
+			Serial << "  help" << endl;
-			Serial << "    blink [Dx on_ms off_ms]" << endl;
+			Serial << "  blink [Dx on_ms off_ms]    : make pin blink" << endl;
-			Serial << "    ls / ip / reset" << endl;
+			Serial << "  ls / ip / reset" << endl;
-			Serial << "    set [name][value]" << endl;
+			Serial << "  set [name][value]" << endl;
-			Serial << "    !  repeat last command" << endl;
+			Serial << "  !  repeat last command" << endl;
 			Serial << endl;
 			Serial << "  echo [on|off] or strings" << endl;
-			Serial << "  every ms [command]; every list; every remove [nr|all], every (on|off) [#]" << endl;
+			Serial << "  every ms [command]; every list; every remove [nr|all]; every (on|off) [#]" << endl;
 			Serial << "  on {output}; off {output}" << endl;
 			Serial << "  $id : name of the client." << endl;
 			Serial << "  rnd[(min[,max])] random number." << endl;
@@ -855,11 +883,6 @@ void loop()
   MDNS.update();
   #endif
 
-	if (MqttClient::counter != count)
-	{
-		Serial << "# " << MqttClient::counter << endl;
-		count = MqttClient::counter;
-	}
 	for(auto it: brokers)
 		it.second->loop();
 

library.json

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

library.properties

@@ -1,5 +1,5 @@
 name=TinyMqtt
-version=0.8.0
+version=0.9.5
 author=Francois BIOT, HSaturn, <hsaturn@gmail.com>
 maintainer=Francois BIOT, HSaturn, <hsaturn@gmail.com>
 sentence=A tiny broker and client library for MQTT messaging.
@@ -8,4 +8,3 @@ category=Communication
 url=https://github.com/hsaturn/TinyMqtt
 architectures=*
 includes=TinyMqtt.h
-depends=AsyncTCP

src/StringIndexer.h

@@ -9,121 +9,124 @@
  */
 class StringIndexer
 {
-	class StringCounter
+  class StringCounter
-	{
+  {
-		std::string str;
+    std::string str;
-		uint8_t used=0;
+    uint8_t used=0;
-		friend class StringIndexer;
+    friend class StringIndexer;
 
-		#if EPOXY_DUINO
+    #if EPOXY_DUINO
-		public:
+    public:
-		// Workaround to avoid coredump in Indexer::release
+    // Workaround to avoid coredump in Indexer::release
-		// when destroying a Topic after the deletion of
+    // when destroying a Topic after the deletion of
-		// StringIndexer::strings map (which can occurs only with AUnit,
+    // StringIndexer::strings map (which can occurs only with AUnit,
-		// never in the ESP itself, because ESP never ends)
+    // never in the ESP itself, because ESP never ends)
-		// (I hate static vars)
+    // (I hate static vars)
-		~StringCounter() { used=255; }
+    ~StringCounter() { used=255; }
-		#endif
+    #endif
-	};
+  };
-	public:
+  public:
-		using index_t=uint8_t;
+    using index_t = uint8_t;
 
-		static index_t strToIndex(const char* str, uint8_t len)
+   static const std::string& str(const index_t& index)
-		{
+    {
-			for(auto it=strings.begin(); it!=strings.end(); it++)
+      static std::string dummy;
-			{
+      const auto& it=strings.find(index);
-				if (strncmp(it->second.str.c_str(), str, len)==0)
+      if (it == strings.end()) return dummy;
-				{
+      return it->second.str;
-					it->second.used++;
+    }
-					return it->first;
-				}
-			}
-			for(index_t index=1; index; index++)
-			{
-				if (strings.find(index)==strings.end())
-				{
-					strings[index].str = std::string(str, len);
-					strings[index].used++;
-					// Serial << "Creating index " << index << " for (" << strings[index].str.c_str() << ") len=" << len << endl;
-					return index;
-				}
-			}
-			return 0;	// TODO out of indexes
-		}
 
-		static const std::string& str(const index_t& index)
+    static void use(const index_t& index)
-		{
+    {
-			static std::string dummy;
+      auto it=strings.find(index);
-			const auto& it=strings.find(index);
+      if (it != strings.end()) it->second.used++;
-			if (it == strings.end()) return dummy;
+    }
-			return it->second.str;
-		}
 
-		static void use(const index_t& index)
+    static void release(const index_t& index)
-		{
+    {
-			auto it=strings.find(index);
+      auto it=strings.find(index);
-			if (it != strings.end()) it->second.used++;
+      if (it != strings.end())
-		}
+      {
+        it->second.used--;
+        if (it->second.used == 0)
+        {
+          strings.erase(it);
+          // Serial << "Removing string(" << it->second.str.c_str() << ") size=" << strings.size() << endl;
+        }
+      }
+    }
 
-		static void release(const index_t& index)
+    static uint16_t count() { return strings.size(); }
-		{
-			auto it=strings.find(index);
-			if (it != strings.end())
-			{
-				it->second.used--;
-				if (it->second.used == 0)
-				{
-					strings.erase(it);
-					// Serial << "Removing string(" << it->second.str.c_str() << ") size=" << strings.size() << endl;
-				}
-			}
-		}
 
-		static uint16_t count() { return strings.size(); }
+  private:
+    friend class IndexedString;
 
-	private:
+    // increment use of str or create a new index
-		static std::map<index_t, StringCounter> strings;
+    static index_t strToIndex(const char* str, uint8_t len)
+    {
+      for(auto it=strings.begin(); it!=strings.end(); it++)
+      {
+        if (it->second.str.length() == len && strcmp(it->second.str.c_str(), str)==0)
+        {
+          it->second.used++;
+          return it->first;
+        }
+      }
+      for(index_t index=1; index; index++)
+      {
+        if (strings.find(index)==strings.end())
+        {
+          strings[index].str = std::string(str, len);
+          strings[index].used++;
+          // Serial << "Creating index " << index << " for (" << strings[index].str.c_str() << ") len=" << len << endl;
+          return index;
+        }
+      }
+      return 0;  // TODO out of indexes
+    }
+
+    static std::map<index_t, StringCounter> strings;
 };
 
 class IndexedString
 {
-	public:
+  public:
-		IndexedString(const IndexedString& source)
+    IndexedString(const IndexedString& source)
-		{
+    {
-			StringIndexer::use(source.index);
+      StringIndexer::use(source.index);
-			index = source.index;
+      index = source.index;
-		}
+    }
 
-		IndexedString(const char* str, uint8_t len)
+    IndexedString(const char* str, uint8_t len)
-		{
+    {
-			index=StringIndexer::strToIndex(str, len);
+      index=StringIndexer::strToIndex(str, len);
-		}
+    }
 
-		IndexedString(const std::string& str) : IndexedString(str.c_str(), str.length()) {};
+    IndexedString(const std::string& str) : IndexedString(str.c_str(), str.length()) {};
 
-		~IndexedString() { StringIndexer::release(index); }
+    ~IndexedString() { StringIndexer::release(index); }
 
-		IndexedString& operator=(const IndexedString& source)
+    IndexedString& operator=(const IndexedString& source)
-		{
+    {
-			StringIndexer::use(source.index);
+      StringIndexer::use(source.index);
-			index = source.index;
+      index = source.index;
-			return *this;
+      return *this;
-		}
+    }
 
-		friend bool operator<(const IndexedString& i1, const IndexedString& i2)
+    friend bool operator<(const IndexedString& i1, const IndexedString& i2)
-		{
+    {
-			return i1.index < i2.index;
+      return i1.index < i2.index;
-		}
+    }
 
-		friend bool operator==(const IndexedString& i1, const IndexedString& i2)
+    friend bool operator==(const IndexedString& i1, const IndexedString& i2)
-		{
+    {
-			return i1.index == i2.index;
+      return i1.index == i2.index;
-		}
+    }
 
-		const std::string& str() const { return StringIndexer::str(index); }
+    const std::string& str() const { return StringIndexer::str(index); }
 
-		const StringIndexer::index_t& getIndex() const { return index; }
+    const StringIndexer::index_t& getIndex() const { return index; }
 
-	private:
+  private:
-		StringIndexer::index_t index;
+    StringIndexer::index_t index;
 };

src/TinyMqtt.h

@@ -1,18 +1,18 @@
 #pragma once
 
-// TODO Should add a AUnit with both TCP_ASYNC and not TCP_ASYNC
+// TODO Should add a AUnit with both TINY_MQTT_ASYNC and not TINY_MQTT_ASYNC
-// #define TCP_ASYNC	// Uncomment this to use ESPAsyncTCP instead of normal cnx
+// #define TINY_MQTT_ASYNC  // Uncomment this to use ESPAsyncTCP instead of normal cnx
 
 #if defined(ESP8266) || defined(EPOXY_DUINO)
-	#ifdef TCP_ASYNC
+  #ifdef TINY_MQTT_ASYNC
-		#include <ESPAsyncTCP.h>
+    #include <ESPAsyncTCP.h>
   #else
     #include <ESP8266WiFi.h>
   #endif
 #elif defined(ESP32)
   #include <WiFi.h>
-	#ifdef TCP_ASYNC
+  #ifdef TINY_MQTT_ASYNC
-	  #include <AsyncTCP.h> // https://github.com/me-no-dev/AsyncTCP
+    #include <AsyncTCP.h> // https://github.com/me-no-dev/AsyncTCP
   #endif
 #endif
 #ifdef EPOXY_DUINO
@@ -20,6 +20,14 @@
 #else
   #define dbg_ptr uint32_t
 #endif
+
+#ifdef WIO_TERMINAL
+  // Uncommon board handling
+  // If you have a problem with this line, just remove it.
+  // Note: https://github.com/hsaturn/TinyMqtt/issues/41
+  #include <rpcWiFi.h>
+#endif
+
 #include <vector>
 #include <set>
 #include <string>
@@ -34,7 +42,7 @@
   #define debug(what) {}
 #endif
 
-#ifdef TCP_ASYNC
+#ifdef TINY_MQTT_ASYNC
   using TcpClient = AsyncClient;
   using TcpServer = AsyncServer;
 #else
@@ -44,165 +52,165 @@
 
 enum __attribute__((packed)) MqttError
 {
-	MqttOk = 0,
+  MqttOk = 0,
-	MqttNowhereToSend=1,
+  MqttNowhereToSend=1,
-	MqttInvalidMessage=2,
+  MqttInvalidMessage=2,
 };
 
 class Topic : public IndexedString
 {
-	public:
+  public:
-		Topic(const char* s, uint8_t len) : IndexedString(s,len){}
+    Topic(const char* s, uint8_t len) : IndexedString(s,len){}
-		Topic(const char* s) : Topic(s, strlen(s)) {}
+    Topic(const char* s) : Topic(s, strlen(s)) {}
-		Topic(const std::string s) : Topic(s.c_str(), s.length()){};
+    Topic(const std::string s) : Topic(s.c_str(), s.length()){};
 
-		const char* c_str() const { return str().c_str(); }
+    const char* c_str() const { return str().c_str(); }
 
-		bool matches(const Topic&) const;
+    bool matches(const Topic&) const;
 };
 
 class MqttClient;
 class MqttMessage
 {
-	const uint16_t MaxBufferLength = 4096;  //hard limit: 16k due to size decoding
+  const uint16_t MaxBufferLength = 4096;  //hard limit: 16k due to size decoding
-	public:
+  public:
-		enum __attribute__((packed)) Type
+    enum __attribute__((packed)) Type
-		{
+    {
-			Unknown     =    0,
+      Unknown     =    0,
-			Connect     = 0x10,
+      Connect     = 0x10,
-			ConnAck     = 0x20,
+      ConnAck     = 0x20,
-			Publish     = 0x30,
+      Publish     = 0x30,
-			PubAck      = 0x40,
+      PubAck      = 0x40,
-			Subscribe   = 0x80,
+      Subscribe   = 0x80,
-			SubAck      = 0x90,
+      SubAck      = 0x90,
-			UnSubscribe = 0xA0,
+      UnSubscribe = 0xA0,
-			UnSuback	  = 0xB0,
+      UnSuback    = 0xB0,
-			PingReq     = 0xC0,
+      PingReq     = 0xC0,
-			PingResp    = 0xD0,
+      PingResp    = 0xD0,
-			Disconnect  = 0xE0
+      Disconnect  = 0xE0
-		};
+    };
-		enum __attribute__((packed)) State
+    enum __attribute__((packed)) State
-		{
+    {
-			FixedHeader=0,
+      FixedHeader=0,
-			Length=1,
+      Length=1,
-			VariableHeader=2,
+      VariableHeader=2,
-			PayLoad=3,
+      PayLoad=3,
-			Complete=4,
+      Complete=4,
-			Error=5,
+      Error=5,
-			Create=6
+      Create=6
-		};
+    };
 
-		MqttMessage() { reset(); }
+    MqttMessage() { reset(); }
-		MqttMessage(Type t, uint8_t bits_d3_d0=0) { create(t); buffer[0] |= bits_d3_d0; }
+    MqttMessage(Type t, uint8_t bits_d3_d0=0) { create(t); buffer[0] |= bits_d3_d0; }
-		void incoming(char byte);
+    void incoming(char byte);
-		void add(char byte) { incoming(byte); }
+    void add(char byte) { incoming(byte); }
-		void add(const char* p, size_t len, bool addLength=true );
+    void add(const char* p, size_t len, bool addLength=true );
-		void add(const std::string& s) { add(s.c_str(), s.length()); }
+    void add(const std::string& s) { add(s.c_str(), s.length()); }
-		void add(const Topic& t) { add(t.str()); }
+    void add(const Topic& t) { add(t.str()); }
-		const char* end() const { return &buffer[0]+buffer.size(); }
+    const char* end() const { return &buffer[0]+buffer.size(); }
-		const char* getVHeader() const { return &buffer[vheader]; }
+    const char* getVHeader() const { return &buffer[vheader]; }
-		void complete() { encodeLength(); }
+    void complete() { encodeLength(); }
 
-		void reset();
+    void reset();
 
-		// buff is MSB/LSB/STRING
+    // buff is MSB/LSB/STRING
-		// output buff+=2, len=length(str)
+    // output buff+=2, len=length(str)
-		static void getString(const char* &buff, uint16_t& len);
+    static void getString(const char* &buff, uint16_t& len);
 
-		Type type() const
+    Type type() const
-		{
+    {
-			return state == Complete ? static_cast<Type>(buffer[0] & 0xF0) : Unknown;
+      return state == Complete ? static_cast<Type>(buffer[0] & 0xF0) : Unknown;
-		}
+    }
 
-		uint8_t flags() const { return static_cast<uint8_t>(buffer[0] & 0x0F); }
+    uint8_t flags() const { return static_cast<uint8_t>(buffer[0] & 0x0F); }
 
-		void create(Type type)
+    void create(Type type)
-		{
+    {
-			buffer=(decltype(buffer)::value_type)type;
+      buffer=(decltype(buffer)::value_type)type;
-			buffer+='\0';		// reserved for msg length byte 1/2
+      buffer+='\0';    // reserved for msg length byte 1/2
-			buffer+='\0';		// reserved for msg length byte 2/2 (fixed)
+      buffer+='\0';    // reserved for msg length byte 2/2 (fixed)
-			vheader=3;      // Should never change
+      vheader=3;      // Should never change
-			size=0;
+      size=0;
-			state=Create;
+      state=Create;
-		}
+    }
-		MqttError sendTo(MqttClient*);
+    MqttError sendTo(MqttClient*);
-		void hexdump(const char* prefix=nullptr) const;
+    void hexdump(const char* prefix=nullptr) const;
 
-	private:
+  private:
-		void encodeLength();
+    void encodeLength();
 
-		std::string buffer;
+    std::string buffer;
-		uint8_t vheader;
+    uint8_t vheader;
-		uint16_t size;	// bytes left to receive
+    uint16_t size;  // bytes left to receive
-		State state;
+    State state;
 };
 
 class MqttBroker;
 class MqttClient
 {
-	using CallBack = void (*)(const MqttClient* source, const Topic& topic, const char* payload, size_t payload_length);
+  using CallBack = void (*)(const MqttClient* source, const Topic& topic, const char* payload, size_t payload_length);
-	enum __attribute__((packed)) Flags
+  enum __attribute__((packed)) Flags
-	{
+  {
-		FlagUserName = 128,
+    FlagUserName = 128,
-		FlagPassword = 64,
+    FlagPassword = 64,
-		FlagWillRetain = 32,	// unsupported
+    FlagWillRetain = 32,  // unsupported
-		FlagWillQos = 16 | 8, // unsupported
+    FlagWillQos = 16 | 8, // unsupported
-		FlagWill = 4,			    // unsupported
+    FlagWill = 4,          // unsupported
-		FlagCleanSession = 2,	// unsupported
+    FlagCleanSession = 2,  // unsupported
-		FlagReserved = 1
+    FlagReserved = 1
-	};
+  };
-	public:
+  public:
-	  /** Constructor. If broker is not null, this is the adress of a local broker.
+    /** Constructor. If broker is not null, this is the adress of a local broker.
-		    If you want to connect elsewhere, leave broker null and use connect() **/
+        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="");
-		MqttClient(const std::string& id) : MqttClient(nullptr, id){}
+    MqttClient(const std::string& id) : MqttClient(nullptr, id){}
 
-		~MqttClient();
+    ~MqttClient();
 
-		void connect(MqttBroker* parent);
+    void connect(MqttBroker* parent);
-		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 = 10);
 
     // TODO it seems that connected returns true in tcp mode even if
     // no negociation occured (only if tcp link is established)
-		bool connected() { return
+    bool connected() { return
-			(parent!=nullptr and client==nullptr) or
+      (parent!=nullptr and client==nullptr) or
-			(client and client->connected()); }
+      (client and client->connected()); }
-		void write(const char* buf, size_t length)
+    void write(const char* buf, size_t length)
-		{ if (client) client->write(buf, length); }
+    { if (client) client->write(buf, length); }
 
-		const std::string& id() const { return clientId; }
+    const std::string& id() const { return clientId; }
-		void id(std::string& new_id) { clientId = new_id; }
+    void id(std::string& new_id) { clientId = new_id; }
 
-		/** Should be called in main loop() */
+    /** Should be called in main loop() */
-		void loop();
+    void loop();
-		void close(bool bSendDisconnect=true);
+    void close(bool bSendDisconnect=true);
-		void setCallback(CallBack fun)
+    void setCallback(CallBack fun)
-		{
+    {
-			callback=fun;
+      callback=fun;
-			#ifdef TINY_MQTT_DEBUG
+      #ifdef TINY_MQTT_DEBUG
-				Serial << "Callback set to " << (long)fun << endl;
+        Serial << "Callback set to " << (long)fun << endl;
-				if (callback) callback(this, "test/topic", "value", 5);
+        if (callback) callback(this, "test/topic", "value", 5);
-			#endif
+      #endif
-		};
+    };
 
-		// Publish from client to the world
+    // Publish from client to the world
-		MqttError publish(const Topic&, const char* payload, size_t pay_length);
+    MqttError publish(const Topic&, const char* payload, size_t pay_length);
-		MqttError publish(const Topic& t, const char* payload) { return publish(t, payload, strlen(payload)); }
+    MqttError publish(const Topic& t, const char* payload) { return publish(t, payload, strlen(payload)); }
-		MqttError publish(const Topic& t, const String& s) { return publish(t, s.c_str(), s.length()); }
+    MqttError publish(const Topic& t, const String& s) { return publish(t, s.c_str(), s.length()); }
-		MqttError publish(const Topic& t, const std::string& s) { return publish(t,s.c_str(),s.length());}
+    MqttError publish(const Topic& t, const std::string& s) { return publish(t,s.c_str(),s.length());}
-		MqttError publish(const Topic& t) { return publish(t, nullptr, 0);};
+    MqttError publish(const Topic& t) { return publish(t, nullptr, 0);};
 
-		MqttError subscribe(Topic topic, uint8_t qos=0);
+    MqttError subscribe(Topic topic, uint8_t qos=0);
-		MqttError unsubscribe(Topic topic);
+    MqttError unsubscribe(Topic topic);
-		bool isSubscribedTo(const Topic& topic) const;
+    bool isSubscribedTo(const Topic& topic) const;
 
-		// connected to local broker
+    // connected to local broker
-		// TODO seems to be useless
+    // TODO seems to be useless
-		bool isLocal() const { return client == nullptr; }
+    bool isLocal() const { return client == nullptr; }
 
-		void dump(std::string indent="")
+    void dump(std::string indent="")
-		{
+    {
-		  (void)indent;
+      (void)indent;
       #ifdef TINY_MQTT_DEBUG
         uint32_t ms=millis();
         Serial << indent << "+-- " << '\'' << clientId.c_str() << "' " << (connected() ? " ON " : " OFF");
@@ -213,7 +221,6 @@ class MqttClient
           bool c = false;
           Serial << " [";
           for(auto s: subscriptions)
-            (void)indent;
           {
             if (c) Serial << ", ";
             Serial << s.str().c_str();
@@ -223,100 +230,100 @@ class MqttClient
         }
         Serial << endl;
       #endif
-		}
+    }
 
 #ifdef EPOXY_DUINO
-		static std::map<MqttMessage::Type, int> counters;  // Number of processed messages
+    static std::map<MqttMessage::Type, int> counters;  // Number of processed messages
 #endif
 
-	private:
+  private:
 
-		// event when tcp/ip link established (real or fake)
+    // event when tcp/ip link established (real or fake)
-		static void onConnect(void * client_ptr, TcpClient*);
+    static void onConnect(void * client_ptr, TcpClient*);
-#ifdef TCP_ASYNC
+#ifdef TINY_MQTT_ASYNC
-		static void onData(void* client_ptr, TcpClient*, void* data, size_t len);
+    static void onData(void* client_ptr, TcpClient*, void* data, size_t len);
 #endif
-		MqttError sendTopic(const Topic& topic, MqttMessage::Type type, uint8_t qos);
+    MqttError sendTopic(const Topic& topic, MqttMessage::Type type, uint8_t qos);
-		void resubscribe();
+    void resubscribe();
 
-		friend class MqttBroker;
+    friend class MqttBroker;
-		MqttClient(MqttBroker* parent, TcpClient* client);
+    MqttClient(MqttBroker* parent, TcpClient* client);
-		// republish a received publish if topic matches any in subscriptions
+    // republish a received publish if topic matches any in subscriptions
-		MqttError publishIfSubscribed(const Topic& topic, MqttMessage& msg);
+    MqttError publishIfSubscribed(const Topic& topic, MqttMessage& msg);
 
-		void clientAlive(uint32_t more_seconds);
+    void clientAlive(uint32_t more_seconds);
-		void processMessage(MqttMessage* message);
+    void processMessage(MqttMessage* message);
 
-		bool mqtt_connected = false;
+    bool mqtt_connected = false;
-		char mqtt_flags;
+    char mqtt_flags;
-		uint32_t keep_alive = 60;
+    uint32_t keep_alive = 60;
-		uint32_t alive;
+    uint32_t alive;
-		MqttMessage message;
+    MqttMessage message;
 
-		// TODO	having a pointer on MqttBroker may produce larger binaries
+    // TODO  having a pointer on MqttBroker may produce larger binaries
-		// due to unecessary function linked if ever parent is not used
+    // due to unecessary function linked if ever parent is not used
-		// (this is the case when MqttBroker isn't used except here)
+    // (this is the case when MqttBroker isn't used except here)
-		MqttBroker* parent=nullptr;		// connection to local broker
+    MqttBroker* parent=nullptr;    // connection to local broker
 
-		TcpClient* client=nullptr;		// connection to remote broker
+    TcpClient* client=nullptr;    // connection to remote broker
-		std::set<Topic>	subscriptions;
+    std::set<Topic>  subscriptions;
-		std::string clientId;
+    std::string clientId;
-		CallBack callback = nullptr;
+    CallBack callback = nullptr;
 };
 
 class MqttBroker
 {
-	enum __attribute__((packed)) State
+  enum __attribute__((packed)) State
-	{
+  {
-		Disconnected,	// Also the initial state
+    Disconnected,  // Also the initial state
-		Connecting,		// connect and sends a fake publish to avoid circular cnx
+    Connecting,    // connect and sends a fake publish to avoid circular cnx
-		Connected,		// this->broker is connected and circular cnx avoided
+    Connected,    // this->broker is connected and circular cnx avoided
-	};
+  };
-	public:
+  public:
-	  // TODO limit max number of clients
+    // TODO limit max number of clients
-		MqttBroker(uint16_t port);
+    MqttBroker(uint16_t port);
-		~MqttBroker();
+    ~MqttBroker();
 
-		void begin() { server->begin(); }
+    void begin() { server->begin(); }
-		void loop();
+    void loop();
 
-		void connect(const std::string& host, uint16_t port=1883);
+    void connect(const std::string& host, uint16_t port=1883);
-		bool connected() const { return state == Connected; }
+    bool connected() const { return state == Connected; }
 
-		size_t clientsCount() const { return clients.size(); }
+    size_t clientsCount() const { return clients.size(); }
 
-		void dump(std::string indent="")
+    void dump(std::string indent="")
-		{
+    {
-			for(auto client: clients)
+      for(auto client: clients)
-				client->dump(indent);
+        client->dump(indent);
-		}
+    }
 
-	private:
+  private:
-		friend class MqttClient;
+    friend class MqttClient;
 
-		static void onClient(void*, TcpClient*);
+    static void onClient(void*, TcpClient*);
-		bool checkUser(const char* user, uint8_t len) const
+    bool checkUser(const char* user, uint8_t len) const
-		{ return compareString(auth_user, user, len); }
+    { return compareString(auth_user, user, len); }
 
-		bool checkPassword(const char* password, uint8_t len) const
+    bool checkPassword(const char* password, uint8_t len) const
-		{ return compareString(auth_password, password, len); }
+    { return compareString(auth_password, password, len); }
 
 
-		MqttError publish(const MqttClient* source, const Topic& topic, MqttMessage& msg) const;
+    MqttError publish(const MqttClient* source, const Topic& topic, MqttMessage& msg) const;
 
-		MqttError subscribe(const Topic& topic, uint8_t qos);
+    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
-		void addClient(MqttClient* client);
+    void addClient(MqttClient* client);
-		void removeClient(MqttClient* client);
+    void removeClient(MqttClient* client);
 
-		bool compareString(const char* good, const char* str, uint8_t str_len) const;
+    bool compareString(const char* good, const char* str, uint8_t str_len) const;
-		std::vector<MqttClient*>	clients;
+    std::vector<MqttClient*>  clients;
-		TcpServer* server;
+    TcpServer* server;
 
-		const char* auth_user = "guest";
+    const char* auth_user = "guest";
-		const char* auth_password = "guest";
+    const char* auth_password = "guest";
-		State state = Disconnected;
+    State state = Disconnected;
 
-		MqttClient* broker = nullptr;
+    MqttClient* broker = nullptr;
 };

tests/Makefile

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

tests/debug-mode/Makefile

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

tests/debug-mode/debug-tests.ino

@@ -0,0 +1,15 @@
+#include <Arduino.h>
+#include <AUnit.h>
+#include <TinyMqtt.h>
+#include <map>
+#include <iostream>
+#include <iomanip>
+#include <sstream>
+#include <string>
+
+// Only compilation check, so do nothing
+
+void setup() {}
+void loop() {
+  aunit::TestRunner::run();
+}

tests/length-tests.todo/Makefile

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

tests/local-tests/local-tests.ino

@@ -4,148 +4,148 @@
 #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(local_client_should_unregister_when_destroyed)
 {
-	assertEqual(broker.clientsCount(), (size_t)0);
+  assertEqual(broker.clientsCount(), (size_t)0);
-	{
+  {
-		assertEqual(broker.clientsCount(), (size_t)0);	// Ensure client is not yet connected
+    assertEqual(broker.clientsCount(), (size_t)0);  // Ensure client is not yet connected
-		MqttClient client(&broker);
+    MqttClient client(&broker);
-		assertEqual(broker.clientsCount(), (size_t)1);	// Ensure client is now connected
+    assertEqual(broker.clientsCount(), (size_t)1);  // Ensure client is now connected
-	}
+  }
-	assertEqual(broker.clientsCount(), (size_t)0);
+  assertEqual(broker.clientsCount(), (size_t)0);
 }
 
 #if 0
 test(local_connect)
 {
-	assertEqual(broker.clientsCount(), (size_t)0);
+  assertEqual(broker.clientsCount(), (size_t)0);
 
-	MqttClient client;
+  MqttClient client;
-	assertTrue(client.connected());
+  assertTrue(client.connected());
-	assertEqual(broker.clientsCount(), (size_t)1);
+  assertEqual(broker.clientsCount(), (size_t)1);
 }
 
 test(local_publish_should_be_dispatched)
 {
-	published.clear();
+  published.clear();
-	assertEqual(broker.clientsCount(), (size_t)0);
+  assertEqual(broker.clientsCount(), (size_t)0);
 
-	MqttClient subscriber;
+  MqttClient subscriber;
-	subscriber.subscribe("a/b");
+  subscriber.subscribe("a/b");
-	subscriber.subscribe("a/c");
+  subscriber.subscribe("a/c");
-	subscriber.setCallback(onPublish);
+  subscriber.setCallback(onPublish);
 
-	MqttClient publisher;
+  MqttClient publisher;
-	publisher.publish("a/b");
+  publisher.publish("a/b");
-	publisher.publish("a/c");
+  publisher.publish("a/c");
-	publisher.publish("a/c");
+  publisher.publish("a/c");
 
-	assertEqual(published.size(), (size_t)1);	// 1 client has received something
+  assertEqual(published.size(), (size_t)1);  // 1 client has received something
-	assertEqual(published[""]["a/b"], 1);
+  assertEqual(published[""]["a/b"], 1);
-	assertEqual(published[""]["a/c"], 2);
+  assertEqual(published[""]["a/c"], 2);
 }
 
 test(local_publish_should_be_dispatched_to_local_clients)
 {
-	published.clear();
+  published.clear();
-	assertEqual(broker.clientsCount(), (size_t)0);
+  assertEqual(broker.clientsCount(), (size_t)0);
 
-	MqttClient subscriber_a("A");
+  MqttClient subscriber_a("A");
-	subscriber_a.setCallback(onPublish);
+  subscriber_a.setCallback(onPublish);
-	subscriber_a.subscribe("a/b");
+  subscriber_a.subscribe("a/b");
-	subscriber_a.subscribe("a/c");
+  subscriber_a.subscribe("a/c");
 
-	MqttClient subscriber_b("B");
+  MqttClient subscriber_b("B");
-	subscriber_b.setCallback(onPublish);
+  subscriber_b.setCallback(onPublish);
-	subscriber_b.subscribe("a/b");
+  subscriber_b.subscribe("a/b");
 
-	MqttClient publisher;
+  MqttClient publisher;
-	publisher.publish("a/b");
+  publisher.publish("a/b");
-	publisher.publish("a/c");
+  publisher.publish("a/c");
 
-	assertEqual(published.size(), (size_t)2);	// 2 clients have received something
+  assertEqual(published.size(), (size_t)2);  // 2 clients have received something
-	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(local_unsubscribe)
 {
-	published.clear();
+  published.clear();
-	assertEqual(broker.clientsCount(), (size_t)0);
+  assertEqual(broker.clientsCount(), (size_t)0);
 
-	MqttClient subscriber;
+  MqttClient subscriber;
-	subscriber.setCallback(onPublish);
+  subscriber.setCallback(onPublish);
-	subscriber.subscribe("a/b");
+  subscriber.subscribe("a/b");
 
-	MqttClient publisher;
+  MqttClient publisher;
-	publisher.publish("a/b");
+  publisher.publish("a/b");
 
-	subscriber.unsubscribe("a/b");
+  subscriber.unsubscribe("a/b");
 
-	publisher.publish("a/b");
+  publisher.publish("a/b");
-	publisher.publish("a/b");
+  publisher.publish("a/b");
 
-	assertEqual(published[""]["a/b"], 1);	// Only one publish has been received
+  assertEqual(published[""]["a/b"], 1);  // Only one publish has been received
 }
 
 test(local_nocallback_when_destroyed)
 {
-	published.clear();
+  published.clear();
-	assertEqual(broker.clientsCount(), (size_t)0);
+  assertEqual(broker.clientsCount(), (size_t)0);
 
-	MqttClient publisher;
+  MqttClient publisher;
-	{
+  {
-		MqttClient subscriber;
+    MqttClient subscriber;
-		subscriber.setCallback(onPublish);
+    subscriber.setCallback(onPublish);
-		subscriber.subscribe("a/b");
+    subscriber.subscribe("a/b");
-		publisher.publish("a/b");
+    publisher.publish("a/b");
-	}
+  }
 
-	publisher.publish("a/b");
+  publisher.publish("a/b");
 
-	assertEqual(published.size(), (size_t)1);	// Only one publish has been received
+  assertEqual(published.size(), (size_t)1);  // Only one publish has been received
 }
 #endif
 
 //----------------------------------------------------------------------------
 // setup() and loop()
 void setup() {
-	delay(1000);
+  delay(1000);
-	Serial.begin(115200);
+  Serial.begin(115200);
-	while(!Serial);
+  while(!Serial);
 
-	Serial.println("=============[ LOCAL TinyMqtt TESTS              ]========================");
+  Serial.println("=============[ LOCAL TinyMqtt TESTS              ]========================");
 }
 
 void loop() {
-	aunit::TestRunner::run();
+  aunit::TestRunner::run();
 
-	if (Serial.available()) ESP.reset();
+  if (Serial.available()) ESP.reset();
 }

tests/network-tests/network-tests.ino

@@ -2,6 +2,10 @@
 #include <AUnit.h>
 #include <TinyMqtt.h>
 #include <map>
+#include <iostream>
+#include <iomanip>
+#include <sstream>
+#include <string>
 
 /**
   * TinyMqtt network unit tests.
@@ -10,7 +14,60 @@
   * Checks with a local broker. Clients must connect to the local broker
 	**/
 
-using namespace std;
+// 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)
 {
@@ -299,7 +356,7 @@ test(network_hudge_payload)
 
   MqttClient subscriber(&broker);
   subscriber.setCallback(onPublish);
-  subscriber.subscribe("a/b");
+  subscriber.subscribe("a/b");          // Note -> this does not send any byte .... (nowhere to send)
 
 	MqttClient publisher(&broker);
 	publisher.publish("a/b", payload);		// This publish is received
@@ -310,6 +367,47 @@ test(network_hudge_payload)
 	assertEqual(strcmp(payload, lastPayload), 0);
 }
 
+test(connack)
+{
+  const bool view = false;
+
+  NetworkObserver check(
+    [this](const WiFiClient*, const uint8_t* buffer, size_t length)
+    {
+      if (view) dumpMqttMessage(buffer, length);
+      if (buffer[0] == MqttMessage::ConnAck)
+      {
+        std::string hex = bufferToHexa(buffer, length);
+        assertStringCaseEqual(hex.c_str(), "20020000");
+      }
+    }
+  );
+
+  start_servers(2, true);
+  assertEqual(WiFi.status(), WL_CONNECTED);
+
+  MqttBroker broker(1883);
+  broker.begin();
+  IPAddress broker_ip = WiFi.localIP();
+
+  ESP8266WiFiClass::selectInstance(2);
+  MqttClient client;
+  client.connect(broker_ip.toString().c_str(), 1883);
+  broker.loop();
+
+  assertTrue(broker.clientsCount() == 1);
+  assertTrue(client.connected());
+
+  MqttClient::counters[MqttMessage::Type::SubAck] = 0;
+  client.subscribe("a/b");
+
+  // TODO how to avoid these loops ???
+  broker.loop();
+  client.loop();
+
+  assertEqual(MqttClient::counters[MqttMessage::Type::SubAck], 1);
+}
+
 //----------------------------------------------------------------------------
 // setup() and loop()
 void setup() {

tests/nowifi-tests/nowifi-tests.ino

@@ -93,6 +93,104 @@ test(nowifi_publish_should_be_dispatched_to_clients)
 	assertEqual(published["B"]["a/c"], 0);
 }
 
+test(nowifi_subscribe_with_star_wildcard)
+{
+	published.clear();
+	assertEqual(broker.clientsCount(), (size_t)0);
+
+	MqttClient subscriber(&broker, "A");
+	subscriber.setCallback(onPublish);
+	subscriber.subscribe("house/*/temp");
+
+	MqttClient publisher(&broker);
+	publisher.publish("house/bedroom/temp");
+	publisher.publish("house/kitchen/temp");
+	publisher.publish("house/living_room/tv/temp");
+	publisher.publish("building/location1/bedroom/temp");
+
+	assertEqual(published["A"]["house/bedroom/temp"], 1);
+	assertEqual(published["A"]["house/kitchen/temp"], 1);
+	assertEqual(published["A"]["house/living_room/tv/temp"], 1);
+	assertEqual(published["A"]["building/location1/bedroom/temp"], 0);
+}
+
+test(nowifi_subscribe_with_plus_wildcard)
+{
+	published.clear();
+	assertEqual(broker.clientsCount(), (size_t)0);
+
+	MqttClient subscriber(&broker, "A");
+	subscriber.setCallback(onPublish);
+	subscriber.subscribe("house/+/temp");
+
+	MqttClient publisher(&broker);
+	publisher.publish("house/bedroom/temp");
+	publisher.publish("house/kitchen/temp");
+	publisher.publish("house/living_room/tv/temp");
+	publisher.publish("building/location1/bedroom/temp");
+
+	assertEqual(published["A"]["house/bedroom/temp"], 1);
+	assertEqual(published["A"]["house/kitchen/temp"], 1);
+	assertEqual(published["A"]["house/living_room/tv/temp"], 0);
+	assertEqual(published["A"]["building/location1/bedroom/temp"], 0);
+}
+
+test(nowifi_should_not_receive_sys_msg)
+{
+	published.clear();
+	assertEqual(broker.clientsCount(), (size_t)0);
+
+	MqttClient subscriber(&broker, "A");
+	subscriber.setCallback(onPublish);
+	subscriber.subscribe("+/data");
+
+	MqttClient publisher(&broker);
+	publisher.publish("$SYS/data");
+
+	assertEqual(published["A"]["$SYS/data"], 0);
+}
+
+test(nowifi_subscribe_with_mixed_wildcards)
+{
+	published.clear();
+	assertEqual(broker.clientsCount(), (size_t)0);
+
+	MqttClient subscriber(&broker, "A");
+	subscriber.setCallback(onPublish);
+	subscriber.subscribe("+/data/#");
+
+	MqttClient publisher(&broker);
+	publisher.publish("node1/data/update");
+	publisher.publish("node2/data/delta");
+	publisher.publish("node3/data");
+
+	assertEqual(published["A"]["node1/data/update"], 1);
+	assertEqual(published["A"]["node2/data/delta"], 1);
+	assertEqual(published["A"]["node3/data"], 1);
+}
+
+test(nowifi_unsubscribe_with_wildcards)
+{
+	published.clear();
+	assertEqual(broker.clientsCount(), (size_t)0);
+
+	MqttClient subscriber(&broker, "A");
+	subscriber.setCallback(onPublish);
+	subscriber.subscribe("one/two/+");
+	subscriber.subscribe("one/two/three");
+
+	MqttClient publisher(&broker);
+	publisher.publish("one/two/three");
+	publisher.publish("one/two/four");
+
+	subscriber.unsubscribe("one/two/+");
+	publisher.publish("one/two/five");
+
+	assertEqual(published["A"]["one/two/three"], 1);
+	assertEqual(published["A"]["one/two/four"], 1);
+	assertEqual(published["A"]["one/two/five"], 0);
+}
+
 test(nowifi_unsubscribe)
 {
 	published.clear();

tests/string-indexer-tests/Makefile

@@ -1,6 +1,8 @@
 # See https://github.com/bxparks/EpoxyDuino for documentation about this
 # Makefile to compile and run Arduino programs natively on Linux or MacOS.
 
+EXTRA_CXXFLAGS=-g3 -O0
+
 APP_NAME := string-indexer-tests
 ARDUINO_LIBS := AUnit AceCommon AceTime TinyMqtt EspMock ESP8266WiFi  ESPAsync
 ARDUINO_LIB_DIRS := ../../../EspMock/libraries

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

@@ -62,6 +62,14 @@ test(indexer_same_strings_should_equal)
 	assertTrue(one == two);
 }
 
+test(indexer_compare_strings_with_same_beginning)
+{
+  IndexedString two("one_two");
+  IndexedString one("one");
+
+  assertNotEqual(one.getIndex(), two.getIndex());
+}
+
 test(indexer_indexed_operator_eq)
 {
 	IndexedString one("one");

tests/topic-tests/Makefile

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

tests/topic-tests/topic-tests.ino

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