Fix of decode length

Version 0.7.6
Fix message length error
2021-08-09 10:37:46 +02:00 · 2021-08-09 03:04:21 +02:00 · 2021-08-09 03:00:28 +02:00 · 2021-08-09 02:33:01 +02:00 · 2021-05-13 03:21:03 +02:00 · 2021-05-13 03:21:03 +02:00
26 changed files with 1503 additions and 547 deletions
--- a/.github/workflows/aunit.yml
+++ b/.github/workflows/aunit.yml
@@ -21,7 +21,14 @@ jobs:
        git clone https://github.com/bxparks/AceRoutine
        git clone https://github.com/bxparks/AUnit
        git clone https://github.com/bxparks/AceCommon
+        git clone https://github.com/hsaturn/EspMock
    - name: Verify tests
      run: |
-        make -C tests
+        # Run tests for ESP8266
+        make -C tests ESP_LIBS="ESP8266WiFi ESPAsyncTCP" tests
        make -C tests runtests
+        make -C tests clean
+        # Run tests for ESP32
+        #make -C tests ESP_LIBS="ESP8266WiFi ESPAsyncTCP" tests
+        #make -C tests runtests
+        #make -C tests clean
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -0,0 +1,18 @@
+name: "CI"
+on:
+  
+jobs:
+  ci:
+    runs-on: ubuntu-20.04
+    steps:
+    - name: Checkout this repository
+      uses: actions/checkout@v2.3.4
+    - name: Cache for arduino-ci
+      uses: actions/cache@v2.1.3
+      with:
+        path: |
+          ~/.arduino15
+        key: ${{ runner.os }}-arduino
+    - name: Install nix
+      uses: cachix/install-nix-action@v12
+    - run: nix-shell -I nixpkgs=channel:nixpkgs-unstable -p arduino-ci --run "arduino-ci"
--- a/.gitignore
+++ b/.gitignore
@@ -1,2 +0,0 @@
-*~
-src/my_credentials.h
--- a/README.md
+++ b/README.md
@@ -1,17 +1,19 @@
 # TinyMqtt

