mgillespie/TinyMqtt
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Replaced tabs by spaces

Browse Source
This commit is contained in:
Francois BIOT
2022-12-03 20:47:02 +01:00
parent 5a3e9bd90e
commit 744a590467
9 changed files with 1049 additions and 1045 deletions
Download Patch File Download Diff File Expand all files Collapse all files

37
tests/length-tests.todo/length-tests.ino
View File

@@ -1,53 +1,54 @@
// vim: ts=2 sw=2 expandtab
#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
**/
* 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
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]++;
if (srce)
published[srce->id()][topic]++;
lastPayload = payload;
lastLength = length;
lastLength = length;
}
test(length_decode_greater_than_127)
{
// TODO WRITE THIS TEST
// The test should verify than a mqtt message with more than 127 bytes is correctly decoded
assertEqual(1,2);
assertEqual(1,2);
}
//----------------------------------------------------------------------------
// setup() and loop()
void setup() {
delay(1000);
Serial.begin(115200);
while(!Serial);
delay(1000);
Serial.begin(115200);
while(!Serial);
Serial.println("=============[ NO WIFI CONNECTION TinyMqtt TESTS ]========================");
Serial.println("=============[ NO WIFI CONNECTION TinyMqtt TESTS ]========================");
}
void loop() {
aunit::TestRunner::run();
aunit::TestRunner::run();
if (Serial.available()) ESP.reset();
if (Serial.available()) ESP.reset();
}

185
tests/network-tests/network-tests.ino
View File

@@ -1,3 +1,4 @@
// vim: ts=2 sw=2 expandtab
#include <Arduino.h>
#include <AUnit.h>
#include <TinyMqtt.h>
@@ -10,10 +11,10 @@
/**
* TinyMqtt network unit tests.
*
* No wifi connection unit tests.
*
* No wifi connection unit tests.
* Checks with a local broker. Clients must connect to the local broker
**/
**/
// if ascii_pos = 0, no ascii dump, else ascii dump starts after column ascii_pos
std::string bufferToHexa(const uint8_t* buffer, size_t length, char sep = 0, size_t ascii_pos = 0)
@@ -77,7 +78,7 @@ String toString(const IPAddress& ip)
MqttBroker broker(1883);
std::map<std::string, std::map<Topic, int>> published; // map[client_id] => map[topic] = count
std::map<std::string, std::map<Topic, int>> published; // map[client_id] => map[topic] = count
char* lastPayload = nullptr;
size_t lastLength;
@@ -96,12 +97,12 @@ void start_servers(int n, bool early_accept = true)
void onPublish(const MqttClient* srce, const Topic& topic, const char* payload, size_t length)
{
if (srce)
published[srce->id()][topic]++;
if (lastPayload) free(lastPayload);
if (srce)
published[srce->id()][topic]++;
if (lastPayload) free(lastPayload);
lastPayload = strdup(payload);
lastLength = length;
lastLength = length;
}
test(network_single_broker_begin)
@@ -263,12 +264,12 @@ test(network_one_client_one_broker_hudge_publish_and_subscribe_through_network)
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);
assertEqual(broker.clientsCount(), (size_t)0);
{
MqttClient client(&broker);
assertEqual(broker.clientsCount(), (size_t)1);
}
assertEqual(broker.clientsCount(), (size_t)0);
}
@@ -277,113 +278,113 @@ test(network_client_should_unregister_when_destroyed)
test(network_connect)
{
assertEqual(broker.clientsCount(), (size_t)0);
assertEqual(broker.clientsCount(), (size_t)0);
MqttClient client(&broker);
assertTrue(client.connected());
assertEqual(broker.clientsCount(), (size_t)1);
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);
published.clear();
assertEqual(broker.clientsCount(), (size_t)0);
MqttClient subscriber(&broker);
subscriber.subscribe("a/b");
subscriber.subscribe("a/c");
subscriber.setCallback(onPublish);
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");
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);
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);
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_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 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
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);
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);
published.clear();
assertEqual(broker.clientsCount(), (size_t)0);
MqttClient subscriber(&broker);
subscriber.setCallback(onPublish);
subscriber.subscribe("a/b");
MqttClient subscriber(&broker);
subscriber.setCallback(onPublish);
subscriber.subscribe("a/b");
MqttClient publisher(&broker);
publisher.publish("a/b"); // This publish is received
MqttClient publisher(&broker);
publisher.publish("a/b"); // This publish is received
subscriber.unsubscribe("a/b");
subscriber.unsubscribe("a/b");
publisher.publish("a/b"); // Those one, no (unsubscribed)
publisher.publish("a/b");
publisher.publish("a/b"); // Those one, no (unsubscribed)
publisher.publish("a/b");
assertEqual(published[""]["a/b"], 1); // Only one publish has been received
assertEqual(published[""]["a/b"], 1); // Only one publish has been received
}
test(network_nocallback_when_destroyed)
{
published.clear();
assertEqual(broker.clientsCount(), (size_t)0);
published.clear();
assertEqual(broker.clientsCount(), (size_t)0);
MqttClient publisher(&broker);
MqttClient publisher(&broker);
{
MqttClient subscriber(&broker);
subscriber.setCallback(onPublish);
subscriber.subscribe("a/b");
publisher.publish("a/b");
}
{
MqttClient subscriber(&broker);
subscriber.setCallback(onPublish);
subscriber.subscribe("a/b");
publisher.publish("a/b");
}
publisher.publish("a/b");
publisher.publish("a/b");
assertEqual(published.size(), (size_t)1); // Only one publish has been received
assertEqual(published.size(), (size_t)1); // Only one publish has been received
}
test(network_small_payload)
{
published.clear();
published.clear();
const char* payload="abcd";
const char* payload="abcd";
MqttClient subscriber(&broker);
subscriber.setCallback(onPublish);
subscriber.subscribe("a/b");
MqttClient subscriber(&broker);
subscriber.setCallback(onPublish);
subscriber.subscribe("a/b");
MqttClient publisher(&broker);
publisher.publish("a/b", payload, strlen(payload)); // This publish is received
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);
assertEqual(lastLength, (size_t)4);
}
test(network_hudge_payload)
@@ -394,13 +395,13 @@ test(network_hudge_payload)
subscriber.setCallback(onPublish);
subscriber.subscribe("a/b"); // Note -> this does not send any byte .... (nowhere to send)
MqttClient publisher(&broker);
publisher.publish("a/b", payload); // This publish is received
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);
assertEqual(lastLength, strlen(payload));
assertEqual(strcmp(payload, lastPayload), 0);
}
test(connack)
@@ -447,19 +448,19 @@ test(connack)
//----------------------------------------------------------------------------
// setup() and loop()
void setup() {
/* delay(1000);
Serial.begin(115200);
while(!Serial);
*/
/* delay(1000);
Serial.begin(115200);
while(!Serial);
*/
Serial.println("=============[ FAKE NETWORK TinyMqtt TESTS ]========================");
Serial.println("=============[ FAKE NETWORK TinyMqtt TESTS ]========================");
WiFi.mode(WIFI_STA);
WiFi.begin("network", "password");
WiFi.mode(WIFI_STA);
WiFi.begin("network", "password");
}
void loop() {
aunit::TestRunner::run();
aunit::TestRunner::run();
if (Serial.available()) ESP.reset();
if (Serial.available()) ESP.reset();
}

