Merge branch 'main' of github.com:hsaturn/TinyMqtt into main

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

README.md

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

examples/tinymqtt-test/tinymqtt-test.ino

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

library.properties

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

src/StringIndexer.h

@@ -28,29 +28,6 @@ class StringIndexer
   public:
     using index_t = uint8_t;
 
-    static index_t strToIndex(const char* str, uint8_t len)
-    {
-      for(auto it=strings.begin(); it!=strings.end(); it++)
-      {
-        if (strncmp(it->second.str.c_str(), str, len)==0)
-        {
-          it->second.used++;
-          return it->first;
-        }
-      }
-      for(index_t index=1; index; index++)
-      {
-        if (strings.find(index)==strings.end())
-        {
-          strings[index].str = std::string(str, len);
-          strings[index].used++;
-          // Serial << "Creating index " << index << " for (" << strings[index].str.c_str() << ") len=" << len << endl;
-          return index;
-        }
-      }
-      return 0;  // TODO out of indexes
-    }
-
    static const std::string& str(const index_t& index)
     {
       static std::string dummy;
@@ -82,6 +59,32 @@ class StringIndexer
     static uint16_t count() { return strings.size(); }
 
   private:
+    friend class IndexedString;
+
+    // increment use of str or create a new index
+    static index_t strToIndex(const char* str, uint8_t len)
+    {
+      for(auto it=strings.begin(); it!=strings.end(); it++)
+      {
+        if (it->second.str.length() == len && strcmp(it->second.str.c_str(), str)==0)
+        {
+          it->second.used++;
+          return it->first;
+        }
+      }
+      for(index_t index=1; index; index++)
+      {
+        if (strings.find(index)==strings.end())
+        {
+          strings[index].str = std::string(str, len);
+          strings[index].used++;
+          // Serial << "Creating index " << index << " for (" << strings[index].str.c_str() << ") len=" << len << endl;
+          return index;
+        }
+      }
+      return 0;  // TODO out of indexes
+    }
+
     static std::map<index_t, StringCounter> strings;
 };
 

src/TinyMqtt.cpp

@@ -8,7 +8,7 @@
 MqttBroker::MqttBroker(uint16_t port)
 {
   server = new TcpServer(port);
-#ifdef TCP_ASYNC
+#ifdef TINY_MQTT_ASYNC
   server->onClient(onClient, this);
 #endif
 }
@@ -26,7 +26,7 @@ MqttBroker::~MqttBroker()
 MqttClient::MqttClient(MqttBroker* parent, TcpClient* new_client)
   : parent(parent)
 {
-#ifdef TCP_ASYNC
+#ifdef TINY_MQTT_ASYNC
   client = new_client;
   client->onData(onData, this);
   // client->onConnect() TODO
@@ -91,7 +91,7 @@ void MqttClient::connect(std::string broker, uint16_t port, uint16_t ka)
   client = new TcpClient;
 
   debug("Trying to connect to " << broker.c_str() << ':' << port);
-#ifdef TCP_ASYNC
+#ifdef TINY_MQTT_ASYNC
   client->onData(onData, this);
   client->onConnect(onConnect, this);
   client->connect(broker.c_str(), port);
@@ -146,7 +146,7 @@ void MqttBroker::onClient(void* broker_ptr, TcpClient* client)
 
 void MqttBroker::loop()
 {
-#ifndef TCP_ASYNC
+#ifndef TINY_MQTT_ASYNC
   WiFiClient client = server->available();
 
   if (client)
@@ -281,7 +281,7 @@ void MqttClient::loop()
       // there is no need to send one PingReq per instance.
     }
   }
-#ifndef TCP_ASYNC
+#ifndef TINY_MQTT_ASYNC
   while(client && client->available()>0)
   {
     message.incoming(client->read());
@@ -314,7 +314,7 @@ void MqttClient::onConnect(void *mqttclient_ptr, TcpClient*)
   mqtt->clientAlive(0);
 }
 
