Update network-tests.ino

Remove useless code

src/MqttStreaming.h

@@ -38,6 +38,7 @@
   4.  Simple _FMT mechanism ala printf, but without the typeunsafetyness 
       and no internal buffers for replaceable stream printing
 */
+#pragma once
 
 #ifndef ARDUINO_STREAMING
 #define ARDUINO_STREAMING

src/TinyMqtt.cpp

@@ -1,13 +1,9 @@
 #include "TinyMqtt.h"
 #include <sstream>
 
-void outstring(const char* prefix, const char*p, uint16_t len)
+#ifdef EPOXY_DUINO
-{
+  std::map<MqttMessage::Type, int> MqttClient::counters;
-	return;
+#endif
-	Serial << prefix << "='";
-	while(len--) Serial << (char)*p++;
-	Serial << '\'' << endl;
-}
 
 MqttBroker::MqttBroker(uint16_t port)
 {
@@ -38,7 +34,11 @@ MqttClient::MqttClient(MqttBroker* parent, TcpClient* new_client)
 #else
 	client = new WiFiClient(*new_client);
 #endif
+#ifdef EPOXY_DUINO
+	alive = millis()+500000;
+#else
 	alive = millis()+5000;	// TODO MAGIC client expires after 5s if no CONNECT msg
+#endif
 }
 
 MqttClient::MqttClient(MqttBroker* parent, const std::string& id)