-![Release](https://img.shields.io/github/v/release/hsaturn/TinyMqtt)
-![Issues](https://img.shields.io/github/issues/hsaturn/TinyMqtt)
-![Esp8266](https://img.shields.io/badge/platform-ESP8266-green)
-![Gpl 3.0](https://img.shields.io/github/license/hsaturn/TinyMqtt)
-![Mqtt 3.1.1](https://img.shields.io/badge/Mqtt-%203.1.1-yellow)
+[![Release](https://img.shields.io/github/v/release/hsaturn/TinyMqtt)](https://github.com/hsaturn/TinyMqtt/releases)
+[![AUnit Tests](https://github.com/hsaturn/TinyMqtt/actions/workflows/aunit.yml/badge.svg)](https://github.com/hsaturn/TinyMqtt/actions/workflows/aunit.yml)
+[![Issues](https://img.shields.io/github/issues/hsaturn/TinyMqtt)](https://github.com/hsaturn/TinyMqtt/issues)
+[![Esp8266](https://img.shields.io/badge/platform-ESP8266-green)](https://www.espressif.com/en/products/socs/esp8266)
+[![Esp32](https://img.shields.io/badge/platform-ESP32-green)](https://www.espressif.com/en/products/socs/esp32)
+[![Gpl 3.0](https://img.shields.io/github/license/hsaturn/TinyMqtt)](https://www.gnu.org/licenses/gpl-3.0.fr.html)
+[![Mqtt 3.1.1](https://img.shields.io/badge/Mqtt-%203.1.1-yellow)](https://docs.oasis-open.org/mqtt/mqtt/v3.1.1/errata01/os/mqtt-v3.1.1-errata01-os-complete.html#_Toc442180822)

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

 ## Features

 - Very (very !!) fast broker I saw it re-sent 1000 topics per second for two
-  clients that had subscribed (payload ~15 bytes). No topic lost.
+  clients that had subscribed (payload ~15 bytes ESP8266). No topic lost.
  The max I've seen was 2k msg/s (1 client 1 subscription)
 - Act as as a mqtt broker and/or a mqtt client
 - Mqtt 3.1.1 / Qos 0 supported
@@ -21,32 +23,16 @@ ESP 8266 is a small, fast and capable Mqtt Broker and Client
 - zeroconf, this is a strange but very powerful mode where
  all brokers tries to connect together on the same local network.

-## TODO List
-* Use [Async library](https://github.com/me-no-dev/ESPAsyncTCP)
-* Implement zeroconf mode (needs async)
-* Add a max_clients in MqttBroker. Used with zeroconf, there will be
-no need for having tons of clients (also RAM is the problem with many clients)
-* Why not a 'global' TinyMqtt::loop() instead of having to call loop for all broker/clients instances
-* Test what is the real max number of clients for broker. As far as I saw, 1k is needed per client which would make more than 30 clients critical.
-* ~~MqttMessage uses a buffer 256 bytes which is usually far than needed.~~
-* ~~MqttClient does not support more than one subscription at time~~
-* ~~MqttClient auto re-subscribe (::resubscribe works bad on broker.emqx.io)~~
-* MqttClient auto reconnection
-* ~~MqttClient unsubscribe~~
-* MqttClient does not sent payload to callback...
-* MqttClient user/password
-* Wildcards (I may implement only # as I'm not interrested by a clever and cpu consuming matching)
-
 ## Quickstart

 * install [TinyMqtt library](https://github.com/hsaturn/TinyMqtt)
+  (you can use the Arduino library manager and search for TinyMqtt)
 * modify <libraries/TinyMqtt/src/my_credentials.h> (wifi setup)

 ## Examples

-
 | Example             | Description                                |
-| ---------------------------- | --------------------------------- |
+| ------------------- | ------------------------------------------ |
 | client-without-wifi | standalone example                         |
 | simple-client       | Connect the ESP to an external Mqtt broker |
 | simple-broker       | Simple Mqtt broker with your ESP           |
@@ -57,11 +43,25 @@ no need for having tons of clients (also RAM is the problem with many clients)

 ## Standalone mode (zeroconf)
 -> The zeroconf mode is not yet implemented
-zerofonf clients to connect to broker on local network.
+zeroconf clients to connect to broker on local network.

 In Zeroconf mode, each ESP is a a broker and scans the local network.
 After a while one ESP naturally becomes a 'master' and all ESP are connected together.
 No problem if the master dies, a new master will be choosen soon.

+## TODO List
+* ~~Use [Async library](https://github.com/me-no-dev/ESPAsyncTCP)~~
+* Implement zeroconf mode (needs async)
+* Add a max_clients in MqttBroker. Used with zeroconf, there will be
+no need for having tons of clients (also RAM is the problem with many clients)
+* Why not a 'global' TinyMqtt::loop() instead of having to call loop for all broker/clients instances
+* Test what is the real max number of clients for broker. As far as I saw, 1k is needed per client which would make more than 30 clients critical.
+* ~~MqttClient auto re-subscribe (::resubscribe works bad on broker.emqx.io)~~
+* MqttClient auto reconnection
+* MqttClient user/password
+* Wildcards (I may implement only # as I'm not interrested by a clever and cpu consuming matching)
+* I suspect that MqttClient::parent could be removed and replaced with a simple boolean
+  (this'll need to rewrite a few functions)
+
 ## License
 Gnu GPL 3.0, see [LICENSE](https://github.com/hsaturn/TinyMqtt/blob/main/LICENSE).
--- a/examples/client-with-wifi/client-with-wifi.ino
+++ b/examples/client-with-wifi/client-with-wifi.ino
@@ -3,23 +3,36 @@
 /** 
  * Local broker that accept connections and two local clients
  *
+  * 
+  *  +-----------------------------+
+  *  | ESP                         |
+  *  |                 +--------+  | 1883 <--- External client/s
+  *  |       +-------->| broker |  | 1883 <--- External client/s
+  *  |       |         +--------+  |
+  *  |       |             ^       |
+  *  |       |             |       |
+  *  |       |             |       |     -----
+  *  |       v             v       |      ---  
+  *  | +----------+  +----------+  |       -  
+  *  | | internal |  | internal |  +-------*  Wifi
+  *  | | client   |  | client   |  |          
+  *  | +----------+  +----------+  |          
+  *  |                             |
+  *  +-----------------------------+
+  * 
  * pros - Reduces internal latency (when publish is received by the same ESP)
  *      - Reduces wifi traffic
  *      - No need to have an external broker
-	*      - can still report to a 'main' broker (TODO see documentation that have to be written)
-	*      - accepts external clients
+  *      - can still report to a 'main' broker (TODO see documentation that have to be written)
+  *      - accepts external clients
  *
  * cons - Takes more memory
-	*      - a bit hard to understand
-	*
-  * This sounds crazy: a mqtt mqtt that do not need a broker !
-  *  The use case arise when one ESP wants to publish topics and subscribe to them at the same time.
-  *  Without broker, the ESP won't react to its own topics.
+  *      - a bit hard to understand
  *
-  *  TinyMqtt mqtt allows this use case to work.
  */

-#include <my_credentials.h>
+const char *ssid     = "";
+const char *password = "";

 std::string topic="sensor/temperature";

@@ -28,17 +41,20 @@ MqttBroker broker(1883);
 MqttClient mqtt_a(&broker);
 MqttClient mqtt_b(&broker);

-void onPublishA(const MqttClient* source, const Topic& topic, const char* payload, size_t length)
-{ Serial << endl << "---------> A Received " << topic.c_str() << endl; }
+void onPublishA(const MqttClient* /* source */, const Topic& topic, const char* payload, size_t /* length */)
+{ Serial << "--> client A received " << topic.c_str() << ", " << payload << endl; }

-void onPublishB(const MqttClient* source, const Topic& topic, const char* payload, size_t length)
-{ Serial << endl << "---------> B Received " << topic.c_str() << endl; }
+void onPublishB(const MqttClient* /* source */, const Topic& topic, const char* payload, size_t /* length */)
+{ Serial << "--> client B Received " << topic.c_str() << ", " << payload << endl; }

 void setup()
 {
  Serial.begin(115200);
-	delay(500);
-	Serial << "Clients with wifi " << endl;
+  delay(500);
+  Serial << "Clients with wifi " << endl;
+
+	if (strlen(ssid)==0)
+		Serial << "****** PLEASE EDIT THE EXAMPLE AND MODIFY ssid/password *************" << endl;

  WiFi.mode(WIFI_STA);
  WiFi.begin(ssid, password);
@@ -47,7 +63,7 @@ void setup()

  Serial << "Connected to " << ssid << "IP address: " << WiFi.localIP() << endl;

-	broker.begin();
+  broker.begin();

  mqtt_a.setCallback(onPublishA);
  mqtt_a.subscribe(topic);
@@ -58,30 +74,31 @@ void setup()

 void loop()
 {
-	broker.loop();
+  broker.loop();  // Don't forget to add loop for every broker and clients

  mqtt_a.loop();
  mqtt_b.loop();

  // ============= client A publish ================
-	static const int intervalA = 5000;  // publishes every 5s
-	static uint32_t timerA = millis() + intervalA;
+  static const int intervalA = 5000;  // publishes every 5s (please avoid usage of delay())
+  static uint32_t timerA = millis() + intervalA;

-	if (millis() > timerA)
-	{
-		Serial << "A is publishing " << topic.c_str() << endl;
-		timerA += intervalA;
-		mqtt_a.publish(topic);
-	}
+  if (millis() > timerA)
+  {
+    Serial << "A is publishing " << topic.c_str() << endl;
+    timerA += intervalA;
+    mqtt_a.publish(topic, " sent by A");
+  }

  // ============= client B publish ================
-	static const int intervalB = 7000;	// will send topic each 7s
-	static uint32_t timerB = millis() + intervalB;
+  static const int intervalB = 7000;	// will send topic each 7s
+  static uint32_t timerB = millis() + intervalB;

-	if (millis() > timerB)
-	{
-		Serial << "B is publishing " << topic.c_str() << endl;
-		timerB += intervalB;
-		mqtt_b.publish(topic, std::string(String(15+millis()%10).c_str()));
-	}
+  if (millis() > timerB)
+  {
+		static int temperature;
+    Serial << "B is publishing " << topic.c_str() << endl;
+    timerB += intervalB;
+    mqtt_b.publish(topic, " sent by B: "+std::string(String(16+temperature++%6).c_str()));
+  }
 }
--- a/examples/client-without-wifi/client-without-wifi.ino
+++ b/examples/client-without-wifi/client-without-wifi.ino
@@ -1,12 +1,30 @@
 #include <TinyMqtt.h>   // https://github.com/hsaturn/TinyMqtt

 /** TinyMQTT allows a disconnected mode:
- * 
- *  In this example, local clients A and B are talking together, no need to be connected.
- *  A single ESP can use this to be able to comunicate with itself with the power
- *  of MQTT, and once connected still continue to work with others.
- *  
- */
+  * 
+  *  +-----------------------------+
+  *  | ESP                         |
+  *  |                 +--------+  |
+  *  |       +-------->| broker |  |
+  *  |       |         +--------+  |
+  *  |       |             ^       |
+  *  |       |             |       |
+  *  |       v             v       |
+  *  | +----------+  +----------+  |
+  *  | | internal |  | internal |  |
+  *  | | client   |  | client   |  |          
+  *  | +----------+  +----------+  |          
+  *  |                             |
+  *  +-----------------------------+
+  *
+  *  In this example, local clients A and B are talking together, no need to be connected.
+  *
+  *  A single ESP can use this to be able to comunicate with itself with the power
+  *  of MQTT, and once connected still continue to work with others.
+  *
+  *  The broker may still be conected if wifi is on.
+  *
+  */

 std::string topic="sensor/temperature";

@@ -14,11 +32,11 @@ MqttBroker broker(1883);
 MqttClient mqtt_a(&broker);
 MqttClient mqtt_b(&broker);

-void onPublishA(const MqttClient* srce, const Topic& topic, const char* payload, size_t length)
-{ Serial << "--> A Received " << topic.c_str() << endl; }
+void onPublishA(const MqttClient* /* srce */, const Topic& topic, const char* payload, size_t /* length */)
+{ Serial << "--> Client A received msg on topic " << topic.c_str() << ", " << payload << endl; }

-void onPublishB(const MqttClient* srce, const Topic& topic, const char* payload, size_t length)
-{ Serial << "--> B Received " << topic.c_str() << endl; }
+void onPublishB(const MqttClient* /* srce */, const Topic& topic, const char* payload, size_t /* length */)
+{ Serial << "--> Client B received msg on topic " << topic.c_str() << ", " << payload << endl; }

 void setup()
 {
@@ -35,7 +53,7 @@ void setup()

 void loop()
 {
-	broker.loop();
+	broker.loop();	// Don't forget to call loop() for all brokers and clients
  mqtt_a.loop();
  mqtt_b.loop();

@@ -47,7 +65,7 @@ void loop()
 	{
 		Serial << "A is publishing " << topic.c_str() << endl;
 		timerA += intervalA;
-		mqtt_a.publish(topic);
+		mqtt_a.publish(topic, "sent by A");
 	}

  // ============= client B publish ================
@@ -58,6 +76,6 @@ void loop()
 	{
 		Serial << "B is publishing " << topic.c_str() << endl;
 		timerB += intervalB;
-		mqtt_b.publish(topic);
+		mqtt_b.publish(topic, "sent by B");
 	}
 }
--- a/examples/simple-broker/simple-broker.ino
+++ b/examples/simple-broker/simple-broker.ino
@@ -1,14 +1,33 @@
 #include "TinyMqtt.h"   // https://github.com/hsaturn/TinyMqtt

-#include <my_credentials.h>
-
 #define PORT 1883
 MqttBroker broker(PORT);

+/** Basic Mqtt Broker
+  *
+  *  +-----------------------------+
+  *  | ESP                         |
+  *  |       +--------+            | 
+  *  |       | broker |            | 1883 <--- External client/s
+  *  |       +--------+            |
+  *  |                             |
+  *  +-----------------------------+
+  *
+  *  Your ESP will become a MqttBroker.
+	*  You can test it with any client such as mqtt-spy for example
+	*  
+  */
+
+const char* ssid = "";
+const char* password = "";
+
 void setup() 
 {
  Serial.begin(115200);

+	if (strlen(ssid)==0)
+		Serial << "****** PLEASE MODIFY ssid/password *************" << endl;
+
  WiFi.mode(WIFI_STA);
  WiFi.begin(ssid, password);
 
--- a/examples/simple-client/simple-client.ino
+++ b/examples/simple-client/simple-client.ino
@@ -1,9 +1,25 @@
-#include <ESP8266WiFi.h>
 #include "TinyMqtt.h"   // https://github.com/hsaturn/TinyMqtt

-/** Simple Client
+/** Simple Client (The simplest configuration)
  *
-	* This is the simplest Mqtt client configuration
+  *                             
+  *                   +--------+       
+  *           +------>| broker |<--- <  Other client
+  *           |       +--------+       
+  *           |                               
+  *   +-----------------+
+  *   | ESP   |         |           
+  *   | +----------+    |          
+  *   | | internal |    |              
+  *   | | client   |    |          
+  *   | +----------+    |          
+  *   |                 |
+  *   +-----------------+
+  * 
+	* 1 - change the ssid/password
+	* 2 - change BROKER values (or keep emqx.io test broker)
+	* 3 - you can use mqtt-spy to connect to the same broker and
+	*     see the sensor/temperature updated by the client.
 	*
 	* pro  - small memory footprint (both ram and flash)
 	*      - very simple to setup and use
@@ -13,7 +29,11 @@
 	*      - local publishes takes more time (because they go outside)
 	*/

-#include <my_credentials.h>
+const char* BROKER = "broker.emqx.io";
+const uint16_t BROKER_PORT = 1883;
+
+const char* ssid = "";
+const char* password = "";

 static float temp=19;
 static MqttClient client;
@@ -22,7 +42,10 @@ void setup()
 {
  Serial.begin(115200);
 	delay(500);
+
 	Serial << "Simple clients with wifi " << endl;
+	if (strlen(ssid)==0)
+		Serial << "****** PLEASE MODIFY ssid/password *************" << endl;

  WiFi.mode(WIFI_STA);
  WiFi.begin(ssid, password);
@@ -32,21 +55,33 @@ void setup()

  Serial << "Connected to " << ssid << "IP address: " << WiFi.localIP() << endl;  

-	client.connect("192.168.1.40", 1883);	// Put here your broker ip / port
-
+	client.connect(BROKER, BROKER_PORT);	// Put here your broker ip / port
 }

 void loop()
 {
-	client.loop();
+	client.loop();	// Don't forget to call loop() for each broker and client

-	delay(1000);
+	// delay(1000);		please avoid usage of delay (see below how this done using next_send and millis())
+	static auto next_send = millis();
 	
-	auto rnd=random(100);
+	if (millis() > next_send)
+	{
+		next_send += 1000;

-	if (rnd > 66) temp += 0.1;
-	else if (rnd < 33) temp -= 0.1;
+		if (not client.connected())
+		{
+			Serial << millis() << ": Not connected to broker" << endl;
+			return;
+		}

-	client.publish("sensor/temperature", String(temp));
+		auto rnd=random(100);

+		if (rnd > 66) temp += 0.1;
+		else if (rnd < 33) temp -= 0.1;
+
+		Serial << "--> Publishing a new sensor/temperature value: " << temp << endl;
+
+		client.publish("sensor/temperature", String(temp));
+	}
 }
--- a/examples/tinymqtt-test/tinymqtt-test.ino
+++ b/examples/tinymqtt-test/tinymqtt-test.ino
@@ -1,24 +1,32 @@
-#define TINY_MQTT_DEBUG
 #include <TinyMqtt.h>       // https://github.com/hsaturn/TinyMqtt
 #include <MqttStreaming.h>
+#if defined(ESP8266)
+  #include <ESP8266mDNS.h>
+#elif defined(ESP32)
+  #include <WiFi.h>
+  #include <ESPmDNS.h>
+#else
+  #error Unsupported platform
+#endif
+
 #include <sstream>
 #include <map>

-/** 
-  * Console allowing to make any kind of test.
+bool echo_on = true;
+
+/** Very complex example
+  * Console allowing to make any kind of test,
+	* even some stress tests.
  *
-  * 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
-  *
-  * cons - Takes more memory
-	*      - a bit hard to understand
+	* Upload the sketch, the use the terminal.
+	* Press H for mini help.
 	*
+  * tested with mqtt-spy-0.5.4
+	* TODO examples of scripts
  */

-#include <my_credentials.h>
+const char* ssid = "";
+const char* password = "";

 std::string topic="sensor/temperature";

@@ -40,46 +48,110 @@ std::map<std::string, MqttBroker*> brokers;

 void setup()
 {
+	WiFi.persistent(false); // https://github.com/esp8266/Arduino/issues/1054
  Serial.begin(115200);
 	delay(500);
-	Serial << endl << endl << endl
-	<< "Connecting to '" << ssid << "' ";

+  Serial << endl << endl;
+  Serial << "***************************************************************" << endl;
+  Serial << "*  Welcome to the TinyMqtt console" << endl;
+  Serial << endl;
+  Serial << "*  The console allows to test all features of the libraries." << endl;
+  Serial << endl;
+  if (strlen(ssid)==0)
+    Serial << "*  WARNING: You may want to modify ssid/password in order" << endl
+		       << "            to reflect your Wifi configuration." << endl;
+  Serial << endl;
+	Serial << "*  Enter help to view the list of commands." << endl;
+  Serial << "***************************************************************" << endl;
+  Serial << endl;
+
+	Serial << "Connecting to '" << ssid << "' ";
+
+  WiFi.mode(WIFI_STA);
+  WiFi.begin(ssid, password);
  WiFi.mode(WIFI_STA);
  WiFi.begin(ssid, password);

  while (WiFi.status() != WL_CONNECTED)
-	{ Serial << '-'; delay(500); }
+  { Serial << '-'; delay(500); }
+
+  Serial << endl << "Connected to " << ssid << "IP address: " << WiFi.localIP() << endl;
+
+  const char* name="tinytest";
+  Serial << "Starting MDNS, name= " << name;
+  if (!MDNS.begin(name))
+    Serial << "  error, not available." << endl;
+  else
+    Serial << " ok." << endl;

-  Serial << "Connected to " << ssid << "IP address: " << WiFi.localIP() << endl;
-	Serial << "Type help for more..." << endl;

 	MqttBroker* broker = new MqttBroker(1883);
 	broker->begin();
 	brokers["broker"] = broker;
 }

+std::string getword(std::string& str, const char* if_empty=nullptr, char sep=' ');
+
 int getint(std::string& str, const int if_empty=0)
 {
-	std::string sword;
-	while(str.length() && str[0]>='0' && str[0]<='9')
+	std::string str2=str;
+	std::string sword = getword(str);
+	if (sword[0] and isdigit(sword[0]))
 	{
-		sword += str[0]; str.erase(0,1);
+		int ret=atoi(sword.c_str());
+		while(isdigit(sword[0]) or sword[0]==' ') sword.erase(0,1);
+		if (sword.length()) str = sword+' '+str;
+	  return ret;
 	}
-	while(str[0]==' ') str.erase(0,1);
-	if (if_empty and sword.length()==0) return if_empty;
-	return atoi(sword.c_str());
+	str=str2;
+  return if_empty;
 }

-std::string getword(std::string& str, const char* if_empty=nullptr, char sep=' ')
+std::string getword(std::string& str, const char* if_empty/*=nullptr*/, char sep/*=' '*/)
 {
+	char quote=(str[0]=='"' or str[0]=='\'' ? str[0] : 0);
+	if (quote) str.erase(0,1);
 	std::string sword;
-	while(str.length() && str[0]!=sep)
+	while(str.length() and (str[0]!=sep or quote))
 	{
-		sword += str[0]; str.erase(0,1);
+		if (str[0]==quote)
+		{
+			str.erase(0,1);
+			break;
+		}
+		sword += str[0];
+		str.erase(0,1);
 	}
 	while(str[0]==sep) str.erase(0,1);
 	if (if_empty and sword.length()==0) return if_empty;
+	if (quote==false and sword.length()>=4 and sword.substr(0,3)=="rnd")
+	{
+		sword.erase(0,3);
+		if (sword[0]=='(')
+		{
+			int to = 100;
+			sword.erase(0,1);
+			int from=getint(sword);
+			if (sword[0]==',')
+			{
+				sword.erase(0,1);
+				to = getint(sword);
+				if (sword[0]!=')') Serial << "Missing ')'" << endl;
+			}
+			else
+			{
+				to=from;
+				from=0;
+			}
+			return String(random(from,to)).c_str();
+		}
+		else
+		{
+			Serial << "Missing '('" << endl;
+		}
+	}
+	while(str[0]==' ') str.erase(0,1);
 	return sword;
 }

@@ -107,7 +179,7 @@ std::string getip(std::string& str, const char* if_empty=nullptr, char sep=' ')
 			return addr;
 	}
 	IPAddress local=WiFi.localIP();
-	addr="";
+	addr.clear();
 	while(build.size()!=4)
 	{
 		std::stringstream b;
@@ -125,13 +197,13 @@ std::string getip(std::string& str, const char* if_empty=nullptr, char sep=' ')
 std::map<std::string, std::string> vars;

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

-void getCommand(std::string& search)
+void convertToCommand(std::string& search)
 {
 	while(search[0]==' ') search.erase(0,1);
 	if (search.length()==0) return;
@@ -151,7 +223,7 @@ void getCommand(std::string& search)
 	else if (count>1)
 	{
 		Serial << "Ambiguous command: " << matches << endl;
-		search="";
+		search.clear();
 	}
 }

@@ -167,7 +239,7 @@ void replace(const char* d, std::string& str, std::string srch, std::string to)
 		{
 			str.erase(pos, srch.length());
 			str.insert(pos, to);
-			pos += to.length();
+			pos += to.length()-1;
 		}
 	}
 }
@@ -185,6 +257,7 @@ void replaceVars(std::string& cmd)
 	}
 	cmd.erase(0, cmd.find_first_not_of(" "));
 	cmd.erase(cmd.find_last_not_of(" ")+1);
+
 }

 // publish at regular interval
@@ -306,15 +379,482 @@ std::map<MqttClient*, automatic*> automatic::autos;

 bool compare(std::string s, const char* cmd)
 {
-	if (s.length()==0 or s.length()>strlen(cmd))  return false;
-	return strncmp(cmd, s.c_str(), s.length())==0;
+	uint8_t p=0;
+	while(s[p++]==*cmd++)
+	{
+		if (*cmd==0 or s[p]==0) return true;
+		if (s[p]==' ') return true;
+	}
+	return false;
 }

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

+struct Every
+{
+	std::string cmd;
+	uint32_t ms;
+	uint32_t next;
+	uint32_t underrun=0;
+	bool active=true;
+
+	void dump()
+	{
+		Serial << (active ? "enabled  " : "disabled ");
+		auto mill=millis();
+		Serial << ms << "ms [" << cmd << "] next in ";
+		if (mill > next)
+			Serial << "now";
+		else
+			Serial << next-mill << "ms";
+	}
+};
+
+uint32_t blink_ms_on[16];
+uint32_t blink_ms_off[16];
+uint32_t blink_next[16];
+bool blink_state[16];
+int16_t blink;
+
+std::vector<Every> everies;
+
+void eval(std::string& cmd)
+{
+	while(cmd.length())
+	{
+		MqttError retval = MqttOk;
+
+		std::string s;
+		MqttBroker* broker = nullptr;
+		MqttClient* client = nullptr;
+
+		// client.function notation
+		if (cmd.find('.') != std::string::npos &&
+				cmd.find('.') < cmd.find(' '))
+		{
+			s=getword(cmd, nullptr, '.');
+
+			if (s.length())
+			{
+				if (clients.find(s) != clients.end())
+				{
+					client = clients[s];
+				}
+				else if (brokers.find(s) != brokers.end())
+				{
+					broker = brokers[s];
+				}
+				else
+				{
+					Serial << "Unknown class (" << s.c_str() << ")" << endl;
+					cmd.clear();
+				}
+			}
+		}
+
+		s = getword(cmd);
+		if (s.length()) convertToCommand(s);
+		if (s.length()==0)
+		{}
+		else if (compare(s, "delete"))
+		{
+			if (client==nullptr && broker==nullptr)
+			{
+				s = getword(cmd);
+				if (clients.find(s) != clients.end())
+				{
+					client = clients[s];
+				}
+				else if (brokers.find(s) != brokers.end())
+				{
+					broker = brokers[s];
+				}
+				else
+					Serial << "Unable to find (" << s.c_str() << ")" << endl;
+			}
+			if (client)
+			{
+				for (auto it: clients)
+				{
+					if (it.second != client) continue;
+					Serial << "deleted" << endl;
+					delete (it.second);
+					clients.erase(it.first);
+					break;
+				}
+				cmd += " ls";
+			}
+			else if (broker)
+			{
+				for(auto it: brokers)
+				{
+					if (broker != it.second) continue;
+					Serial << "deleted" << endl;
+					delete (it.second);
+					brokers.erase(it.first);
+					break;
+				}
+				cmd += " ls";
+			}
+			else
+				Serial << "Nothing to delete" << endl;
+		}
+		else if (broker)
+		{
+			if (compare(s,"connect"))
+			{
+				Serial << "NYI" << endl;
+			}
+			else if (compare(s, "view"))
+			{
+				broker->dump();
+			}
+			else
+			{
+				Serial << "Unknown broker command (" << s << ")" << endl;
+				s.clear();
+			}
+		}
+		else if (client)
+		{
+			if (compare(s,"connect"))
+			{
+				client->connect(getip(cmd,"192.168.1.40").c_str(), getint(cmd, 1883), getint(cmd, 60));
+				Serial << (client->connected() ? "connected." : "not connected") << endl;
+			}
+			else if (compare(s,"publish"))
+			{
+				retval = client->publish(getword(cmd, topic.c_str()), getword(cmd));
+			}
+			else if (compare(s,"subscribe"))
+			{
+				client->subscribe(getword(cmd, topic.c_str()));
+			}
+			else if (compare(s, "unsubscribe"))
+			{
+				client->unsubscribe(getword(cmd, topic.c_str()));
+			}
+			else if (compare(s, "view"))
+			{
+				client->dump();
+			}
+			else
+			{
+				Serial << "Unknown client command (" << s << ")" << endl;
+				s.clear();
+			}
+		}
+		else if (compare(s, "on"))
+		{
+			uint8_t pin=getint(cmd, 2);
+			pinMode(pin, OUTPUT);
+			digitalWrite(pin, HIGH);
+		}
+		else if (compare(s, "off"))
+		{
+			uint8_t pin=getint(cmd, 2);
+			pinMode(pin, OUTPUT);
+			digitalWrite(pin, LOW);
+		}
+		else if (compare(s, "echo"))
+		{
+			s=getword(cmd);
+			if (s=="on")
+				echo_on = true;
+			else if (s=="off")
+				echo_on = false;
+			else
+			{
+				Serial << s << ' ';
+				while(cmd.length())
+				{
+					Serial << getword(cmd) << ' ';
+				}
+			}
+		}
+		else if (compare(s, "every"))
+		{
+			uint32_t ms = getint(cmd, 0);
+			if (ms)
+			{
+				if (cmd.length())
+				{
+					Every every;
+					every.ms=ms;
+					every.cmd=cmd;
+					every.next=millis()+ms;
+					everies.push_back(every);
+					every.dump();
+					Serial << endl;
+					cmd.clear();
+				}
+			}
+			else if (compare(cmd, "off") or compare(cmd, "on"))
+			{
+				bool active=getword(cmd)=="on";
+				uint8_t ever=getint(cmd, 100);
+				uint8_t count=0;
+				for(auto& every: everies)
+				{
+					if (count==ever or (ever==100))
+					{
+						if (every.active != active)
+						{
+							Serial << "every #" << count << (active ? " on" :" off") << endl;
+							every.active = active;
+							every.underrun = 0;
+						}
+					}
+					count++;
+				}
+			}
+			else if (compare(cmd, "list") or cmd.length()==0)
+			{
+				getword(cmd);
+				Serial << "List of everies (ms=" << millis() << ")" << endl;
+				uint8_t count=0;
+				for(auto& every: everies)
+				{
+					Serial << count << ": ";
+					every.dump();
+					Serial << endl;
+					count++;
+				}
+			}
+			else if (compare(cmd, "remove"))
+			{
+				Serial << "Removing..." << endl;
+				getword(cmd);
+				int8_t every=getint(cmd, -1);
+				if (every==-1 and compare(cmd, "last") and everies.size())
+				{
+					getword(cmd);
+					everies.erase(everies.begin()+everies.size()-1);
+				}
+				else if (every==-1 and compare(cmd, "all"))
+				{
+					getword(cmd);
+					everies.clear();
+				}
+				else if (everies.size() > (uint8_t)every)
+				{
+					everies.erase(everies.begin()+every);
+				}
+				else
+					Serial << "Bad colmmand" << endl;
+			}
+			else
+				Serial << "Bad command" << endl;
+		}
+		else if (compare(s, "blink"))
+		{
+			int8_t blink_nr = getint(cmd, -1);
+			if (blink_nr >= 0)
+			{
+				blink_ms_on[blink_nr]=getint(cmd, blink_ms_on[blink_nr]);
+				blink_ms_off[blink_nr]=getint(cmd, blink_ms_on[blink_nr]);
+				pinMode(blink_nr, OUTPUT);
+				blink_next[blink_nr] = millis();
+				Serial << "Blink " << blink_nr << ' ' << (blink_ms_on[blink_nr] ? "on" : "off") << endl;
+				if (blink_ms_on[blink_nr])
+					blink |= 1<< blink_nr;
+				else
+				{
+					blink &= ~(1<< blink_nr);
+				}
+			}
+		}
+		else if (compare(s, "auto"))
+		{
+			automatic::command(client, cmd);
+			if (client == nullptr)
+				cmd.clear();
+		}
+		else if (compare(s, "broker"))
+		{
+			std::string id=getword(cmd);
+			if (id.length() or brokers.find(id)!=brokers.end())
+			{
+				int port=getint(cmd, 0);
+				if (port)
+				{
+					MqttBroker* broker = new MqttBroker(port);
+					broker->begin();
+
+					brokers[id] = broker;
+					Serial << "new broker (" << id.c_str() << ")" << endl;
+				}
+				else
+					Serial << "Missing port" << endl;
+			}
+			else
+				Serial << "Missing or existing broker name (" << id.c_str() << ")" << endl;
+			cmd+=" ls";
+		}
+		else if (compare(s, "client"))
+		{
+			std::string id=getword(cmd);
+			if (id.length() or clients.find(id)!=clients.end())
+			{
+				s=getword(cmd);	// broker name
+				if (s=="" or brokers.find(s) != brokers.end())
+				{
+					MqttBroker* broker = nullptr;
+					if (s.length()) broker = brokers[s];
+					MqttClient* client = new MqttClient(broker);
+					client->id(id);
+					clients[id]=client;
+					client->setCallback(onPublish);
+					client->subscribe(topic);
+					Serial << "new client (" << id.c_str() << ", " << s.c_str() << ')' << endl;
+				}
+				else if (s.length())
+				{
+					Serial << " not found." << endl;
+				}
+			}
+			else
+				Serial << "Missing or existing client name" << endl;
+			cmd+=" ls";
+		}
+		else if (compare(s, "set"))
+		{
+			std::string name(getword(cmd));
+			if (name.length()==0)
+			{
+				for(auto it: vars)
+				{
+					Serial << "  " << it.first << " -> " << it.second << endl;
+				}
+			}
+			else if (commands.find(name) != commands.end())
+			{
+				Serial << "Reserved keyword (" << name << ")" << endl;
+				cmd.clear();
+			}
+			else
+			{
+				if (cmd.length())
+				{
+					vars[name] = cmd;
+					cmd.clear();
+				}
+				else if (vars.find(name) != vars.end())
+					vars.erase(vars.find(name));
+			}
+		}
+		else if (compare(s, "ls") or compare(s, "view"))
+		{
+			Serial << "--< " << clients.size() << " client/s. >--" << endl;
+			for(auto it: clients)
+			{
+				it.second->dump("  ");
+			}
+
+			Serial << "--< " << brokers.size() << " brokers/s. >--" << endl;
+			for(auto it: brokers)
+			{
+				Serial << "  +-- '" << it.first.c_str() << "' " << it.second->clientsCount() << " client/s."<< endl;
+				it.second->dump("     ");
+			}
+		}
+		else if (compare(s, "reset"))
+			ESP.restart();
+		else if (compare(s, "ip"))
+			Serial << "IP: " << WiFi.localIP() << endl;
+		else if (compare(s,"help"))
+		{
+			Serial << "syntax:" << endl;
+			Serial << "  MqttBroker:" << endl;
+			Serial << "    broker {name} {port} : create a new broker" << endl;
+			Serial << endl;
+			Serial << "  MqttClient:" << endl;
+			Serial << "    client {name} {parent broker} : create a client then" << endl;
+			Serial << "      name.connect  [ip] [port] [alive]" << endl;
+			Serial << "      name.[un]subscribe [topic]" << endl;
+			Serial << "      name.publish [topic][payload]" << endl;
+			Serial << "      name.view" << endl;
+			Serial << "      name.delete" << endl;
+
+			automatic::help();
+			Serial << endl;
+			Serial << "    help" << endl;
+			Serial << "    blink [Dx on_ms off_ms]" << endl;
+			Serial << "    ls / ip / reset" << endl;
+			Serial << "    set [name][value]" << 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 << "  on {output}; off {output}" << endl;
+			Serial << "  $id : name of the client." << endl;
+			Serial << "  rnd[(min[,max])] random number." << endl;
+			Serial << "  default topic is '" << topic.c_str() << "'" << endl;
+			Serial << endl;
+		}
+		else
+		{
+			while(s[0]==' ') s.erase(0,1);
+			if (s.length())
+				Serial << "Unknown command (" << s.c_str() << ")" << endl;
+		}
+
+		if (retval != MqttOk)
+		{
+			Serial << "# MQTT ERROR " << retval << endl;
+		}
+	}
+}
+
 void loop()
 {
+	auto ms=millis();
+	int8_t out=0;
+	int16_t blink_bits = blink;
+	uint8_t e=0;
+
+	for(auto& every: everies)
+	{
+		if (not every.active) continue;
+		if (every.ms && every.cmd.length() && ms > every.next)
+		{
+			std::string cmd(every.cmd);
+			eval(cmd);
+			every.next += every.ms;
+			if (ms > every.next and ms > every.underrun)
+			{
+				Serial << "Underrun every #" << e << ", " <<  (ms - every.next) << "ms late" << endl;
+				every.underrun = ms+5000;
+			}
+		}
+		e++;
+	}
+
+	while(blink_bits)
+	{
+		if (blink_ms_on[out] and ms > blink_next[out])
+		{
+			if (blink_state[out])
+			{
+				blink_next[out] += blink_ms_on[out];
+				digitalWrite(out, LOW);
+			}
+			else
+			{
+				blink_next[out] += blink_ms_off[out];
+				digitalWrite(abs(out), HIGH);
+			}
+			blink_state[out] = not blink_state[out];
+		}
+		blink_bits >>=1;
+		out++;
+	}
+
 	static long count;
+  #if defined(ESP9266)
+  MDNS.update();
+  #endif
+
 	if (MqttClient::counter != count)
 	{
 		Serial << "# " << MqttClient::counter << endl;
@@ -332,10 +872,11 @@ void loop()
 	{
 		static std::string cmd;
 		char c=Serial.read();
+		if (echo_on)
+			Serial << c;

-		if (c==10 or c==14)
+		if (c==10 or c==13)
 		{
-
 			Serial << "----------------[ " << cmd.c_str() << " ]--------------" << endl;
 			static std::string last_cmd;
 			if (cmd=="!")
@@ -344,254 +885,7 @@ void loop()
 				last_cmd=cmd;

 			if (cmd.substr(0,3)!="set") replaceVars(cmd);
-			while(cmd.length())
-			{
-				MqttError retval = MqttOk;
-
-				std::string s;
-				MqttBroker* broker = nullptr;
-				MqttClient* client = nullptr;
-
-				// client.function notation
-				// ("a.fun " becomes "fun a ")
-				if (cmd.find('.') != std::string::npos && 
-						cmd.find('.') < cmd.find(' '))
-				{
-					s=getword(cmd, nullptr, '.');
-
-					if (s.length())
-					{
-						if (clients.find(s) != clients.end())
-						{
-							client = clients[s];
-						}
-						else if (brokers.find(s) != brokers.end())
-						{
-							broker = brokers[s];
-						}
-						else
-						{
-							Serial << "Unknown class (" << s.c_str() << ")" << endl;
-							cmd="";
-						}
-					}
-				}
-				
-				s = getword(cmd);
-				if (s.length()) getCommand(s);
-				if (s.length()==0)
-				{}
-				else if (compare(s, "delete"))
-				{
-					if (client==nullptr && broker==nullptr)
-					{
-						s = getword(cmd);
-						if (clients.find(s) != clients.end())
-						{
-							client = clients[s];
-						}
-						else if (brokers.find(s) != brokers.end())
-						{
-							broker = brokers[s];
-						}
-						else
-							Serial << "Unable to find (" << s.c_str() << ")" << endl;
-					}
-					if (client)
-					{
-						clients.erase(s);
-						for (auto it: clients)
-						{
-							if (it.second != client) continue;
-							Serial << "deleted" << endl;
-							clients.erase(it.first);
-							break;
-						}
-						cmd += " ls";
-					}
-					else if (broker)
-					{
-						for(auto it: brokers)
-						{
-							Serial << (int32_t)it.second << '/' << (int32_t)broker << endl;
-							if (broker != it.second) continue;
-							Serial << "deleted" << endl;
-							brokers.erase(it.first);
-							break;
-						}
-						cmd += " ls";
-					}
-					else
-						Serial << "Nothing to delete" << endl;
-				}
-				else if (broker)
-				{
-					if (compare(s,"connect"))
-				  {
-						Serial << "NYI" << endl;
-				  }
-					else if (compare(s, "view"))
-					{
-						broker->dump();
-					}
-			  }
-				else if (client)
-				{
-					if (compare(s,"connect"))
-					{
-						client->connect(getip(cmd,"192.168.1.40").c_str(), getint(cmd, 1883), getint(cmd, 60));
-						Serial << (client->connected() ? "connected." : "not connected") << endl;
-					}
-					else if (compare(s,"publish"))
-					{
-						while (cmd[0]==' ') cmd.erase(0,1);
-						retval = client->publish(getword(cmd, topic.c_str()), cmd.c_str(), cmd.length());
-						cmd="";	// remove payload
-					}
-					else if (compare(s,"subscribe"))
-					{
-						client->subscribe(getword(cmd, topic.c_str()));
-					}
-					else if (compare(s, "view"))
-					{
-						client->dump();
-					}
-				}
-				else if (compare(s, "auto"))
-				{
-					automatic::command(client, cmd);
-					if (client == nullptr)
-						cmd.clear();
-				}
-				else if (compare(s, "broker"))
-				{
-					std::string id=getword(cmd);
-					if (id.length() or brokers.find(id)!=brokers.end())
-					{
-						int port=getint(cmd, 0);
-						if (port)
-						{
-							MqttBroker* broker = new MqttBroker(port);
-							broker->begin();
-
-							brokers[id] = broker;
-							Serial << "new broker (" << id.c_str() << ")" << endl;
-						}
-						else
-							Serial << "Missing port" << endl;
-					}
-					else
-						Serial << "Missing or existing broker name (" << id.c_str() << ")" << endl;
-					cmd+=" ls";
-				}
-				else if (compare(s, "client"))
-				{
-					std::string id=getword(cmd);
-					if (id.length() or clients.find(id)!=clients.end())
-					{
-						s=getword(cmd);	// broker name
-						if (s=="" or brokers.find(s) != brokers.end())
-						{
-							MqttBroker* broker = nullptr;
-							if (s.length()) broker = brokers[s];
-							MqttClient* client = new MqttClient(broker);
-							client->id(id);
-							clients[id]=client;
-							client->setCallback(onPublish);
-							client->subscribe(topic);
-							Serial << "new client (" << id.c_str() << ", " << s.c_str() << ')' << endl;
-						}
-						else if (s.length())
-						{
-							Serial << " not found." << endl;
-						}
-					}
-					else
-						Serial << "Missing or existing client name" << endl;
-					cmd+=" ls";
-				}
-				else if (compare(s, "set"))
-				{
-					std::string name(getword(cmd));
-					if (name.length()==0)
-					{
-						for(auto it: vars)
-						{
-							Serial << "  " << it.first << " -> " << it.second << endl;
-						}
-					}
-					else if (commands.find(name) != commands.end())
-					{
-						Serial << "Reserved keyword (" << name << ")" << endl;
-						cmd.clear();
-					}
-					else
-					{
-						if (cmd.length())
-						{
-							vars[name] = cmd;
-							cmd.clear();
-						}
-						else if (vars.find(name) != vars.end())
-							vars.erase(vars.find(name));
-					}
-				}
-				else if (compare(s, "ls") or compare(s, "view"))
-				{
-					Serial << "--< " << clients.size() << " client/s. >--" << endl;
-					for(auto it: clients)
-					{
-						Serial << "  "; it.second->dump();
-					}
-
-					Serial << "--< " << brokers.size() << " brokers/s. >--" << endl;
-					for(auto it: brokers)
-					{
-						Serial << " ==[ Broker: " << it.first.c_str() << " ]== ";
-						it.second->dump();
-					}
-				}
-				else if (compare(s, "reset"))
-					ESP.restart();
-				else if (compare(s, "ip"))
-					Serial << "IP: " << WiFi.localIP() << endl;
-				else if (compare(s,"help"))
-				{
-					Serial << "syntax:" << endl;
-					Serial << "  MqttBroker:" << endl;
-					Serial << "    broker {name} {port} : create a new broker" << endl;
-					Serial << endl;
-					Serial << "  MqttClient:" << endl;
-					Serial << "    client {name} {parent broker} : create a client then" << endl;
-					Serial << "      name.connect  [ip] [port] [alive]" << endl;
-					Serial << "      name.subscribe [topic]" << endl;
-					Serial << "      name.publish [topic][payload]" << endl;
-					Serial << "      name.view" << endl;
-					Serial << "      name.delete" << endl;
-
-					automatic::help();
-					Serial << endl;
-					Serial << "    help" << endl;
-					Serial << "    ls / ip / reset" << endl;
-					Serial << "    set [name][value]" << endl;
-					Serial << "    !  repeat last command" << endl;
-					Serial << endl;
-					Serial << "  $id : name of the client." << endl;
-					Serial << "  default topic is '" << topic.c_str() << "'" << endl;
-					Serial << endl;
-				}
-				else
-				{
-					while(s[0]==' ') s.erase(0,1);
-					if (s.length())
-						Serial << "Unknown command (" << s.c_str() << ")" << endl;
-				}
-
-				if (retval != MqttOk)
-				{
-					Serial << "## ERROR " << retval << endl;
-				}
-			}
+			eval(cmd);
 		}
 		else
 		{
--- a/keywords.txt
+++ b/keywords.txt
@@ -9,13 +9,19 @@
 TinyMqtt    KEYWORD1

 MqttBroker  KEYWORD1
+connect		  KEYWORD2
+clientsCount KEYWORD2
 begin				KEYWORD2
 loop				KEYWORD2
+port				KEYWORD2

 MqttClient  KEYWORD1
+connect		  KEYWORD2
+connected	  KEYWORD2
 publish     KEYWORD2
 setCallback	KEYWORD2
 subscribe	  KEYWORD2
+unsubscribe	KEYWORD2

 Topic				KEYWORD1
 matches			KEYWORD2
--- a/library.json
+++ b/library.json
@@ -1,12 +1,12 @@
 {
    "name": "TinyMqtt",
    "keywords": "ethernet, mqtt, m2m, iot",
-    "description": "MQTT is a lightweight messaging protocol ideal for small devices. This library allows you to send and receive MQTT messages. It does support MQTT 3.1.1 without any QOS.",
+    "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.7.1",
+    "version": "0.7.7",
    "exclude": "",
    "examples": "examples/*/*.ino",
    "frameworks": "arduino",
--- a/library.properties
+++ b/library.properties
@@ -1,10 +1,11 @@
 name=TinyMqtt
-version=0.7.1
+version=0.7.7
 author=Francois BIOT, HSaturn, <hsaturn@gmail.com>
 maintainer=Francois BIOT, HSaturn, <hsaturn@gmail.com>
 sentence=A tiny broker and client library for MQTT messaging.
-paragraph=MQTT is a lightweight messaging protocol ideal for small devices. This library allows you to send and receive MQTT messages and to jhost a broker in your ESP. It does support MQTT 3.1.1 without any QOS.
+paragraph=MQTT is a lightweight messaging protocol ideal for small devices. This library allows to send and receive MQTT messages and to host a broker in your ESP 8266 and 32 WROOM. It does support MQTT 3.1.1 with QoS=0.
 category=Communication
 url=https://github.com/hsaturn/TinyMqtt
 architectures=*
 includes=TinyMqtt.h
+depends=AsyncTCP
--- a/src/StringIndexer.h
+++ b/src/StringIndexer.h
@@ -2,7 +2,6 @@
 #include <map>
 #include <string>
 #include <string.h>
-#include <ESP8266WiFi.h>

 /***
 * Allows to store up to 255 different strings with one byte class
@@ -15,11 +14,21 @@ class StringIndexer
 		std::string str;
 		uint8_t used=0;
 		friend class StringIndexer;
+
+		#if EPOXY_DUINO
+		public:
+		// Workaround to avoid coredump in Indexer::release
+		// when destroying a Topic after the deletion of
+		// StringIndexer::strings map (which can occurs only with AUnit,
+		// never in the ESP itself, because ESP never ends)
+		// (I hate static vars)
+		~StringCounter() { used=255; }
+		#endif
 	};
 	public:
 		using index_t=uint8_t;

-		static const index_t strToIndex(const char* str, uint8_t len)
+		static index_t strToIndex(const char* str, uint8_t len)
 		{
 			for(auto it=strings.begin(); it!=strings.end(); it++)
 			{
@@ -29,7 +38,7 @@ class StringIndexer
 					return it->first;
 				}
 			}
-			for(index_t index=0; index<255; index++)
+			for(index_t index=1; index; index++)
 			{
 				if (strings.find(index)==strings.end())
 				{
@@ -70,6 +79,8 @@ class StringIndexer
 			}
 		}

+		static uint16_t count() { return strings.size(); }
+
 	private:
 		static std::map<index_t, StringCounter> strings;
 };
@@ -88,6 +99,8 @@ class IndexedString
 			index=StringIndexer::strToIndex(str, len);
 		}

+		IndexedString(const std::string& str) : IndexedString(str.c_str(), str.length()) {};
+
 		~IndexedString() { StringIndexer::release(index); }

 		IndexedString& operator=(const IndexedString& source)
@@ -102,6 +115,11 @@ class IndexedString
 			return i1.index < i2.index;
 		}

+		friend bool operator==(const IndexedString& i1, const IndexedString& i2)
+		{
+			return i1.index == i2.index;
+		}
+
 		const std::string& str() const { return StringIndexer::str(index); }

 		const StringIndexer::index_t& getIndex() const { return index; }
--- a/src/TinyMqtt.cpp
+++ b/src/TinyMqtt.cpp
@@ -9,8 +9,12 @@ void outstring(const char* prefix, const char*p, uint16_t len)
 	Serial << '\'' << endl;
 }

-MqttBroker::MqttBroker(uint16_t port) : server(port)
+MqttBroker::MqttBroker(uint16_t port)
 {
+	server = new TcpServer(port);
+#ifdef TCP_ASYNC
+	server->onClient(onClient, this);
+#endif
 }

 MqttBroker::~MqttBroker()
@@ -19,18 +23,26 @@ MqttBroker::~MqttBroker()
 	{
 		delete clients[0];
 	}
+	delete server;
 }

 // private constructor used by broker only
-MqttClient::MqttClient(MqttBroker* parent, WiFiClient& new_client)
+MqttClient::MqttClient(MqttBroker* parent, TcpClient* new_client)
 	: parent(parent)
 {
-	client = new WiFiClient(new_client);
+#ifdef TCP_ASYNC
+	client = new_client;
+	client->onData(onData, this);
+	// client->onConnect() TODO
+	// client->onDisconnect() TODO
+#else
+	client = new WiFiClient(*new_client);
+#endif
 	alive = millis()+5000;	// client expires after 5s if no CONNECT msg
 }

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

@@ -67,29 +79,22 @@ void MqttClient::close(bool bSendDisconnect)
 void MqttClient::connect(std::string broker, uint16_t port, uint16_t ka)
 {
 	debug("cnx: closing");
+	keep_alive = ka;
 	close();
 	if (client) delete client;
-	client = new WiFiClient;
+	client = new TcpClient;
+
 	debug("Trying to connect to " << broker.c_str() << ':' << port);
+#ifdef TCP_ASYNC
+	client->onData(onData, this);
+	client->onConnect(onConnect, this);
+	client->connect(broker.c_str(), port);
+#else
 	if (client->connect(broker.c_str(), port))
 	{
-	  debug("cnx: connecting");
-		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
-
-		keep_alive = ka;
-		msg.add(0x00);			// keep_alive
-		msg.add((char)keep_alive);
-		msg.add(clientId);
-	  debug("cnx: mqtt connecting");
-		msg.sendTo(this);
-		msg.reset();
-	  debug("cnx: mqtt sent " << (int32_t)parent);
-
-		clientAlive(0);
+		onConnect(this, client);
 	}
+#endif
 }

 void MqttBroker::addClient(MqttClient* client)
@@ -97,6 +102,13 @@ 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;
+	broker->connect(host, port);
+	broker->parent = this;	// Because connect removed the link
+}
+
 void MqttBroker::removeClient(MqttClient* remove)
 {
  for(auto it=clients.begin(); it!=clients.end(); it++)
@@ -104,6 +116,11 @@ void MqttBroker::removeClient(MqttClient* remove)
 		auto client=*it;
 		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());
@@ -113,15 +130,31 @@ void MqttBroker::removeClient(MqttClient* remove)
 	debug("Error cannot remove client");	// TODO should not occur
 }

+void MqttBroker::onClient(void* broker_ptr, TcpClient* client)
+{
+	MqttBroker* broker = static_cast<MqttBroker*>(broker_ptr);
+
+	broker->addClient(new MqttClient(broker, client));
+	debug("New client");
+}
+
 void MqttBroker::loop()
 {
-  WiFiClient client = server.available();
+#ifndef TCP_ASYNC
+  WiFiClient client = server->available();

  if (client)
 	{
-		addClient(new MqttClient(this, client));
-		debug("New client (" << clients.size() << ')');
+		onClient(this, &client);
 	}
+#endif
+	if (broker)
+	{
+		// TODO should monitor broker's activity.
+		// 1 When broker disconnect and reconnect we have to re-subscribe
+		broker->loop();
+	}
+

  // for(auto it=clients.begin(); it!=clients.end(); it++)
 	// use index because size can change during the loop
@@ -134,7 +167,7 @@ void MqttBroker::loop()
 		}
 		else
 		{
-      debug("Client " << client->id().c_str() << "  Disconnected, parent=" << (int32_t)client->parent);
+      debug("Client " << client->id().c_str() << "  Disconnected, parent=" << (dbg_ptr)client->parent);
 			// Note: deleting a client not added by the broker itself will probably crash later.
 			delete client;
 			break;
@@ -142,7 +175,16 @@ void MqttBroker::loop()
 	}
 }

-MqttError MqttBroker::publish(const MqttClient* source, const Topic& topic, MqttMessage& msg)
+MqttError MqttBroker::subscribe(const Topic& topic, uint8_t qos)
+{
+	if (broker && broker->connected())
+	{
+		return broker->subscribe(topic, qos);
+	}
+	return MqttNowhereToSend;
+}
+
+MqttError MqttBroker::publish(const MqttClient* source, const Topic& topic, const MqttMessage& msg) const
 {
 	MqttError retval = MqttOk;

@@ -151,33 +193,32 @@ MqttError MqttBroker::publish(const MqttClient* source, const Topic& topic, Mqtt
 	for(auto client: clients)
 	{
 		i++;
-#if TINY_MQTT_DEBUG
+#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())	// Broker is connected
+		if (broker && broker->connected())	// this (MqttBroker) is connected (to a external broker)
 		{
-			//    ext broker -> clients or
-			// or clients -> ext broker
-			if (source == broker)	// broker -> clients
+			// ext_broker -> clients or clients -> ext_broker
+			if (source == broker)	// external broker -> internal clients
 				doit = true;
-			else									// clients -> broker
+			else									// external clients -> this broker
 			{
-				MqttError ret = broker->publish(topic, msg);
+				// 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: R7
+		else // Disconnected
 		{
-			// All is allowed
 			doit = true;
 		}
-#if TINY_MQTT_DEBUG
+#ifdef TINY_MQTT_DEBUG
 		Serial << ", doit=" << doit << ' ';
 #endif

-		if (doit) retval = client->publish(topic, msg);
+		if (doit) retval = client->publishIfSubscribed(topic, msg);
 		debug("");
 	}
 	return retval;
@@ -223,24 +264,64 @@ void MqttClient::loop()
 		{
 			debug("pingreq");
 			uint16_t pingreq = MqttMessage::Type::PingReq;
-			client->write((uint8_t*)(&pingreq), 2);
+			client->write((const char*)(&pingreq), 2);
 			clientAlive(0);

-			// TODO when many MqttClient passes through a local browser
+			// TODO when many MqttClient passes through a local broker
 			// there is no need to send one PingReq per instance.
 		}
 	}
-
+#ifndef TCP_ASYNC
 	while(client && client->available()>0)
 	{
 		message.incoming(client->read());
 		if (message.type())
 		{
-			processMessage();
+			processMessage(&message);
+			message.reset();
 		}
 	}
+#endif
 }

+void MqttClient::onConnect(void *mqttclient_ptr, TcpClient*)
+{
+	MqttClient* mqtt = static_cast<MqttClient*>(mqttclient_ptr);
+	debug("cnx: connecting");
+	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);
+	msg.add(mqtt->clientId);
+	debug("cnx: mqtt connecting");
+	msg.sendTo(mqtt);
+	msg.reset();
+	debug("cnx: mqtt sent " << (dbg_ptr)mqtt->parent);
+
+	mqtt->clientAlive(0);
+}
+
+#ifdef TCP_ASYNC
+void MqttClient::onData(void* client_ptr, TcpClient*, void* data, size_t len)
+{
+	char* char_ptr = static_cast<char*>(data);
+	MqttClient* client=static_cast<MqttClient*>(client_ptr);
+	while(len>0)
+	{
+		client->message.incoming(*char_ptr++);
+		if (client->message.type())
+		{
+			client->processMessage(&client->message);
+			client->message.reset();
+		}
+		len--;
+	}
+}
+#endif
+
 void MqttClient::resubscribe()
 {
 	// TODO resubscription limited to 256 bytes
@@ -272,6 +353,10 @@ MqttError MqttClient::subscribe(Topic topic, uint8_t qos)
 	{
 		return sendTopic(topic, MqttMessage::Type::Subscribe, qos);
 	}
+	else
+	{
+		return parent->subscribe(topic, qos);
+	}
 	return ret;
 }

@@ -306,22 +391,22 @@ MqttError MqttClient::sendTopic(const Topic& topic, MqttMessage::Type type, uint

 long MqttClient::counter=0;

-void MqttClient::processMessage()
+void MqttClient::processMessage(const MqttMessage* mesg)
 {
 	counter++;
-#if TINY_MQTT_DEBUG
-if (message.type() != MqttMessage::Type::PingReq && message.type() != MqttMessage::Type::PingResp)
+#ifdef TINY_MQTT_DEBUG
+if (mesg->type() != MqttMessage::Type::PingReq && mesg->type() != MqttMessage::Type::PingResp)
 {
-	Serial << "---> INCOMING " << _HEX(message.type()) << " client(" << (int)client << ':' << clientId << ") mem=" << ESP.getFreeHeap() << endl;
-	// message.hexdump("Incoming");
+	Serial << "---> INCOMING " << _HEX(mesg->type()) << " client(" << (dbg_ptr)client << ':' << clientId << ") mem=" << ESP.getFreeHeap() << endl;
+	// mesg->hexdump("Incoming");
 }
 #endif
-  auto header = message.getVHeader();
+  auto header = mesg->getVHeader();
  const char* payload;
  uint16_t len;
 	bool bclose=true;

-	switch(message.type() & 0XF0)
+	switch(mesg->type() & 0XF0)
 	{
 		case MqttMessage::Type::Connect:
 			if (mqtt_connected)
@@ -344,30 +429,30 @@ if (message.type() != MqttMessage::Type::PingReq && message.type() != MqttMessag
 			}

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

 			if (mqtt_flags & FlagWill)	// Will topic
 			{
-				message.getString(payload, len);	// Will Topic
+				mesg->getString(payload, len);	// Will Topic
 				outstring("WillTopic", payload, len);
 				payload += len;

-				message.getString(payload, len);	// Will Message
+				mesg->getString(payload, len);	// Will Message
 				outstring("WillMessage", payload, len);
 				payload += len;
 			}
 			// FIXME forgetting credential is allowed (security hole)
 			if (mqtt_flags & FlagUserName)
 			{
-				message.getString(payload, len);
+				mesg->getString(payload, len);
 				if (!parent->checkUser(payload, len)) break;
 				payload += len;
 			}
 			if (mqtt_flags & FlagPassword)
 			{
-				message.getString(payload, len);
+				mesg->getString(payload, len);
 				if (!parent->checkPassword(payload, len)) break;
 				payload += len;
 			}
@@ -406,7 +491,7 @@ if (message.type() != MqttMessage::Type::PingReq && message.type() != MqttMessag
 			if (client)
 			{
 				uint16_t pingreq = MqttMessage::Type::PingResp;
-				client->write((uint8_t*)(&pingreq), 2);
+				client->write((const char*)(&pingreq), 2);
 			  bclose = false;
 			}
 			else
@@ -421,25 +506,27 @@ if (message.type() != MqttMessage::Type::PingReq && message.type() != MqttMessag
 				if (!mqtt_connected) break;
 				payload = header+2;
 				
-				debug("subscribe loop");
-				while(payload < message.end())
+				debug("un/subscribe loop");
+				while(payload < mesg->end())
 				{
-					message.getString(payload, len);	// Topic
+					mesg->getString(payload, len);	// Topic
 					debug( "  topic (" << std::string(payload, len) << ')');
-					outstring("Subscribes", payload, len);
+					outstring("  un/subscribes", payload, len);
 					// subscribe(Topic(payload, len));
 					Topic topic(payload, len);
-					if ((message.type() & 0XF0) == MqttMessage::Type::Subscribe)
+					payload += len;
+					if ((mesg->type() & 0XF0) == MqttMessage::Type::Subscribe)
+					{
+						uint8_t qos = *payload++;
+						if (qos != 0) debug("Unsupported QOS" << qos << endl);
 						subscriptions.insert(topic);
+					}
 					else
 					{
 						auto it=subscriptions.find(topic);
 						if (it != subscriptions.end())
 							subscriptions.erase(it);
 					}
-					payload += len;
-					uint8_t qos = *payload++;
-					debug("  qos=" << qos);
 				}
 				debug("end loop");
 				bclose = false;
@@ -447,38 +534,44 @@ if (message.type() != MqttMessage::Type::PingReq && message.type() != MqttMessag
 			}
 			break;

-		case MqttMessage::Type::Publish:
+		case MqttMessage::Type::UnSuback:
 			if (!mqtt_connected) break;
+			bclose = false;
+			break;
+
+		case MqttMessage::Type::Publish:
+			if (mqtt_connected or client == nullptr)
 			{
-				uint8_t qos = message.type() & 0x6;
+				uint8_t qos = mesg->type() & 0x6;
 				payload = header;
-				message.getString(payload, len);
+				mesg->getString(payload, len);
 				Topic published(payload, len);
 				payload += len;
-				len=message.end()-payload;
 				// Serial << "Received Publish (" << published.str().c_str() << ") size=" << (int)len
-				// << '(' << std::string(payload, len).c_str() << ')'	<< " msglen=" << message.length() << endl; 
+				// << '(' << 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)
+
+				if (client==nullptr)	// internal MqttClient receives publish
+				{
+					if (callback and isSubscribedTo(published))
+					{
+						callback(this, published, payload, len);	// TODO send the real payload
+					}
+				}
+				else if (parent) // from outside to inside
 				{
 				  debug("publishing to parent");
-					parent->publish(this, published, message);
+					parent->publish(this, published, *mesg);
 				}
-				else if (callback && subscriptions.find(published)!=subscriptions.end())
-				{
-					callback(this, published, nullptr, 0);	// TODO send the real payload
-				}
-				message.create(MqttMessage::Type::PubAck);
-				// TODO re-add packet identifier if any
-				message.sendTo(this);
 				bclose = false;
 			}
 			break;

 		case MqttMessage::Type::Disconnect:
-			// TODO should discard any will message
+			// TODO should discard any will msg
 			if (!mqtt_connected) break;
 			mqtt_connected = false;
 			close(false);
@@ -491,8 +584,9 @@ if (message.type() != MqttMessage::Type::PingReq && message.type() != MqttMessag
 	};
 	if (bclose)
 	{
-		Serial << "*************** Error msg 0x" << _HEX(message.type());
-		message.hexdump("-------ERROR ------");
+		Serial << "*************** Error msg 0x" << _HEX(mesg->type());
+		mesg->hexdump("-------ERROR ------");
+		dump();
 		Serial << endl;
 		close();
  }
@@ -500,7 +594,6 @@ if (message.type() != MqttMessage::Type::PingReq && message.type() != MqttMessag
 	{
 		clientAlive(parent ? 5 : 0);
 	}
-	message.reset();
 }

 bool Topic::matches(const Topic& topic) const
@@ -516,8 +609,11 @@ MqttError MqttClient::publish(const Topic& topic, const char* payload, size_t pa
 	MqttMessage msg(MqttMessage::Publish);
 	msg.add(topic);
 	msg.add(payload, pay_length, false);
+	msg.complete();
 	if (parent)
+	{
 		return parent->publish(this, topic, msg);
+	}
 	else if (client)
 		return msg.sendTo(this);
 	else
@@ -525,29 +621,33 @@ MqttError MqttClient::publish(const Topic& topic, const char* payload, size_t pa
 }

 // republish a received publish if it matches any in subscriptions
-MqttError MqttClient::publish(const Topic& topic, MqttMessage& msg)
+MqttError MqttClient::publishIfSubscribed(const Topic& topic, const MqttMessage& msg)
 {
 	MqttError retval=MqttOk;

 	debug("mqttclient publish " << subscriptions.size());
-	for(const auto& subscription: subscriptions)
+	if (isSubscribedTo(topic))
 	{
-		if (subscription.matches(topic))
+		if (client)
+			retval = msg.sendTo(this);
+		else
 		{
-			debug(" match client=" << (int32_t)client << ", topic " << topic.str().c_str() << ' ');
-			if (client)
-			{
-				retval = msg.sendTo(this);
-			}
-			else if (callback)
-			{
-				callback(this, topic, nullptr, 0);	// TODO Payload
-			}
+			processMessage(&msg);
+			// callback(this, topic, nullptr, 0);	// TODO Payload
 		}
 	}
 	return retval;
 }

+bool MqttClient::isSubscribedTo(const Topic& topic) const
+{
+	for(const auto& subscription: subscriptions)
+		if (subscription.matches(topic))
+			return true;
+
+	return false;
+}
+
 void MqttMessage::reset()
 {
 	buffer.clear();
@@ -565,7 +665,12 @@ void MqttMessage::incoming(char in_byte)
 			state = Length;
 			break;
 		case Length:
-			size = (size<<7) + (in_byte & 0x3F);
+		  if (size==0)
+        size = in_byte & 0x7F;
+		  else if (size<128)
+		    size += static_cast<uint16_t>(in_byte & 0x7F)<<7;
+		  else
+		    state = Error;  // Really don't want to handle msg with length > 16k
 			if (size > MaxBufferLength)
 			{
 				state = Error;
@@ -616,13 +721,14 @@ void MqttMessage::add(const char* p, size_t len, bool addLength)
 {
 	if (addLength)
 	{
+		buffer.reserve(buffer.length()+addLength+2);
 		incoming(len>>8);
 		incoming(len & 0xFF);
 	}
 	while(len--) incoming(*p++);
 }

-void MqttMessage::encodeLength(char* msb, int length)
+void MqttMessage::encodeLength(char* msb, int length) const
 {
 	do
 	{
@@ -633,7 +739,13 @@ void MqttMessage::encodeLength(char* msb, int length)
 	} while (length);
 };

-MqttError MqttMessage::sendTo(MqttClient* client)
+void MqttMessage::complete()
+{
+		encodeLength(&buffer[1], buffer.size()-2);
+		state = Complete;
+}
+
+MqttError MqttMessage::sendTo(MqttClient* client) const
 {
 	if (buffer.size())
 	{
--- a/src/TinyMqtt.h
+++ b/src/TinyMqtt.h
@@ -1,18 +1,47 @@
-#include <ESP8266WiFi.h>
+#pragma once
+
+// TODO Should add a AUnit with both TCP_ASYNC and not TCP_ASYNC
+// #define TCP_ASYNC	// Uncomment this to use ESPAsyncTCP instead of normal cnx
+
+#if defined(ESP8266) || defined(EPOXY_DUINO)
+	#ifdef TCP_ASYNC
+		#include <ESPAsyncTCP.h>
+  #else
+    #include <ESP8266WiFi.h>
+  #endif
+#elif defined(ESP32)
+  #include <WiFi.h>
+	#ifdef TCP_ASYNC
+	  #include <AsyncTCP.h> // https://github.com/me-no-dev/AsyncTCP
+  #endif
+#endif
+#ifdef EPOXY_DUINO
+  #define dbg_ptr uint64_t
+#else
+  #define dbg_ptr uint32_t
+#endif
 #include <vector>
 #include <set>
 #include <string>
 #include "StringIndexer.h"
 #include <MqttStreaming.h>

-#if 0
+// #define TINY_MQTT_DEBUG
+
+#ifdef TINY_MQTT_DEBUG
  #define debug(what) { Serial << __LINE__ << ' ' << what << endl; delay(100); }
-  #define TINY_MQTT_DEBUG 1
 #else
-  #define TINY_MQTT_DEBUG 0
  #define debug(what) {}
 #endif

+#ifdef TCP_ASYNC
+  using TcpClient = AsyncClient;
+  using TcpServer = AsyncServer;
+#else
+  using TcpClient = WiFiClient;
+  using TcpServer = WiFiServer;
+#endif
+
 enum MqttError
 {
 	MqttOk = 0,
@@ -35,7 +64,7 @@ class Topic : public IndexedString
 class MqttClient;
 class MqttMessage
 {
-	const uint16_t MaxBufferLength = 255;
+	const uint16_t MaxBufferLength = 4096;  //hard limit: 16k
 	public:
 		enum Type
 		{
@@ -47,6 +76,7 @@ class MqttMessage
 			Subscribe   = 0x80,
 			SubAck      = 0x90,
 			UnSubscribe = 0xA0,
+			UnSuback	= 0xB0,
 			PingReq     = 0xC0,
 			PingResp    = 0xD0,
 			Disconnect  = 0xE0
@@ -72,6 +102,7 @@ class MqttMessage
 		const char* end() const { return &buffer[0]+buffer.size(); }
 		const char* getVHeader() const { return &buffer[vheader]; }
 		uint16_t length() const { return buffer.size(); }
+		void complete();

 		void reset();

@@ -79,7 +110,6 @@ class MqttMessage
 		// output buff+=2, len=length(str)
 		static void getString(const char* &buff, uint16_t& len);

-
 		Type type() const
 		{
 			return state == Complete ? static_cast<Type>(buffer[0]) : Unknown;
@@ -88,18 +118,18 @@ class MqttMessage
 		void create(Type type)
 		{
 			buffer=(char)type;
-			buffer+='\0';
+			buffer+='\0';		// reserved for msg length
 			vheader=2;
 			size=0;
 			state=Create;
 		}
-		MqttError sendTo(MqttClient*);
+		MqttError sendTo(MqttClient*) const;
 		void hexdump(const char* prefix=nullptr) const;

 	private:
-		void encodeLength(char* msb, int length);
+		void encodeLength(char* msb, int length) const;

-		std::string buffer;
+		mutable std::string buffer;	// mutable -> sendTo()
 		uint8_t vheader;
 		uint16_t size;	// bytes left to receive
 		State state;
@@ -120,14 +150,15 @@ class MqttClient
 		FlagReserved = 1
 	};
 	public:
-		MqttClient(MqttBroker*);
-		MqttClient(MqttBroker* brk, const std::string& id) : MqttClient(brk) { clientId=id; }
-		MqttClient() : MqttClient(nullptr) {};
+	  /** 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() **/
+		MqttClient(MqttBroker* broker = nullptr, const std::string& id="");
+		MqttClient(const std::string& id) : MqttClient(nullptr, id){}

 		~MqttClient();

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

 		bool connected() { return
 			(parent!=nullptr and client==nullptr) or
@@ -138,60 +169,69 @@ class MqttClient
 		const std::string& id() const { return clientId; }
 		void id(std::string& new_id) { clientId = new_id; }

+		/** Should be called in main loop() */
 		void loop();
 		void close(bool bSendDisconnect=true);
 		void setCallback(CallBack fun) {callback=fun; };

 		// Publish from client to the world
 		MqttError publish(const Topic&, const char* payload, size_t pay_length);
+		MqttError publish(const Topic& t, const char* payload) { return publish(t, payload, strlen(payload)); }
 		MqttError publish(const Topic& t, const String& s) { return publish(t, s.c_str(), s.length()); }
 		MqttError publish(const Topic& t, const std::string& s) { return publish(t,s.c_str(),s.length());}
 		MqttError publish(const Topic& t) { return publish(t, nullptr, 0);};

 		MqttError subscribe(Topic topic, uint8_t qos=0);
 		MqttError unsubscribe(Topic topic);
+		bool isSubscribedTo(const Topic& topic) const;

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

-		void dump()
+		void dump(std::string indent="")
 		{
 			uint32_t ms=millis();
-			Serial << "MqttClient (" << clientId.c_str() << ") p=" << (int32_t) parent
-				<< " c=" << (int32_t)client << (connected() ? " ON " : " OFF"); 
-			Serial << ", alive=" << (uint32_t)alive << '/' << ms << ", ka=" << keep_alive;
+			Serial << indent << "+-- " << '\'' << clientId.c_str() << "' " << (connected() ? " ON " : " OFF");
+			Serial << ", alive=" << alive << '/' << ms << ", ka=" << keep_alive << ' ';
 			Serial << (client && client->connected() ? "" : "dis") << "connected";
-		  message.hexdump("entrant msg");
-			bool c=false;
-			Serial << " [";
-			for(auto s: subscriptions)
+			if (subscriptions.size())
 			{
-				Serial << (c?", ": "")<< s.str().c_str();
-				c=true;
+				bool c = false;
+				Serial << " [";
+				for(auto s: subscriptions)
+				{
+					if (c) Serial << ", ";
+					Serial << s.str().c_str();
+					c=true;
+				}
+				Serial << ']';
 			}
-
-			
-			Serial << "]" << endl;
+			Serial << endl;
 		}

-		static long counter;	// Number of messages sent
+		/** Count the number of messages that have been sent **/
+		static long counter;

 	private:
+		static void onConnect(void * client_ptr, TcpClient*);
+#ifdef TCP_ASYNC
+		static void onData(void* client_ptr, TcpClient*, void* data, size_t len);
+#endif
 		MqttError sendTopic(const Topic& topic, MqttMessage::Type type, uint8_t qos);
 		void resubscribe();

 		friend class MqttBroker;
-		MqttClient(MqttBroker* parent, WiFiClient& client);
+		MqttClient(MqttBroker* parent, TcpClient* client);
 		// republish a received publish if topic matches any in subscriptions
-		MqttError publish(const Topic& topic, MqttMessage& msg);
+		MqttError publishIfSubscribed(const Topic& topic, const MqttMessage& msg);

 		void clientAlive(uint32_t more_seconds);
-		void processMessage();
+		void processMessage(const MqttMessage* message);

 		bool mqtt_connected = false;
 		char mqtt_flags;
-		uint32_t keep_alive;
+		uint32_t keep_alive = 60;
 		uint32_t alive;
 		MqttMessage message;

@@ -200,7 +240,7 @@ class MqttClient
 		// (this is the case when MqttBroker isn't used except here)
 		MqttBroker* parent=nullptr;		// connection to local broker

-		WiFiClient* client=nullptr;		// connection to mqtt client or to remote broker
+		TcpClient* client=nullptr;		// connection to mqtt client or to remote broker
 		std::set<Topic>	subscriptions;
 		std::string clientId;
 		CallBack callback = nullptr;
@@ -219,29 +259,24 @@ class MqttBroker
 		MqttBroker(uint16_t port);
 		~MqttBroker();

-		void begin() { server.begin(); }
+		void begin() { server->begin(); }
 		void loop();

-		uint8_t port() const { return server.port(); }
-
-		void connect(std::string host, uint32_t port=1883);
+		void connect(const std::string& host, uint16_t port=1883);
 		bool connected() const { return state == Connected; }

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

-		void dump()
+		void dump(std::string indent="")
 		{
-			Serial << clients.size() << " client/s" << endl;
 			for(auto client: clients)
-			{
-				Serial << "  ";
-				client->dump();
-			}
+				client->dump(indent);
 		}

 	private:
 		friend class MqttClient;

+		static void onClient(void*, TcpClient*);
 		bool checkUser(const char* user, uint8_t len) const
 		{ return compareString(auth_user, user, len); }

@@ -249,7 +284,9 @@ class MqttBroker
 		{ return compareString(auth_password, password, len); }


-		MqttError publish(const MqttClient* source, const Topic& topic, MqttMessage& msg);
+		MqttError publish(const MqttClient* source, const Topic& topic, const MqttMessage& msg) const;
+
+		MqttError subscribe(const Topic& topic, uint8_t qos);

 		// For clients that are added not by the broker itself
 		void addClient(MqttClient* client);
@@ -257,7 +294,7 @@ class MqttBroker

 		bool compareString(const char* good, const char* str, uint8_t str_len) const;
 		std::vector<MqttClient*>	clients;
-		WiFiServer server;
+		TcpServer* server;

 		const char* auth_user = "guest";
 		const char* auth_password = "guest";
--- a/tests/Makefile
+++ b/tests/Makefile
@@ -5,7 +5,7 @@ tests:
 		$(MAKE) -C $$(dirname $$i) -j; \
 	done

-runtests:
+runtests: tests
 	set -e; \
 	for i in *-tests/Makefile; do \
 		echo '==== Running:' $$(dirname $$i); \
--- a/tests/length-tests/Makefile
+++ b/tests/length-tests/Makefile
@@ -0,0 +1,8 @@
+# See https://github.com/bxparks/EpoxyDuino for documentation about this
+# Makefile to compile and run Arduino programs natively on Linux or MacOS.
+
+APP_NAME := length-tests
+ARDUINO_LIBS := AUnit AceCommon AceTime TinyMqtt EspMock ESP8266WiFi  ESPAsyncTCP
+ARDUINO_LIB_DIRS := ../../../EspMock/libraries
+EPOXY_CORE := EPOXY_CORE_ESP8266
+include ../../../EpoxyDuino/EpoxyDuino.mk
--- a/tests/length-tests/length-tests.ino
+++ b/tests/length-tests/length-tests.ino
@@ -0,0 +1,53 @@
+#include <AUnit.h>
+#include <TinyMqtt.h>
+#include <map>
+
+/**
+	* TinyMqtt local unit tests.
+	*
+	* Clients are connected to pseudo remote broker
+	* The remote should be 127.0.0.1:1883 <--- But this does not work due to Esp network limitations
+	* We are using 127.0.0.1 because this is simpler to test with a single ESP
+	* Also, this will allow to mock and thus run Action on github
+	**/
+
+using namespace std;
+
+MqttBroker broker(1883);
+
+std::map<std::string, std::map<Topic, int>>	published;		// map[client_id] => map[topic] = count
+
+const char* lastPayload;
+size_t lastLength;
+
+void onPublish(const MqttClient* srce, const Topic& topic, const char* payload, size_t length)
+{
+	if (srce)
+		published[srce->id()][topic]++;
+  lastPayload = payload;
+	lastLength = length;
+}
+
+test(length_decode_greater_than_127)
+{
+  // TODO WRITE THIS TEST
+  // The test should verify than a mqtt message with more than 127 bytes is correctly decoded
+	assertEqual(1,2);
+}
+
+
+//----------------------------------------------------------------------------
+// setup() and loop()
+void setup() {
+	delay(1000);
+	Serial.begin(115200);
+	while(!Serial);
+
+	Serial.println("=============[ NO WIFI CONNECTION TinyMqtt TESTS ]========================");
+}
+
+void loop() {
+	aunit::TestRunner::run();
+
+	if (Serial.available()) ESP.reset();
+}
--- a/tests/local-tests/Makefile
+++ b/tests/local-tests/Makefile
@@ -2,5 +2,7 @@
 # Makefile to compile and run Arduino programs natively on Linux or MacOS.

 APP_NAME := local-tests
-ARDUINO_LIBS := AUnit AceCommon AceTime TinyMqtt ESP8266WiFi
+ARDUINO_LIBS := AUnit AceCommon AceTime TinyMqtt EspMock ESP8266WiFi  ESPAsyncTCP
+ARDUINO_LIB_DIRS := ../../../EspMock/libraries
+EPOXY_CORE := EPOXY_CORE_ESP8266
 include ../../../EpoxyDuino/EpoxyDuino.mk
--- a/tests/local-tests/local-tests.ino
+++ b/tests/local-tests/local-tests.ino
@@ -3,9 +3,12 @@
 #include <map>

 /**
-  * TinyMqtt local unit tests.
+	* TinyMqtt local unit tests.
 	*
-	* No wifi connection unit tests.
+	* Clients are connected to pseudo remote broker
+	* The remote should be 127.0.0.1:1883 <--- But this does not work due to Esp network limitations
+	* We are using 127.0.0.1 because this is simpler to test with a single ESP
+	* Also, this will allow to mock and thus run Action on github
 	**/

 using namespace std;
@@ -14,27 +17,36 @@ MqttBroker broker(1883);

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

+const char* lastPayload;
+size_t lastLength;
+
 void onPublish(const MqttClient* srce, const Topic& topic, const char* payload, size_t length)
 {
 	if (srce)
 		published[srce->id()][topic]++;
+  lastPayload = payload;
+	lastLength = length;
 }

 test(local_client_should_unregister_when_destroyed)
 {
+return;
 	assertEqual(broker.clientsCount(), (size_t)0);
 	{
-		MqttClient client(&broker);
-		assertEqual(broker.clientsCount(), (size_t)1);
+		MqttClient client;
+		assertEqual(broker.clientsCount(), (size_t)0);	// Ensure client is not yet connected
+		client.connect("127.0.0.1", 1883);
+		assertEqual(broker.clientsCount(), (size_t)1);	// Ensure client is now connected
 	}
 	assertEqual(broker.clientsCount(), (size_t)0);
 }

+#if 0
 test(local_connect)
 {
 	assertEqual(broker.clientsCount(), (size_t)0);

-	MqttClient client(&broker);
+	MqttClient client;
 	assertTrue(client.connected());
 	assertEqual(broker.clientsCount(), (size_t)1);
 }
@@ -44,12 +56,12 @@ test(local_publish_should_be_dispatched)
 	published.clear();
 	assertEqual(broker.clientsCount(), (size_t)0);

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

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

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

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

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

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

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

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

 	subscriber.unsubscribe("a/b");
@@ -109,30 +121,32 @@ test(local_nocallback_when_destroyed)
 	published.clear();
 	assertEqual(broker.clientsCount(), (size_t)0);

+	MqttClient publisher;
 	{
-		MqttClient subscriber(&broker);
+		MqttClient subscriber;
 		subscriber.setCallback(onPublish);
 		subscriber.subscribe("a/b");
+		publisher.publish("a/b");
 	}

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

-	assertEqual(published.size(), (size_t)0);	// 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);
-  Serial.begin(115200);
-  while(!Serial);
+	delay(1000);
+	Serial.begin(115200);
+	while(!Serial);

 	Serial.println("=============[ NO WIFI CONNECTION TinyMqtt TESTS ]========================");
 }

 void loop() {
-  aunit::TestRunner::run();
+	aunit::TestRunner::run();

 	if (Serial.available()) ESP.reset();
 }
--- a/tests/nowifi-tests/Makefile
+++ b/tests/nowifi-tests/Makefile
@@ -0,0 +1,8 @@
+# See https://github.com/bxparks/EpoxyDuino for documentation about this
+# Makefile to compile and run Arduino programs natively on Linux or MacOS.
+
+APP_NAME := nowifi-tests
+ARDUINO_LIBS := AUnit AceCommon AceTime TinyMqtt EspMock ESP8266WiFi  ESPAsyncTCP
+ARDUINO_LIB_DIRS := ../../../EspMock/libraries
+EPOXY_CORE := EPOXY_CORE_ESP8266
+include ../../../EpoxyDuino/EpoxyDuino.mk
--- a/tests/nowifi-tests/nowifi-tests.ino
+++ b/tests/nowifi-tests/nowifi-tests.ino
@@ -0,0 +1,166 @@
+#include <AUnit.h>
+#include <TinyMqtt.h>
+#include <map>
+
+/**
+  * TinyMqtt nowifi 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
+
+char* lastPayload = nullptr;
+size_t lastLength;
+
+void onPublish(const MqttClient* srce, const Topic& topic, const char* payload, size_t length)
+{
+	if (srce)
+		published[srce->id()][topic]++;
+	
+	if (lastPayload) free(lastPayload);
+  lastPayload = strdup(payload);
+	lastLength = length;
+}
+
+test(nowifi_client_should_unregister_when_destroyed)
+{
+	assertEqual(broker.clientsCount(), (size_t)0);
+	{
+		MqttClient client(&broker);
+		assertEqual(broker.clientsCount(), (size_t)1);
+	}
+	assertEqual(broker.clientsCount(), (size_t)0);
+}
+
+test(nowifi_connect)
+{
+	assertEqual(broker.clientsCount(), (size_t)0);
+
+	MqttClient client(&broker);
+	assertTrue(client.connected());
+	assertEqual(broker.clientsCount(), (size_t)1);
+}
+
+test(nowifi_publish_should_be_dispatched)
+{
+	published.clear();
+	assertEqual(broker.clientsCount(), (size_t)0);
+
+	MqttClient subscriber(&broker);
+	subscriber.subscribe("a/b");
+	subscriber.subscribe("a/c");
+	subscriber.setCallback(onPublish);
+
+	MqttClient publisher(&broker);
+	publisher.publish("a/b");
+	publisher.publish("a/c");
+	publisher.publish("a/c");
+
+	assertEqual(published.size(), (size_t)1);	// 1 client has received something
+	assertEqual(published[""]["a/b"], 1);
+	assertEqual(published[""]["a/c"], 2);
+}
+
+test(nowifi_publish_should_be_dispatched_to_clients)
+{
+	published.clear();
+	assertEqual(broker.clientsCount(), (size_t)0);
+
+	MqttClient subscriber_a(&broker, "A");
+	subscriber_a.setCallback(onPublish);
+	subscriber_a.subscribe("a/b");
+	subscriber_a.subscribe("a/c");
+
+	MqttClient subscriber_b(&broker, "B");
+	subscriber_b.setCallback(onPublish);
+	subscriber_b.subscribe("a/b");
+
+	MqttClient publisher(&broker);
+	publisher.publish("a/b");		// A and B should receive this
+	publisher.publish("a/c");		// A should receive this 
+
+	assertEqual(published.size(), (size_t)2);	// 2 clients have received something
+	assertEqual(published["A"]["a/b"], 1);
+	assertEqual(published["A"]["a/c"], 1);
+	assertEqual(published["B"]["a/b"], 1);
+	assertEqual(published["B"]["a/c"], 0);
+}
+
+test(nowifi_unsubscribe)
+{
+	published.clear();
+	assertEqual(broker.clientsCount(), (size_t)0);
+
+	MqttClient subscriber(&broker);
+	subscriber.setCallback(onPublish);
+	subscriber.subscribe("a/b");
+
+	MqttClient publisher(&broker);
+	publisher.publish("a/b");		// This publish is received
+
+	subscriber.unsubscribe("a/b");
+
+	publisher.publish("a/b");		// Those one, no (unsubscribed)
+	publisher.publish("a/b");
+
+	assertEqual(published[""]["a/b"], 1);	// Only one publish has been received
+}
+
+test(nowifi_nocallback_when_destroyed)
+{
+	published.clear();
+	assertEqual(broker.clientsCount(), (size_t)0);
+
+	MqttClient publisher(&broker);
+
+	{
+		MqttClient subscriber(&broker);
+		subscriber.setCallback(onPublish);
+		subscriber.subscribe("a/b");
+		publisher.publish("a/b");
+	}
+
+	publisher.publish("a/b");
+
+	assertEqual(published.size(), (size_t)1);	// Only one publish has been received
+}
+
+test(nowifi_payload_nullptr)
+{
+	published.clear();
+
+	const char* payload="abcd";
+
+	MqttClient subscriber(&broker);
+	subscriber.setCallback(onPublish);
+	subscriber.subscribe("a/b");
+
+	MqttClient publisher(&broker);
+	publisher.publish("a/b", payload, strlen(payload));		// This publish is received
+
+  // coming from MqttClient::publish(...)
+  assertEqual(payload, lastPayload);
+	assertEqual(lastLength, (size_t)4);
+}
+
+//----------------------------------------------------------------------------
+// setup() and loop()
+void setup() {
+	delay(1000);
+	Serial.begin(115200);
+	while(!Serial);
+
+	Serial.println("=============[ NO WIFI CONNECTION TinyMqtt TESTS ]========================");
+}
+
+void loop() {
+	aunit::TestRunner::run();
+
+	if (Serial.available()) ESP.reset();
+}
--- a/tests/result.json
+++ b/tests/result.json
@@ -0,0 +1,6 @@
+{
+    "schemaVersion" : 1,
+    "label" : "tests",
+    "message" : "Message content",
+    "color": "red"
+}
--- a/tests/result.yaml
+++ b/tests/result.yaml
@@ -0,0 +1,2 @@
+result: 1
+insert: "passed"
--- a/tests/string-indexer-tests/Makefile
+++ b/tests/string-indexer-tests/Makefile
@@ -0,0 +1,8 @@
+# See https://github.com/bxparks/EpoxyDuino for documentation about this
+# Makefile to compile and run Arduino programs natively on Linux or MacOS.
+
+APP_NAME := string-indexer-tests
+ARDUINO_LIBS := AUnit AceCommon AceTime TinyMqtt EspMock ESP8266WiFi  ESPAsync
+ARDUINO_LIB_DIRS := ../../../EspMock/libraries
+EPOXY_CORE := EPOXY_CORE_ESP8266
+include ../../../EpoxyDuino/EpoxyDuino.mk
--- a/tests/string-indexer-tests/string-indexer-tests.ino
+++ b/tests/string-indexer-tests/string-indexer-tests.ino
@@ -0,0 +1,109 @@
+#include <AUnit.h>
+#include <StringIndexer.h>
+#include <map>
+
+/**
+	* TinyMqtt / StringIndexer unit tests.
+	*
+	**/
+
+using namespace std;
+
+test(indexer_empty)
+{
+  assertEqual(StringIndexer::count(), 0);
+}
+
+test(indexer_strings_deleted_should_empty_indexer)
+{
+  assertTrue(StringIndexer::count()==0);
+	{
+		IndexedString one("one");
+    assertEqual(StringIndexer::count(), 1);
+		IndexedString two("two");
+    assertEqual(StringIndexer::count(), 2);
+		IndexedString three("three");
+    assertEqual(StringIndexer::count(), 3);
+		IndexedString four("four");
+    assertEqual(StringIndexer::count(), 4);
+	}
+  assertEqual(StringIndexer::count(), 0);
+}
+
+test(indexer_same_strings_count_as_one)
+{
+	IndexedString one  ("one");
+	IndexedString two  ("one");
+	IndexedString three("one");
+	IndexedString fourt("one");
+
+	assertEqual(StringIndexer::count(), 1);
+}
+
+test(indexer_size_of_indexed_string)
+{
+	assertEqual(sizeof(IndexedString), (size_t)1);
+}
+
+test(indexer_different_strings_are_different)
+{
+	IndexedString one("one");
+	IndexedString two("two");
+
+	assertFalse(one == two);
+}
+
+test(indexer_same_strings_should_equal)
+{
+	IndexedString one("one");
+	IndexedString two("one");
+
+	assertTrue(one == two);
+}
+
+test(indexer_indexed_operator_eq)
+{
+	IndexedString one("one");
+	{
+		IndexedString same = one;
+		assertTrue(one == same);
+		assertEqual(StringIndexer::count(), 1);
+  }
+	assertEqual(StringIndexer::count(), 1);
+}
+
+test(indexer_get_string)
+{
+	std::string sone("one");
+	IndexedString one(sone);
+
+  assertTrue(sone==one.str());
+}
+
+test(indexer_get_index)
+{
+	IndexedString one1("one");
+	IndexedString one2("one");
+	IndexedString two1("two");
+	IndexedString two2("two");
+
+  assertTrue(one1.getIndex() == one2.getIndex());
+	assertTrue(two1.getIndex() == two2.getIndex());
+	assertTrue(one1.getIndex() != two1.getIndex());
+}
+
+//----------------------------------------------------------------------------
+// setup() and loop()
+void setup() {
+	delay(1000);
+	Serial.begin(115200);
+	while(!Serial);
+
+	Serial.println("=============[ TinyMqtt StringIndexer TESTS ]========================");
+}
+
+void loop() {
+	aunit::TestRunner::run();
+
+	// if (Serial.available()) ESP.reset();
+}
Author	SHA1	Message	Date
hsaturn	9c7f3b6b8e	Fix of decode length	2021-08-09 10:37:46 +02:00
hsaturn	fab242e212	Version 0.7.6	2021-08-09 03:04:21 +02:00
hsaturn	56a2be621f	Fix message length error	2021-08-09 03:00:28 +02:00
hsaturn	c4cf39ab68	Fix aunit tests	2021-08-09 02:33:01 +02:00
hsaturn	90dea36ab0	Attempt to write more readable examples	2021-05-13 03:21:03 +02:00
hsaturn	25a721e06a	Attempt to write more readable examples	2021-05-13 03:21:03 +02:00
hsaturn	b228d35ab0	Attempt to write more readable examples	2021-05-13 03:21:03 +02:00
hsaturn	c70716a595	Attempt to write more readable examples	2021-05-13 03:21:03 +02:00
hsaturn	8d5cad5fec	Added overload of Client::publish, fix compilation	2021-05-13 03:21:03 +02:00
hsaturn	d5430228e5	Fix cr/lf bug Added echo on\|off for later vt100 terminal Added rnd(min,max) function Simplied every function Better parsing for getword (accept strings) Fix for blink command	2021-05-13 03:21:03 +02:00
hsaturn	91c1f96146	Update README.md links updates	2021-05-08 15:14:59 +02:00
hsaturn	f04a2a07c0	Fix aunit.yml	2021-04-28 21:22:07 +00:00
hsaturn	38f306c170	Fix compilation esp8266 esp32	2021-04-28 23:16:33 +02:00
hsaturn	024e80c9dc	Perpare for future ESP32 aunit tests	2021-04-28 21:00:31 +00:00
hsaturn	2249ddef7f	Release 0.7.5	2021-04-28 18:57:24 +02:00
hsaturn	e193929f8f	changed every command	2021-04-28 18:56:17 +02:00
hsaturn	e00e31de33	Fix build in Esp8266 mode Modify dump() functions	2021-04-28 18:55:57 +02:00
hsaturn	20292b7b7b	Fix example syntax	2021-04-28 08:24:44 +02:00
hsaturn	26de3befa8	TinyTest Esp32 port Update library definition	2021-04-28 08:19:55 +02:00
hsaturn	1098466055	Update README.md	2021-04-28 08:14:46 +02:00
hsaturn	2d3663e78c	Update README.md	2021-04-28 07:32:56 +02:00
hsaturn	5e16282ad0	Disable ci.yml	2021-04-21 01:10:35 +02:00
hsaturn	e35a43c4a4	Trying to remove unsupported platform that break ci.yml	2021-04-21 01:05:31 +02:00
hsaturn	087a203ba0	Create ci.yml	2021-04-21 00:56:49 +02:00
hsaturn	5d313bbf5e	Rewrite examples	2021-04-12 00:27:25 +02:00
hsaturn	ce896f02c4	Merge pull request #6 from hsaturn/AsyncAndWifi AsyncTcp can be activated by removing the command on TCP_ASYNC in TinyMqtt.h But the code is not bug free yet.	2021-04-11 23:33:29 +02:00
hsaturn	d3210c3c93	Merge branch 'main' into AsyncAndWifi	2021-04-11 23:30:13 +02:00
hsaturn	23f1207718	Lot of new functions for tinytest - command every allowing to add peridic evaluations very usefull for benchmarks and load tests - on/off command	2021-04-11 23:27:15 +02:00
hsaturn	122ab88960	Rewrite client-with-wifi.ino	2021-04-11 23:26:49 +02:00
hsaturn	28b0ac1611	Fix missing receive loop for mqttclient	2021-04-11 21:21:48 +02:00
hsaturn	1cfb5cfab1	Allow multiple command per line separated by ;	2021-04-11 19:19:06 +02:00
hsaturn	b023cd67a9	Fix AUnit in debug mode / Not async	2021-04-11 17:02:24 +02:00
hsaturn	24ee6b5201	Fixes in WiFiClient mode	2021-04-11 16:33:12 +02:00
hsaturn	2e92a98db2	Trying to fuse togeter Async and not async version	2021-04-11 15:51:33 +02:00
hsaturn	c59bddfd39	Implementation of Unsuback (unless MqttClient disconnects)	2021-04-11 01:58:44 +02:00
hsaturn	7bdb9cc0cd	Tinytest, allow to blink output 0	2021-04-11 01:57:58 +02:00
hsaturn	be62699702	Fix connect problem with MqttClient	2021-04-11 00:48:04 +02:00
hsaturn	77da47e1da	Update README.md	2021-04-10 18:02:48 +02:00
hsaturn	88797bfafd	Added AUnit	2021-04-10 18:02:28 +02:00
hsaturn	1e3b37623d	Fix AUnit build	2021-04-10 17:54:46 +02:00
hsaturn	ba6a96976a	ESP32 version that could work	2021-04-10 17:47:21 +02:00
hsaturn	6afd3939b3	Merge remote-tracking branch 'origin/AsyncTcp' into main	2021-04-10 17:23:53 +02:00
hsaturn	2ffe0c13fa	README.md update	2021-04-10 17:23:46 +02:00
hsaturn	fe3f8d7b32	Very promising async commit	2021-04-10 17:19:57 +02:00
hsaturn	d1c7ebe134	Added unsubscribe to tinytest	2021-04-10 17:18:53 +02:00
hsaturn	aa0ed9a7a7	Bad merge fix	2021-04-10 17:18:53 +02:00
hsaturn	48eb0daf9a	Fix bug in unsubscription list	2021-04-10 17:16:25 +02:00
hsaturn	34c05bc37a	Fix compilation in DEBUG mode	2021-04-10 17:16:25 +02:00
hsaturn	7c96c4a5cc	Fix warning	2021-04-10 17:16:25 +02:00
hsaturn	b280196395	Added mqDns to tinytest	2021-04-10 17:16:25 +02:00
hsaturn	c75f4893e8	AsyncTcp AsyncTcp	2021-04-10 17:16:25 +02:00
hsaturn	d666f6a53b	AsyncTCP (to be continued)	2021-04-10 17:16:25 +02:00
hsaturn	7ef18de755	Very promising async commit	2021-04-10 17:16:25 +02:00
hsaturn	838df3a34a	Added unsubscribe to tinytest	2021-04-10 17:15:21 +02:00
hsaturn	ad602194cf	Fix bug in unsubscription list	2021-04-10 16:51:56 +02:00
hsaturn	afc9370e3e	Fix compilation in DEBUG mode	2021-04-10 16:51:35 +02:00
hsaturn	d96143f185	Fix warning	2021-04-10 16:50:45 +02:00
hsaturn	9c939a5667	Added mqDns to tinytest	2021-04-10 16:50:14 +02:00
hsaturn	8a25155fd8	Bad merge fix	2021-04-10 16:06:45 +02:00
hsaturn	d64ffe772e	Merge branch 'AsyncTcp' of github.com:hsaturn/TinyMqtt into AsyncTcp	2021-04-10 15:57:13 +02:00
hsaturn	db610e6f0f	Merge branch 'AsyncTcp' of github.com:hsaturn/TinyMqtt into AsyncTcp	2021-04-10 15:52:04 +02:00
hsaturn	6711f30ad0	AsyncTcp AsyncTcp	2021-04-10 15:51:29 +02:00
hsaturn	3e8d34e4e7	Very promising async commit Very promising async commit	2021-04-10 15:47:49 +02:00
hsaturn	67a296eb28	Fix too many things in StringIndexer test	2021-04-10 15:39:42 +02:00
hsaturn	e90076d010	AsyncTcp	2021-04-10 14:03:36 +02:00
hsaturn	f42464c173	AsyncTCP (to be continued)	2021-04-10 13:58:23 +02:00
hsaturn	36b452281f	Very promising async commit	2021-04-10 13:42:43 +02:00
hsaturn	077c0c6adf	Typo in libraries text	2021-04-09 23:29:32 +02:00
hsaturn	6f1e5d7488	Added blink command allowing to check if loop slows down	2021-04-09 23:27:50 +02:00
hsaturn	ca8ad88109	Refactoring of EspMock	2021-04-07 06:44:15 +02:00
hsaturn	986a9c592d	Update README.md	2021-04-05 14:18:21 +02:00
hsaturn	62868cba34	Fix payload test (the payload was sent, the test was buggy)	2021-04-05 13:54:40 +02:00
hsaturn	80dade00fe	Avoid unitialized values	2021-04-05 13:54:09 +02:00
hsaturn	8254bd4831	gitignore removed (not properly used)	2021-04-05 13:53:35 +02:00
hsaturn	5834a278c7	Release 0.7.3	2021-04-04 06:36:47 +02:00
hsaturn	146d0de1d4	MqttClient: bug fix, connection lost at each publish received	2021-04-04 06:35:50 +02:00
hsaturn	297a22efb5	Big rewrite of MqttClient in order to avoid code duplicate	2021-04-04 05:57:48 +02:00
hsaturn	510ff514a9	[tests] Changed assertions	2021-04-04 01:07:12 +02:00
hsaturn	ad6f7155e5	Added test for StringIndexer	2021-04-03 21:11:54 +02:00
hsaturn	3ed5874373	Fix compilation	2021-04-02 19:57:04 +02:00
hsaturn	e1a936e081	Merge branch 'main' of github.com:hsaturn/TinyMqtt into main	2021-04-02 19:23:53 +02:00
hsaturn	0757a95fbf	Keywords updated, code clean	2021-04-02 19:22:59 +02:00
hsaturn	7c8d71262f	Fix test (not yet finished)	2021-04-02 18:59:07 +02:00
hsaturn	138ce973f2	Typos in libraries	2021-04-02 18:48:37 +02:00
hsaturn	bf499117b7	Merge branch 'main' of github.com:hsaturn/TinyMqtt into main	2021-03-31 19:12:28 +02:00
hsaturn	4ed6f72602	Merge branch 'test' into main	2021-03-31 19:11:24 +02:00
hsaturn	87a78c549f	Fix crash at end of unit tests	2021-03-31 19:09:43 +02:00
hsaturn	5211360b91	Local tests added	2021-03-31 19:09:05 +02:00
hsaturn	549a23ffb7	Fix delete was not really deleting in tinytest	2021-03-31 10:40:06 +02:00
hsaturn	3a1af655d7	Fix compilation problem	2021-03-31 00:33:15 +02:00
hsaturn	e71ffefc5a	Fixed a useless test and modified MqttClient constructors	2021-03-31 00:22:31 +02:00
hsaturn	b6a0dde2b1	json	2021-03-30 08:52:46 +02:00
hsaturn	babc391632	Added json	2021-03-30 08:52:10 +02:00
hsaturn	27bdbb9a0b	str	2021-03-30 08:41:30 +02:00
hsaturn	6a9e158428	results	2021-03-30 08:39:02 +02:00
hsaturn	6fc6794dc3	result0.yaml	2021-03-30 08:37:25 +02:00
hsaturn	1eaa514579	result.yaml	2021-03-30 08:35:33 +02:00
hsaturn	7af4c2ca69	Added .o to gitignore	2021-03-30 08:21:56 +02:00
hsaturn	a340558460	Fix tests	2021-03-30 08:21:33 +02:00
hsaturn	9a7db237d3	Renamed local to nowifi as local will be used for local (127.0.0.1) tests	2021-03-30 08:15:13 +02:00
hsaturn	91e083e7b0	Merge branch 'linter' into main	2021-03-29 23:58:00 +02:00
hsaturn	97adc985e6	Code clean	2021-03-29 23:56:36 +02:00
hsaturn	6fcfc9dfc0	ptr	2021-03-29 23:20:49 +02:00
hsaturn	a6596ffc89	Fix ptr	2021-03-29 23:06:40 +02:00
hsaturn	533ab0c70d	Try to mock Esp	2021-03-29 21:47:14 +02:00
hsaturn	792a28e831	deleted	2021-03-29 20:45:33 +02:00
hsaturn	9407193454	MqttClient::unsubscribe implemented	2021-03-29 20:39:10 +02:00
hsaturn	602050f309	Update readme.md	2021-03-29 11:45:51 +02:00
hsaturn	1a70c90af2	refix EspWifi	2021-03-29 00:01:32 +02:00
hsaturn	ed4091c53e	ESP8266WiFi lib added for aunit	2021-03-28 23:57:06 +02:00
hsaturn	f2a805f724	Fix makefile	2021-03-28 23:50:50 +02:00
hsaturn	3083bcf071	Revert auint	2021-03-28 23:44:11 +02:00
hsaturn	d01f46dbc1	Fix aunit	2021-03-28 23:42:57 +02:00
hsaturn	39b2257619	Merge branch 'linter' of github.com:hsaturn/TinyMqtt into linter	2021-03-28 23:39:50 +02:00
hsaturn	60d385189b	Fixed make target	2021-03-28 23:39:37 +02:00
hsaturn	3f2c1c57e1	Fixed make target	2021-03-28 23:30:19 +02:00
hsaturn	e550197d0a	Fixed make target	2021-03-28 23:28:48 +02:00
hsaturn	253bc9b3f5	Added makefile for aunit	2021-03-28 23:26:53 +02:00
hsaturn	96d8018960	Test aunit	2021-03-28 23:16:07 +02:00
hsaturn	505cacc2df	Lint fixes	2021-03-28 23:09:10 +02:00
hsaturn	62848056a2	test	2021-03-28 23:01:14 +02:00