301
tests/nowifi-tests/nowifi-tests.ino
View File

@@ -1,3 +1,4 @@
// vim: ts=2 sw=2 expandtab
#include <Arduino.h>
#include <AUnit.h>
#include <TinyMqtt.h>
@@ -5,247 +6,247 @@
/**
* TinyMqtt nowifi unit tests.
*
* No wifi connection unit tests.
*
* No wifi connection unit tests.
* Checks with a local broker. Clients must connect to the local broker
**/
**/
using namespace std;
MqttBroker broker(1883);
std::map<std::string, std::map<Topic, int>> published; // map[client_id] => map[topic] = count
std::map<std::string, std::map<Topic, int>> published; // map[client_id] => map[topic] = count
char* lastPayload = nullptr;
size_t lastLength;
void onPublish(const MqttClient* srce, const Topic& topic, const char* payload, size_t length)
{
if (srce)
published[srce->id()][topic]++;
if (lastPayload) free(lastPayload);
if (srce)
published[srce->id()][topic]++;
if (lastPayload) free(lastPayload);
lastPayload = strdup(payload);
lastLength = length;
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);
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);
assertEqual(broker.clientsCount(), (size_t)0);
MqttClient client(&broker);
assertTrue(client.connected());
assertEqual(broker.clientsCount(), (size_t)1);
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);
published.clear();
assertEqual(broker.clientsCount(), (size_t)0);
MqttClient subscriber(&broker);
subscriber.subscribe("a/b");
subscriber.subscribe("a/c");
subscriber.setCallback(onPublish);
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");
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);
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);
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_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 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
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);
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_subscribe_with_star_wildcard)
{
published.clear();
assertEqual(broker.clientsCount(), (size_t)0);
published.clear();
assertEqual(broker.clientsCount(), (size_t)0);
MqttClient subscriber(&broker, "A");
subscriber.setCallback(onPublish);
subscriber.subscribe("house/*/temp");
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");
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);
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);
published.clear();
assertEqual(broker.clientsCount(), (size_t)0);
MqttClient subscriber(&broker, "A");
subscriber.setCallback(onPublish);
subscriber.subscribe("house/+/temp");
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");
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);
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);
published.clear();
assertEqual(broker.clientsCount(), (size_t)0);
MqttClient subscriber(&broker, "A");
subscriber.setCallback(onPublish);
subscriber.subscribe("+/data");
MqttClient subscriber(&broker, "A");
subscriber.setCallback(onPublish);
subscriber.subscribe("+/data");
MqttClient publisher(&broker);
publisher.publish("$SYS/data");
MqttClient publisher(&broker);
publisher.publish("$SYS/data");
assertEqual(published["A"]["$SYS/data"], 0);
assertEqual(published["A"]["$SYS/data"], 0);
}
test(nowifi_subscribe_with_mixed_wildcards)
{
published.clear();
assertEqual(broker.clientsCount(), (size_t)0);
published.clear();
assertEqual(broker.clientsCount(), (size_t)0);
MqttClient subscriber(&broker, "A");
subscriber.setCallback(onPublish);
subscriber.subscribe("+/data/#");
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");
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);
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);
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 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");
MqttClient publisher(&broker);
publisher.publish("one/two/three");
publisher.publish("one/two/four");
subscriber.unsubscribe("one/two/+");
publisher.publish("one/two/five");
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);
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();
assertEqual(broker.clientsCount(), (size_t)0);
published.clear();
assertEqual(broker.clientsCount(), (size_t)0);
MqttClient subscriber(&broker);
subscriber.setCallback(onPublish);
subscriber.subscribe("a/b");
MqttClient subscriber(&broker);
subscriber.setCallback(onPublish);
subscriber.subscribe("a/b");
MqttClient publisher(&broker);
publisher.publish("a/b"); // This publish is received
MqttClient publisher(&broker);
publisher.publish("a/b"); // This publish is received
subscriber.unsubscribe("a/b");
subscriber.unsubscribe("a/b");
publisher.publish("a/b"); // Those one, no (unsubscribed)
publisher.publish("a/b");
publisher.publish("a/b"); // Those one, no (unsubscribed)
publisher.publish("a/b");
assertEqual(published[""]["a/b"], 1); // Only one publish has been received
assertEqual(published[""]["a/b"], 1); // Only one publish has been received
}
test(nowifi_nocallback_when_destroyed)
{
published.clear();
assertEqual(broker.clientsCount(), (size_t)0);
published.clear();
assertEqual(broker.clientsCount(), (size_t)0);
MqttClient publisher(&broker);
MqttClient publisher(&broker);
{
MqttClient subscriber(&broker);
subscriber.setCallback(onPublish);
subscriber.subscribe("a/b");
publisher.publish("a/b");
}
{
MqttClient subscriber(&broker);
subscriber.setCallback(onPublish);
subscriber.subscribe("a/b");
publisher.publish("a/b");
}
publisher.publish("a/b");
publisher.publish("a/b");
assertEqual(published.size(), (size_t)1); // Only one publish has been received
assertEqual(published.size(), (size_t)1); // Only one publish has been received
}
test(nowifi_small_payload)
{
published.clear();
published.clear();
const char* payload="abcd";
const char* payload="abcd";
MqttClient subscriber(&broker);
subscriber.setCallback(onPublish);
subscriber.subscribe("a/b");
MqttClient subscriber(&broker);
subscriber.setCallback(onPublish);
subscriber.subscribe("a/b");
MqttClient publisher(&broker);
publisher.publish("a/b", payload, strlen(payload)); // This publish is received
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);
assertEqual(lastLength, (size_t)4);
}
test(nowifi_hudge_payload)
@@ -256,26 +257,26 @@ test(nowifi_hudge_payload)
subscriber.setCallback(onPublish);
subscriber.subscribe("a/b");
MqttClient publisher(&broker);
publisher.publish("a/b", payload); // This publish is received
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(lastLength, strlen(payload));
}
//----------------------------------------------------------------------------
// 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 ]========================");
Serial.println("=============[ NO WIFI CONNECTION TinyMqtt TESTS ]========================");
}
void loop() {
aunit::TestRunner::run();
aunit::TestRunner::run();
if (Serial.available()) ESP.reset();
if (Serial.available()) ESP.reset();
}

83
tests/string-indexer-tests/string-indexer-tests.ino
View File

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

19
tests/topic-tests/topic-tests.ino
View File

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