@@ -84,7 +84,7 @@ void MqttClient::connect(MqttBroker* parentBroker)
 
 void MqttClient::connect(std::string broker, uint16_t port, uint16_t ka)
 {
-	debug("cnx: closing");
+	debug("MqttClient::connect");
 	keep_alive = ka;
 	close();
 	if (client) delete client;
@@ -250,7 +250,11 @@ void MqttClient::clientAlive(uint32_t more_seconds)
 {
 	if (keep_alive)
 	{
+#ifdef EPOXY_DUINO
+		alive=millis()+500000;
+#else
 		alive=millis()+1000*(keep_alive+more_seconds);
+#endif
 	}
 	else
 		alive=0;
@@ -395,11 +399,8 @@ MqttError MqttClient::sendTopic(const Topic& topic, MqttMessage::Type type, uint
 	return msg.sendTo(this);
 }
 
-long MqttClient::counter=0;
-
 void MqttClient::processMessage(MqttMessage* mesg)
 {
-	counter++;
 #ifdef TINY_MQTT_DEBUG
 if (mesg->type() != MqttMessage::Type::PingReq && mesg->type() != MqttMessage::Type::PingResp)
 {
@@ -417,7 +418,11 @@ if (mesg->type() != MqttMessage::Type::PingReq && mesg->type() != MqttMessage::T
   uint16_t len;
 	bool bclose=true;
 
-	switch(mesg->type() & 0XF0)
+#ifdef EPOXY_DUINO
+  counters[mesg->type()]++;
+#endif
+
+	switch(mesg->type())
 	{
 		case MqttMessage::Type::Connect:
 			if (mqtt_connected)
@@ -447,11 +452,9 @@ if (mesg->type() != MqttMessage::Type::PingReq && mesg->type() != MqttMessage::T
 			if (mqtt_flags & FlagWill)	// Will topic
 			{
 				mesg->getString(payload, len);	// Will Topic
-				outstring("WillTopic", payload, len);
 				payload += len;
 
 				mesg->getString(payload, len);	// Will Message
-				outstring("WillMessage", payload, len);
 				payload += len;
 			}
 			// FIXME forgetting credential is allowed (security hole)
@@ -468,7 +471,9 @@ if (mesg->type() != MqttMessage::Type::PingReq && mesg->type() != MqttMessage::T
 				payload += len;
 			}
 
+      #ifdef TINY_MQTT_DEBUG
 			  Serial << "Connected client:" << clientId.c_str() << ", keep alive=" << keep_alive << '.' << endl;
+      #endif
 			bclose = false;
 			mqtt_connected=true;
 			{
@@ -518,18 +523,25 @@ if (mesg->type() != MqttMessage::Type::PingReq && mesg->type() != MqttMessage::T
 				payload = header+2;
 				
 				debug("un/subscribe loop");
+				std::string qoss;
 				while(payload < mesg->end())
 				{
 					mesg->getString(payload, len);	// Topic
 					debug( "  topic (" << std::string(payload, len) << ')');
-					outstring("  un/subscribes", payload, len);
 					// subscribe(Topic(payload, len));
 					Topic topic(payload, len);
+
 					payload += len;
-					if ((mesg->type() & 0XF0) == MqttMessage::Type::Subscribe)
+					if (mesg->type() == MqttMessage::Type::Subscribe)
 					{
 						uint8_t qos = *payload++;
-						if (qos != 0) debug("Unsupported QOS" << qos << endl);
+						if (qos != 0)
+						{
+							debug("Unsupported QOS" << qos << endl);
+							qoss.push_back(0x80);
+						}
+						else
+							qoss.push_back(qos);
 						subscriptions.insert(topic);
 					}
 					else
@@ -541,7 +553,12 @@ if (mesg->type() != MqttMessage::Type::PingReq && mesg->type() != MqttMessage::T
 				}
 				debug("end loop");
 				bclose = false;
-				// TODO SUBACK
+
+        MqttMessage ack(mesg->type() == MqttMessage::Type::Subscribe ? MqttMessage::Type::SubAck : MqttMessage::Type::UnSuback);
+        ack.add(header[0]);
+        ack.add(header[1]);
+        ack.add(qoss.c_str(), qoss.size(), false);
+        ack.sendTo(this);
 			}
 			break;
 
@@ -556,7 +573,7 @@ if (mesg->type() != MqttMessage::Type::PingReq && mesg->type() != MqttMessage::T
 			#endif
 			if (mqtt_connected or client == nullptr)
 			{
-				uint8_t qos = mesg->type() & 0x6;
+				uint8_t qos = mesg->flags();
 				payload = header;
 				mesg->getString(payload, len);
 				Topic published(payload, len);
@@ -602,10 +619,12 @@ if (mesg->type() != MqttMessage::Type::PingReq && mesg->type() != MqttMessage::T
 	};
 	if (bclose)
 	{
+    #ifdef TINY_MQTT_DEBUG
 		  Serial << "*************** Error msg 0x" << _HEX(mesg->type());
 		  mesg->hexdump("-------ERROR ------");
 		  dump();
 		  Serial << endl;
+    #endif
 		close();
   }
 	else
@@ -722,8 +741,10 @@ void MqttMessage::incoming(char in_byte)
 			break;
 		case Complete:
 		default:
+			#ifdef TINY_MQTT_DEBUG
 			  Serial << "Spurious " << _HEX(in_byte) << endl;
 			  hexdump("spurious");
+      #endif
 			reset();
 			break;
 	}
@@ -778,6 +799,8 @@ MqttError MqttMessage::sendTo(MqttClient* client)
 
 void MqttMessage::hexdump(const char* prefix) const
 {
+  (void)prefix;
+#ifdef TINY_MQTT_DEBUG
 	uint16_t addr=0;
 	const int bytes_per_row = 8;
 	const char* hex_to_str = " | ";
@@ -813,4 +836,5 @@ void MqttMessage::hexdump(const char* prefix) const
 	}
 
 	Serial << endl;
+#endif
 }

src/TinyMqtt.h

@@ -29,7 +29,7 @@
 // #define TINY_MQTT_DEBUG
 
 #ifdef TINY_MQTT_DEBUG
-  #define debug(what) { Serial << __LINE__ << ' ' << what << endl; delay(100); }
+  #define debug(what) { Serial << (int)__LINE__ << ' ' << what << endl; delay(100); }
 #else
   #define debug(what) {}
 #endif
@@ -42,7 +42,7 @@
   using TcpServer = WiFiServer;
 #endif
 
-enum MqttError
+enum __attribute__((packed)) MqttError
 {
 	MqttOk = 0,
 	MqttNowhereToSend=1,
@@ -66,7 +66,7 @@ class MqttMessage
 {
 	const uint16_t MaxBufferLength = 4096;  //hard limit: 16k due to size decoding
 	public:
-		enum Type
+		enum __attribute__((packed)) Type
 		{
 			Unknown     =    0,
 			Connect     = 0x10,
@@ -81,7 +81,7 @@ class MqttMessage
 			PingResp    = 0xD0,
 			Disconnect  = 0xE0
 		};
-		enum State
+		enum __attribute__((packed)) State
 		{
 			FixedHeader=0,
 			Length=1,
@@ -111,12 +111,14 @@ class MqttMessage
 
 		Type type() const
 		{
-			return state == Complete ? static_cast<Type>(buffer[0]) : Unknown;
+			return state == Complete ? static_cast<Type>(buffer[0] & 0xF0) : Unknown;
 		}
 
+		uint8_t flags() const { return static_cast<uint8_t>(buffer[0] & 0x0F); }
+
 		void create(Type type)
 		{
-			buffer=(char)type;
+			buffer=(decltype(buffer)::value_type)type;
 			buffer+='\0';		// reserved for msg length byte 1/2
 			buffer+='\0';		// reserved for msg length byte 2/2 (fixed)
 			vheader=3;      // Should never change
@@ -139,7 +141,7 @@ class MqttBroker;
 class MqttClient
 {
 	using CallBack = void (*)(const MqttClient* source, const Topic& topic, const char* payload, size_t payload_length);
-	enum Flags
+	enum __attribute__((packed)) Flags
 	{
 		FlagUserName = 128,
 		FlagPassword = 64,
@@ -160,6 +162,8 @@ class MqttClient
 		void connect(MqttBroker* parent);
 		void connect(std::string broker, uint16_t port, uint16_t keep_alive = 10);
 
+    // TODO it seems that connected returns true in tcp mode even if
+    // no negociation occured (only if tcp link is established)
 		bool connected() { return
 			(parent!=nullptr and client==nullptr) or
 			(client and client->connected()); }
@@ -198,6 +202,8 @@ class MqttClient
 
 		void dump(std::string indent="")
 		{
+		  (void)indent;
+      #ifdef TINY_MQTT_DEBUG
         uint32_t ms=millis();
         Serial << indent << "+-- " << '\'' << clientId.c_str() << "' " << (connected() ? " ON " : " OFF");
         Serial << ", alive=" << alive << '/' << ms << ", ka=" << keep_alive << ' ';
@@ -207,6 +213,7 @@ class MqttClient
           bool c = false;
           Serial << " [";
           for(auto s: subscriptions)
+            (void)indent;
           {
             if (c) Serial << ", ";
             Serial << s.str().c_str();
@@ -215,9 +222,12 @@ class MqttClient
           Serial << ']';
         }
         Serial << endl;
+      #endif
 		}
 
-		static long counter;  // Number of processed messages
+#ifdef EPOXY_DUINO
+		static std::map<MqttMessage::Type, int> counters;  // Number of processed messages
+#endif
 
 	private:
 
@@ -256,7 +266,7 @@ class MqttClient
 
 class MqttBroker
 {
-	enum State
+	enum __attribute__((packed)) State
 	{
 		Disconnected,	// Also the initial state
 		Connecting,		// connect and sends a fake publish to avoid circular cnx

tests/howto

@@ -4,3 +4,4 @@ git clone https://github.com/bxparks/AUnit.git
 git clone https://github.com/bxparks/EpoxyDuino.git
 cd TinyMqtt/tests
 make
+make runtests

tests/local-tests/Makefile

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

tests/local-tests/local-tests.ino

@@ -31,12 +31,10 @@ void onPublish(const MqttClient* srce, const Topic& topic, const char* payload,
 
 test(local_client_should_unregister_when_destroyed)
 {
-return;
 	assertEqual(broker.clientsCount(), (size_t)0);
 	{
-		MqttClient client;
 		assertEqual(broker.clientsCount(), (size_t)0);	// Ensure client is not yet connected
-		client.connect("127.0.0.1", 1883);
+		MqttClient client(&broker);
 		assertEqual(broker.clientsCount(), (size_t)1);	// Ensure client is now connected
 	}
 	assertEqual(broker.clientsCount(), (size_t)0);
@@ -68,8 +66,8 @@ test(local_publish_should_be_dispatched)
 	publisher.publish("a/c");
 
 	assertEqual(published.size(), (size_t)1);	// 1 client has received something
-	assertTrue(published[""]["a/b"] == 1);
+	assertEqual(published[""]["a/b"], 1);
-	assertTrue(published[""]["a/c"] == 2);
+	assertEqual(published[""]["a/c"], 2);
 }
 
 test(local_publish_should_be_dispatched_to_local_clients)
@@ -91,10 +89,10 @@ test(local_publish_should_be_dispatched_to_local_clients)
 	publisher.publish("a/c");
 
 	assertEqual(published.size(), (size_t)2);	// 2 clients have received something
-	assertTrue(published["A"]["a/b"] == 1);
+	assertEqual(published["A"]["a/b"], 1);
-	assertTrue(published["A"]["a/c"] == 1);
+	assertEqual(published["A"]["a/c"], 1);
-	assertTrue(published["B"]["a/b"] == 1);
+	assertEqual(published["B"]["a/b"], 1);
-	assertTrue(published["B"]["a/c"] == 0);
+	assertEqual(published["B"]["a/c"], 0);
 }
 
 test(local_unsubscribe)
@@ -114,7 +112,7 @@ test(local_unsubscribe)
 	publisher.publish("a/b");
 	publisher.publish("a/b");
 
-	assertTrue(published[""]["a/b"] == 1);	// Only one publish has been received
+	assertEqual(published[""]["a/b"], 1);	// Only one publish has been received
 }
 
 test(local_nocallback_when_destroyed)
@@ -143,7 +141,7 @@ void setup() {
 	Serial.begin(115200);
 	while(!Serial);
 
-	Serial.println("=============[ NO WIFI CONNECTION TinyMqtt TESTS ]========================");
+	Serial.println("=============[ LOCAL TinyMqtt TESTS              ]========================");
 }
 
 void loop() {

tests/network-tests/Makefile

@@ -0,0 +1,13 @@
+# See https://github.com/bxparks/EpoxyDuino for documentation about this
+# Makefile to compile and run Arduino programs natively on Linux or MacOS.
+
+EXTRA_CXXFLAGS=-g3 -O0
+
+# Remove flto flag from EpoxyDuino (too many <optimized out>)
+CXXFLAGS = -Wextra -Wall -std=gnu++11 -fno-exceptions -fno-threadsafe-statics
+
+APP_NAME := network-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/network-tests/network-tests.ino

@@ -0,0 +1,331 @@
+#include <Arduino.h>
+#include <AUnit.h>
+#include <TinyMqtt.h>
+#include <map>
+
+/**
+  * TinyMqtt network unit tests.
+	*
+	* No wifi connection unit tests.
+  * Checks with a local broker. Clients must connect to the local broker
+	**/
+
+using namespace std;
+
+String toString(const IPAddress& ip)
+{
+  return String(ip[0])+'.'+String(ip[1])+'.'+String(ip[2])+'.'+String(ip[3]);
+}
+
+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 start_servers(int n, bool early_accept = true)
+{
+    ESP8266WiFiClass::resetInstances();
+    ESP8266WiFiClass::earlyAccept = early_accept;
+    while(n)
+    {
+      ESP8266WiFiClass::selectInstance(n--);
+      WiFi.mode(WIFI_STA);
+      WiFi.begin("fake_ssid", "fake_pwd");
+    }
+}
+
+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(network_single_broker_begin)
+{
+  assertEqual(WiFi.status(), WL_CONNECTED);
+
+  MqttBroker broker(1883);
+  broker.begin();
+
+  // TODO Nothing is tested here !
+}
+
+test(suback)
+{
+  start_servers(2, true);
+  assertEqual(WiFi.status(), WL_CONNECTED);
+
+  MqttBroker broker(1883);
+  broker.begin();
+  IPAddress broker_ip = WiFi.localIP();
+
+  ESP8266WiFiClass::selectInstance(2);
+  MqttClient client;
+  client.connect(broker_ip.toString().c_str(), 1883);
+  broker.loop();
+
+  assertTrue(broker.clientsCount() == 1);
+  assertTrue(client.connected());
+
+  MqttClient::counters[MqttMessage::Type::SubAck] = 0;
+  client.subscribe("a/b");
+
+  // TODO how to avoid these loops ???
+  broker.loop();
+  client.loop();
+
+  assertEqual(MqttClient::counters[MqttMessage::Type::SubAck], 1);
+}
+
+test(network_client_to_broker_connexion)
+{
+  start_servers(2, true);
+  assertEqual(WiFi.status(), WL_CONNECTED);
+
+  MqttBroker broker(1883);
+  broker.begin();
+  IPAddress broker_ip = WiFi.localIP();
+
+  ESP8266WiFiClass::selectInstance(2);
+  MqttClient client;
+  client.connect(broker_ip.toString().c_str(), 1883);
+  broker.loop();
+
+  assertTrue(broker.clientsCount() == 1);
+  assertTrue(client.connected());
+}
+
+test(network_one_client_one_broker_publish_and_subscribe_through_network)
+{
+  start_servers(2, true);
+  published.clear();
+  assertEqual(WiFi.status(), WL_CONNECTED);
+
+  MqttBroker broker(1883);
+  broker.begin();
+  IPAddress ip_broker = WiFi.localIP();
+
+  // We have a 2nd ESP in order to test through wifi (opposed to local)
+  ESP8266WiFiClass::selectInstance(2);
+  MqttClient client;
+  client.connect(ip_broker.toString().c_str(), 1883);
+  broker.loop();
+  assertTrue(client.connected());
+
+  client.setCallback(onPublish);
+  client.subscribe("a/b");
+  client.publish("a/b", "ab");
+
+  for (int i =0; i<2; i++)
+  {
+    client.loop();
+    broker.loop();
+  }
+  
+  assertEqual(published.size(), (size_t)1);
+  assertEqual((int)lastLength, (int)2); // sizeof(ab)
+}
+
+test(network_one_client_one_broker_hudge_publish_and_subscribe_through_network)
+{
+  start_servers(2, true);
+  published.clear();
+  assertEqual(WiFi.status(), WL_CONNECTED);
+
+  MqttBroker broker(1883);
+  broker.begin();
+  IPAddress ip_broker = WiFi.localIP();
+
+  // We have a 2nd ESP in order to test through wifi (opposed to local)
+  ESP8266WiFiClass::selectInstance(2);
+  MqttClient client;
+  client.connect(ip_broker.toString().c_str(), 1883);
+  broker.loop();
+  assertTrue(client.connected());
+
+  std::string sent;
+
+  for(int i=0; i<200; i++)
+    sent += char('0'+i%10);
+
+  client.setCallback(onPublish);
+  client.subscribe("a/b");
+  client.publish("a/b", sent.c_str());
+
+  for (int i =0; i<2; i++)
+  {
+    client.loop();
+    broker.loop();
+  }
+
+  assertEqual(published.size(), (size_t)1);
+  assertEqual((unsigned int)lastLength, (unsigned int)sent.size());
+}
+
+test(network_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);
+}
+
+
+// THESE TESTS ARE IN LOCAL MODE
+// WE HAVE TO CONVERT THEM TO WIFI MODE (pass through virtual TCP link)
+
+test(network_connect)
+{
+	assertEqual(broker.clientsCount(), (size_t)0);
+
+	MqttClient client(&broker);
+	assertTrue(client.connected());
+	assertEqual(broker.clientsCount(), (size_t)1);
+}
+
+test(network_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(network_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(network_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(network_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(network_small_payload)
+{
+	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);
+}
+
+test(network_hudge_payload)
+{
+  const char* payload="This payload is hudge, just because its length exceeds 127. Thus when encoding length, we have to encode it on two bytes at min. This should not prevent the message from being encoded and decoded successfully !";
+
+  MqttClient subscriber(&broker);
+  subscriber.setCallback(onPublish);
+  subscriber.subscribe("a/b");
+
+	MqttClient publisher(&broker);
+	publisher.publish("a/b", payload);		// This publish is received
+
+  // onPublish should have filled lastPayload and lastLength
+  assertEqual(payload, lastPayload);
+	assertEqual(lastLength, strlen(payload));
+	assertEqual(strcmp(payload, lastPayload), 0);
+}
+
+//----------------------------------------------------------------------------
+// setup() and loop()
+void setup() {
+	/* delay(1000);
+	Serial.begin(115200);
+	while(!Serial);
+	*/
+
+	Serial.println("=============[ FAKE NETWORK TinyMqtt TESTS       ]========================");
+
+	WiFi.mode(WIFI_STA);
+	WiFi.begin("network", "password");
+}
+
+void loop() {
+	aunit::TestRunner::run();
+
+	if (Serial.available()) ESP.reset();
+}