-#ifdef TCP_ASYNC
+#ifdef TINY_MQTT_ASYNC
 void MqttClient::onData(void* client_ptr, TcpClient*, void* data, size_t len)
 {
   char* char_ptr = static_cast<char*>(data);
@@ -636,9 +636,65 @@ if (mesg->type() != MqttMessage::Type::PingReq && mesg->type() != MqttMessage::T
 bool Topic::matches(const Topic& topic) const
 {
   if (getIndex() == topic.getIndex()) return true;
-  if (str() == topic.str()) return true;
+  const char* p1 = c_str();
+  const char* p2 = topic.c_str();
+
+  if (p1 == p2) return true;
+  if (*p2 == '$' and *p1 != '$') return false;
+
+  while(*p1 and *p2)
+  {
+    if (*p1 == '+')
+    {
+      ++p1;
+      if (*p1 and *p1!='/') return false;
+      if (*p1) ++p1;
+      while(*p2 and *p2++!='/');
+    }
+    else if (*p1 == '#')
+    {
+      if (*++p1==0) return true;
       return false;
     }
+    else if (*p1 == '*')
+    {
+      const char c=*(p1+1);
+      if (c==0) return true;
+      if (c!='/') return false;
+      const char*p = p1+2;
+      while(*p and *p2)
+      {
+        if (*p == *p2)
+        {
+          if (*p==0) return true;
+          if (*p=='/')
+          {
+            p1=p;
+            break;
+          }
+        }
+        else
+        {
+          while(*p2 and *p2++!='/');
+          break;
+        }
+        ++p;
+        ++p2;
+      }
+      if (*p==0) return true;
+    }
+    else if (*p1 == *p2)
+    {
+      ++p1;
+      ++p2;
+    }
+    else
+      return false;
+  }
+  if (*p1=='/' and p1[1]=='#' and p1[2]==0) return true;
+  return *p1==0 and *p2==0;
+}
+
 
 // publish from local client
 MqttError MqttClient::publish(const Topic& topic, const char* payload, size_t pay_length)

src/TinyMqtt.h

@@ -1,17 +1,17 @@
 #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
+// TODO Should add a AUnit with both TINY_MQTT_ASYNC and not TINY_MQTT_ASYNC
+// #define TINY_MQTT_ASYNC  // Uncomment this to use ESPAsyncTCP instead of normal cnx
 
 #if defined(ESP8266) || defined(EPOXY_DUINO)
-  #ifdef TCP_ASYNC
+  #ifdef TINY_MQTT_ASYNC
     #include <ESPAsyncTCP.h>
   #else
     #include <ESP8266WiFi.h>
   #endif
 #elif defined(ESP32)
   #include <WiFi.h>
-  #ifdef TCP_ASYNC
+  #ifdef TINY_MQTT_ASYNC
     #include <AsyncTCP.h> // https://github.com/me-no-dev/AsyncTCP
   #endif
 #endif
@@ -42,7 +42,7 @@
   #define debug(what) {}
 #endif
 
-#ifdef TCP_ASYNC
+#ifdef TINY_MQTT_ASYNC
   using TcpClient = AsyncClient;
   using TcpServer = AsyncServer;
 #else
@@ -221,7 +221,6 @@ class MqttClient
           bool c = false;
           Serial << " [";
           for(auto s: subscriptions)
-            (void)indent;
           {
             if (c) Serial << ", ";
             Serial << s.str().c_str();
@@ -241,7 +240,7 @@ class MqttClient
 
     // event when tcp/ip link established (real or fake)
     static void onConnect(void * client_ptr, TcpClient*);
-#ifdef TCP_ASYNC
+#ifdef TINY_MQTT_ASYNC
     static void onData(void* client_ptr, TcpClient*, void* data, size_t len);
 #endif
     MqttError sendTopic(const Topic& topic, MqttMessage::Type type, uint8_t qos);

tests/Makefile

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

tests/debug-mode/Makefile

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

tests/debug-mode/debug-tests.ino

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

tests/length-tests.todo/Makefile

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

tests/nowifi-tests/nowifi-tests.ino

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

tests/string-indexer-tests/Makefile

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

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

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

tests/topic-tests/Makefile

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

tests/topic-tests/topic-tests.ino

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