Initial contribution.

test/lib/cpp/01-con-discon-success.cpp

@@ -0,0 +1,53 @@
+//#include <stdbool.h>
+//#include <cstdio>
+//#include <stdlib.h>
+#include <mosquittopp.h>
+
+static int run = -1;
+
+class mosquittopp_test : public mosqpp::mosquittopp
+{
+	public:
+		mosquittopp_test(const char *id);
+
+		void on_connect(int rc);
+		void on_disconnect(int rc);
+};
+
+mosquittopp_test::mosquittopp_test(const char *id) : mosqpp::mosquittopp(id)
+{
+}
+
+void mosquittopp_test::on_connect(int rc)
+{
+	if(rc){
+		exit(1);
+	}else{
+		disconnect();
+	}
+}
+
+void mosquittopp_test::on_disconnect(int rc)
+{
+	run = rc;
+}
+
+
+int main(int argc, char *argv[])
+{
+	struct mosquittopp_test *mosq;
+
+	mosqpp::lib_init();
+
+	mosq = new mosquittopp_test("01-con-discon-success");
+
+	mosq->connect("localhost", 1888, 60);
+
+	while(run == -1){
+		mosq->loop();
+	}
+
+	mosqpp::lib_cleanup();
+
+	return run;
+}

test/lib/cpp/01-keepalive-pingreq.cpp

@@ -0,0 +1,41 @@
+#include <mosquittopp.h>
+
+static int run = -1;
+
+class mosquittopp_test : public mosqpp::mosquittopp
+{
+	public:
+		mosquittopp_test(const char *id);
+
+		void on_connect(int rc);
+};
+
+mosquittopp_test::mosquittopp_test(const char *id) : mosqpp::mosquittopp(id)
+{
+}
+
+void mosquittopp_test::on_connect(int rc)
+{
+	if(rc){
+		exit(1);
+	}
+}
+
+int main(int argc, char *argv[])
+{
+	struct mosquittopp_test *mosq;
+
+	mosqpp::lib_init();
+
+	mosq = new mosquittopp_test("01-keepalive-pingreq");
+
+	mosq->connect("localhost", 1888, 4);
+
+	while(run == -1){
+		mosq->loop();
+	}
+
+	mosqpp::lib_cleanup();
+
+	return run;
+}

test/lib/cpp/01-no-clean-session.cpp

@@ -0,0 +1,33 @@
+#include <cstring>
+#include <mosquittopp.h>
+
+static int run = -1;
+
+class mosquittopp_test : public mosqpp::mosquittopp
+{
+	public:
+		mosquittopp_test(const char *id, bool clean_session);
+};
+
+mosquittopp_test::mosquittopp_test(const char *id, bool clean_session) : mosqpp::mosquittopp(id, clean_session)
+{
+}
+
+int main(int argc, char *argv[])
+{
+	struct mosquittopp_test *mosq;
+
+	mosqpp::lib_init();
+
+	mosq = new mosquittopp_test("01-no-clean-session", false);
+
+	mosq->connect("localhost", 1888, 60);
+
+	while(run == -1){
+		mosq->loop();
+	}
+
+	mosqpp::lib_cleanup();
+
+	return run;
+}

test/lib/cpp/01-unpwd-set.cpp

@@ -0,0 +1,34 @@
+#include <cstring>
+#include <mosquittopp.h>
+
+static int run = -1;
+
+class mosquittopp_test : public mosqpp::mosquittopp
+{
+	public:
+		mosquittopp_test(const char *id);
+};
+
+mosquittopp_test::mosquittopp_test(const char *id) : mosqpp::mosquittopp(id)
+{
+}
+
+int main(int argc, char *argv[])
+{
+	struct mosquittopp_test *mosq;
+
+	mosqpp::lib_init();
+
+	mosq = new mosquittopp_test("01-unpwd-set");
+	mosq->username_pw_set("uname", ";'[08gn=#");
+
+	mosq->connect("localhost", 1888, 60);
+
+	while(run == -1){
+		mosq->loop();
+	}
+
+	mosqpp::lib_cleanup();
+
+	return run;
+}

test/lib/cpp/01-will-set.cpp

@@ -0,0 +1,37 @@
+//#include <stdbool.h>
+//#include <cstdio>
+//#include <stdlib.h>
+#include <cstring>
+#include <mosquittopp.h>
+
+static int run = -1;
+
+class mosquittopp_test : public mosqpp::mosquittopp
+{
+	public:
+		mosquittopp_test(const char *id);
+};
+
+mosquittopp_test::mosquittopp_test(const char *id) : mosqpp::mosquittopp(id)
+{
+}
+
+int main(int argc, char *argv[])
+{
+	struct mosquittopp_test *mosq;
+
+	mosqpp::lib_init();
+
+	mosq = new mosquittopp_test("01-will-set");
+	mosq->will_set("topic/on/unexpected/disconnect", strlen("will message"), "will message", 1, true);
+
+	mosq->connect("localhost", 1888, 60);
+
+	while(run == -1){
+		mosq->loop();
+	}
+
+	mosqpp::lib_cleanup();
+
+	return run;
+}

test/lib/cpp/01-will-unpwd-set.cpp

@@ -0,0 +1,35 @@
+#include <cstring>
+#include <mosquittopp.h>
+
+static int run = -1;
+
+class mosquittopp_test : public mosqpp::mosquittopp
+{
+	public:
+		mosquittopp_test(const char *id);
+};
+
+mosquittopp_test::mosquittopp_test(const char *id) : mosqpp::mosquittopp(id)
+{
+}
+
+int main(int argc, char *argv[])
+{
+	struct mosquittopp_test *mosq;
+
+	mosqpp::lib_init();
+
+	mosq = new mosquittopp_test("01-will-unpwd-set");
+	mosq->username_pw_set("oibvvwqw", "#'^2hg9a&nm38*us");
+	mosq->will_set("will-topic", strlen("will message"), "will message", 2, false);
+
+	mosq->connect("localhost", 1888, 60);
+
+	while(run == -1){
+		mosq->loop();
+	}
+
+	mosqpp::lib_cleanup();
+
+	return run;
+}

test/lib/cpp/02-subscribe-qos0.cpp

@@ -0,0 +1,55 @@
+#include <mosquittopp.h>
+
+static int run = -1;
+
+class mosquittopp_test : public mosqpp::mosquittopp
+{
+	public:
+		mosquittopp_test(const char *id);
+
+		void on_connect(int rc);
+		void on_disconnect(int rc);
+		void on_subscribe(int mid, int qos_count, const int *granted_qos);
+};
+
+mosquittopp_test::mosquittopp_test(const char *id) : mosqpp::mosquittopp(id)
+{
+}
+
+void mosquittopp_test::on_connect(int rc)
+{
+	if(rc){
+		exit(1);
+	}else{
+		subscribe(NULL, "qos0/test", 0);
+	}
+}
+
+void mosquittopp_test::on_disconnect(int rc)
+{
+	run = rc;
+}
+
+void mosquittopp_test::on_subscribe(int mid, int qos_count, const int *granted_qos)
+{
+	disconnect();
+}
+
+int main(int argc, char *argv[])
+{
+	struct mosquittopp_test *mosq;
+
+	mosqpp::lib_init();
+
+	mosq = new mosquittopp_test("subscribe-qos0-test");
+
+	mosq->connect("localhost", 1888, 60);
+
+	while(run == -1){
+		mosq->loop();
+	}
+
+	mosqpp::lib_cleanup();
+
+	return run;
+}

test/lib/cpp/02-subscribe-qos1.cpp

@@ -0,0 +1,56 @@
+#include <mosquittopp.h>
+
+static int run = -1;
+
+class mosquittopp_test : public mosqpp::mosquittopp
+{
+	public:
+		mosquittopp_test(const char *id);
+
+		void on_connect(int rc);
+		void on_disconnect(int rc);
+		void on_subscribe(int mid, int qos_count, const int *granted_qos);
+};
+
+mosquittopp_test::mosquittopp_test(const char *id) : mosqpp::mosquittopp(id)
+{
+}
+
+void mosquittopp_test::on_connect(int rc)
+{
+	if(rc){
+		exit(1);
+	}else{
+		subscribe(NULL, "qos1/test", 1);
+	}
+}
+
+void mosquittopp_test::on_disconnect(int rc)
+{
+	run = rc;
+}
+
+void mosquittopp_test::on_subscribe(int mid, int qos_count, const int *granted_qos)
+{
+	disconnect();
+}
+
+
+int main(int argc, char *argv[])
+{
+	struct mosquittopp_test *mosq;
+
+	mosqpp::lib_init();
+
+	mosq = new mosquittopp_test("subscribe-qos1-test");
+
+	mosq->connect("localhost", 1888, 60);
+
+	while(run == -1){
+		mosq->loop();
+	}
+
+	mosqpp::lib_cleanup();
+
+	return run;
+}

test/lib/cpp/02-subscribe-qos2.cpp

@@ -0,0 +1,56 @@
+#include <mosquittopp.h>
+
+static int run = -1;
+
+class mosquittopp_test : public mosqpp::mosquittopp
+{
+	public:
+		mosquittopp_test(const char *id);
+
+		void on_connect(int rc);
+		void on_disconnect(int rc);
+		void on_subscribe(int mid, int qos_count, const int *granted_qos);
+};
+
+mosquittopp_test::mosquittopp_test(const char *id) : mosqpp::mosquittopp(id)
+{
+}
+
+void mosquittopp_test::on_connect(int rc)
+{
+	if(rc){
+		exit(1);
+	}else{
+		subscribe(NULL, "qos2/test", 2);
+	}
+}
+
+void mosquittopp_test::on_disconnect(int rc)
+{
+	run = rc;
+}
+
+void mosquittopp_test::on_subscribe(int mid, int qos_count, const int *granted_qos)
+{
+	disconnect();
+}
+
+
+int main(int argc, char *argv[])
+{
+	struct mosquittopp_test *mosq;
+
+	mosqpp::lib_init();
+
+	mosq = new mosquittopp_test("subscribe-qos2-test");
+
+	mosq->connect("localhost", 1888, 60);
+
+	while(run == -1){
+		mosq->loop();
+	}
+
+	mosqpp::lib_cleanup();
+
+	return run;
+}

test/lib/cpp/02-unsubscribe.cpp

@@ -0,0 +1,55 @@
+#include <mosquittopp.h>
+
+static int run = -1;
+
+class mosquittopp_test : public mosqpp::mosquittopp
+{
+	public:
+		mosquittopp_test(const char *id);
+
+		void on_connect(int rc);
+		void on_disconnect(int rc);
+		void on_unsubscribe(int mid);
+};
+
+mosquittopp_test::mosquittopp_test(const char *id) : mosqpp::mosquittopp(id)
+{
+}
+
+void mosquittopp_test::on_connect(int rc)
+{
+	if(rc){
+		exit(1);
+	}else{
+		unsubscribe(NULL, "unsubscribe/test");
+	}
+}
+
+void mosquittopp_test::on_disconnect(int rc)
+{
+	run = rc;
+}
+
+void mosquittopp_test::on_unsubscribe(int mid)
+{
+	disconnect();
+}
+
+int main(int argc, char *argv[])
+{
+	struct mosquittopp_test *mosq;
+
+	mosqpp::lib_init();
+
+	mosq = new mosquittopp_test("unsubscribe-test");
+
+	mosq->connect("localhost", 1888, 60);
+
+	while(run == -1){
+		mosq->loop();
+	}
+
+	mosqpp::lib_cleanup();
+
+	return run;
+}

test/lib/cpp/03-publish-b2c-qos1.cpp

@@ -0,0 +1,76 @@
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+
+#include <mosquittopp.h>
+
+class mosquittopp_test : public mosqpp::mosquittopp
+{
+	public:
+		mosquittopp_test(const char *id);
+
+		void on_connect(int rc);
+		void on_message(const struct mosquitto_message *msg);
+};
+
+mosquittopp_test::mosquittopp_test(const char *id) : mosqpp::mosquittopp(id)
+{
+}
+
+void mosquittopp_test::on_connect(int rc)
+{
+	if(rc){
+		exit(1);
+	}
+}
+
+void mosquittopp_test::on_message(const struct mosquitto_message *msg)
+{
+	if(msg->mid != 123){
+		printf("Invalid mid (%d)\n", msg->mid);
+		exit(1);
+	}
+	if(msg->qos != 1){
+		printf("Invalid qos (%d)\n", msg->qos);
+		exit(1);
+	}
+	if(strcmp(msg->topic, "pub/qos1/receive")){
+		printf("Invalid topic (%s)\n", msg->topic);
+		exit(1);
+	}
+	if(strcmp((char *)msg->payload, "message")){
+		printf("Invalid payload (%s)\n", (char *)msg->payload);
+		exit(1);
+	}
+	if(msg->payloadlen != 7){
+		printf("Invalid payloadlen (%d)\n", msg->payloadlen);
+		exit(1);
+	}
+	if(msg->retain != false){
+		printf("Invalid retain (%d)\n", msg->retain);
+		exit(1);
+	}
+
+	exit(0);
+}
+
+int main(int argc, char *argv[])
+{
+	struct mosquittopp_test *mosq;
+
+	mosqpp::lib_init();
+
+	mosq = new mosquittopp_test("publish-qos1-test");
+	mosq->message_retry_set(3);
+
+	mosq->connect("localhost", 1888, 60);
+
+	while(1){
+		mosq->loop();
+	}
+
+	mosqpp::lib_cleanup();
+
+	return 1;
+}
+

test/lib/cpp/03-publish-b2c-qos2.cpp

@@ -0,0 +1,78 @@
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+
+#include <mosquittopp.h>
+
+static int run = -1;
+
+class mosquittopp_test : public mosqpp::mosquittopp
+{
+	public:
+		mosquittopp_test(const char *id);
+
+		void on_connect(int rc);
+		void on_message(const struct mosquitto_message *msg);
+};
+
+mosquittopp_test::mosquittopp_test(const char *id) : mosqpp::mosquittopp(id)
+{
+}
+
+void mosquittopp_test::on_connect(int rc)
+{
+	if(rc){
+		exit(1);
+	}
+}
+
+void mosquittopp_test::on_message(const struct mosquitto_message *msg)
+{
+	if(msg->mid != 13423){
+		printf("Invalid mid (%d)\n", msg->mid);
+		exit(1);
+	}
+	if(msg->qos != 2){
+		printf("Invalid qos (%d)\n", msg->qos);
+		exit(1);
+	}
+	if(strcmp(msg->topic, "pub/qos2/receive")){
+		printf("Invalid topic (%s)\n", msg->topic);
+		exit(1);
+	}
+	if(strcmp((char *)msg->payload, "message")){
+		printf("Invalid payload (%s)\n", (char *)msg->payload);
+		exit(1);
+	}
+	if(msg->payloadlen != 7){
+		printf("Invalid payloadlen (%d)\n", msg->payloadlen);
+		exit(1);
+	}
+	if(msg->retain != false){
+		printf("Invalid retain (%d)\n", msg->retain);
+		exit(1);
+	}
+
+	run = 0;
+}
+
+int main(int argc, char *argv[])
+{
+	struct mosquittopp_test *mosq;
+
+	mosqpp::lib_init();
+
+	mosq = new mosquittopp_test("publish-qos2-test");
+	mosq->message_retry_set(3);
+
+	mosq->connect("localhost", 1888, 60);
+
+	while(run == -1){
+		mosq->loop();
+	}
+
+	mosqpp::lib_cleanup();
+
+	return run;
+}
+

test/lib/cpp/03-publish-c2b-qos1-disconnect.cpp

@@ -0,0 +1,68 @@
+#include <cstdlib>
+#include <cstring>
+
+#include <mosquittopp.h>
+
+static int run = -1;
+static int first_connection = 1;
+
+class mosquittopp_test : public mosqpp::mosquittopp
+{
+	public:
+		mosquittopp_test(const char *id);
+
+		void on_connect(int rc);
+		void on_disconnect(int rc);
+		void on_publish(int mid);
+};
+
+mosquittopp_test::mosquittopp_test(const char *id) : mosqpp::mosquittopp(id)
+{
+}
+
+void mosquittopp_test::on_connect(int rc)
+{
+	if(rc){
+		exit(1);
+	}else{
+		if(first_connection == 1){
+			publish(NULL, "pub/qos1/test", strlen("message"), "message", 1, false);
+			first_connection = 0;
+		}
+	}
+}
+
+void mosquittopp_test::on_disconnect(int rc)
+{
+	if(rc){
+		reconnect();
+	}else{
+		run = 0;
+	}
+}
+
+void mosquittopp_test::on_publish(int mid)
+{
+	disconnect();
+}
+
+int main(int argc, char *argv[])
+{
+	struct mosquittopp_test *mosq;
+
+	mosqpp::lib_init();
+
+	mosq = new mosquittopp_test("publish-qos1-test");
+	mosq->message_retry_set(3);
+
+	mosq->connect("localhost", 1888, 60);
+
+	while(run == -1){
+		mosq->loop();
+	}
+
+	mosqpp::lib_cleanup();
+
+	return run;
+}
+

test/lib/cpp/03-publish-c2b-qos1-timeout.cpp

@@ -0,0 +1,60 @@
+#include <cstdlib>
+#include <cstring>
+
+#include <mosquittopp.h>
+
+static int run = -1;
+
+class mosquittopp_test : public mosqpp::mosquittopp
+{
+	public:
+		mosquittopp_test(const char *id);
+
+		void on_connect(int rc);
+		void on_disconnect(int rc);
+		void on_publish(int mid);
+};
+
+mosquittopp_test::mosquittopp_test(const char *id) : mosqpp::mosquittopp(id)
+{
+}
+
+void mosquittopp_test::on_connect(int rc)
+{
+	if(rc){
+		exit(1);
+	}else{
+		publish(NULL, "pub/qos1/test", strlen("message"), "message", 1, false);
+	}
+}
+
+void mosquittopp_test::on_disconnect(int rc)
+{
+	run = 0;
+}
+
+void mosquittopp_test::on_publish(int mid)
+{
+	disconnect();
+}
+
+int main(int argc, char *argv[])
+{
+	struct mosquittopp_test *mosq;
+
+	mosqpp::lib_init();
+
+	mosq = new mosquittopp_test("publish-qos1-test");
+	mosq->message_retry_set(3);
+
+	mosq->connect("localhost", 1888, 60);
+
+	while(run == -1){
+		mosq->loop();
+	}
+
+	mosqpp::lib_cleanup();
+
+	return run;
+}
+

test/lib/cpp/03-publish-c2b-qos2-disconnect.cpp

@@ -0,0 +1,68 @@
+#include <cstdlib>
+#include <cstring>
+
+#include <mosquittopp.h>
+
+static int run = -1;
+static int first_connection = 1;
+
+class mosquittopp_test : public mosqpp::mosquittopp
+{
+	public:
+		mosquittopp_test(const char *id);
+
+		void on_connect(int rc);
+		void on_disconnect(int rc);
+		void on_publish(int mid);
+};
+
+mosquittopp_test::mosquittopp_test(const char *id) : mosqpp::mosquittopp(id)
+{
+}
+
+void mosquittopp_test::on_connect(int rc)
+{
+	if(rc){
+		exit(1);
+	}else{
+		if(first_connection == 1){
+			publish(NULL, "pub/qos2/test", strlen("message"), "message", 2, false);
+			first_connection = 0;
+		}
+	}
+}
+
+void mosquittopp_test::on_disconnect(int rc)
+{
+	if(rc){
+		reconnect();
+	}else{
+		run = 0;
+	}
+}
+
+void mosquittopp_test::on_publish(int mid)
+{
+	disconnect();
+}
+
+int main(int argc, char *argv[])
+{
+	struct mosquittopp_test *mosq;
+
+	mosqpp::lib_init();
+
+	mosq = new mosquittopp_test("publish-qos2-test");
+	mosq->message_retry_set(3);
+
+	mosq->connect("localhost", 1888, 60);
+
+	while(run == -1){
+		mosq->loop();
+	}
+
+	mosqpp::lib_cleanup();
+
+	return run;
+}
+

test/lib/cpp/03-publish-c2b-qos2-timeout.cpp

@@ -0,0 +1,60 @@
+#include <cstdlib>
+#include <cstring>
+
+#include <mosquittopp.h>
+
+static int run = -1;
+
+class mosquittopp_test : public mosqpp::mosquittopp
+{
+	public:
+		mosquittopp_test(const char *id);
+
+		void on_connect(int rc);
+		void on_disconnect(int rc);
+		void on_publish(int mid);
+};
+
+mosquittopp_test::mosquittopp_test(const char *id) : mosqpp::mosquittopp(id)
+{
+}
+
+void mosquittopp_test::on_connect(int rc)
+{
+	if(rc){
+		exit(1);
+	}else{
+		publish(NULL, "pub/qos2/test", strlen("message"), "message", 2, false);
+	}
+}
+
+void mosquittopp_test::on_disconnect(int rc)
+{
+	run = 0;
+}
+
+void mosquittopp_test::on_publish(int mid)
+{
+	disconnect();
+}
+
+int main(int argc, char *argv[])
+{
+	struct mosquittopp_test *mosq;
+
+	mosqpp::lib_init();
+
+	mosq = new mosquittopp_test("publish-qos2-test");
+	mosq->message_retry_set(3);
+
+	mosq->connect("localhost", 1888, 60);
+
+	while(run == -1){
+		mosq->loop();
+	}
+
+	mosqpp::lib_cleanup();
+
+	return run;
+}
+

test/lib/cpp/03-publish-c2b-qos2.cpp

@@ -0,0 +1,59 @@
+#include <cstdlib>
+#include <cstring>
+
+#include <mosquittopp.h>
+
+static int run = -1;
+
+class mosquittopp_test : public mosqpp::mosquittopp
+{
+	public:
+		mosquittopp_test(const char *id);
+
+		void on_connect(int rc);
+		void on_disconnect(int rc);
+		void on_publish(int mid);
+};
+
+mosquittopp_test::mosquittopp_test(const char *id) : mosqpp::mosquittopp(id)
+{
+}
+
+void mosquittopp_test::on_connect(int rc)
+{
+	if(rc){
+		exit(1);
+	}else{
+		publish(NULL, "pub/qos2/test", strlen("message"), "message", 2, false);
+	}
+}
+
+void mosquittopp_test::on_disconnect(int rc)
+{
+	run = 0;
+}
+
+void mosquittopp_test::on_publish(int mid)
+{
+	disconnect();
+}
+
+int main(int argc, char *argv[])
+{
+	struct mosquittopp_test *mosq;
+
+	mosqpp::lib_init();
+
+	mosq = new mosquittopp_test("publish-qos2-test");
+
+	mosq->connect("localhost", 1888, 60);
+
+	while(run == -1){
+		mosq->loop();
+	}
+
+	mosqpp::lib_cleanup();
+
+	return run;
+}
+

test/lib/cpp/03-publish-qos0-no-payload.cpp

@@ -0,0 +1,56 @@
+#include <cstring>
+
+#include <mosquittopp.h>
+
+static int run = -1;
+static int sent_mid = -1;
+
+class mosquittopp_test : public mosqpp::mosquittopp
+{
+	public:
+		mosquittopp_test(const char *id);
+
+		void on_connect(int rc);
+		void on_publish(int mid);
+};
+
+mosquittopp_test::mosquittopp_test(const char *id) : mosqpp::mosquittopp(id)
+{
+}
+
+void mosquittopp_test::on_connect(int rc)
+{
+	if(rc){
+		exit(1);
+	}else{
+		publish(&sent_mid, "pub/qos0/no-payload/test", 0, NULL, 0, false);
+	}
+}
+
+void mosquittopp_test::on_publish(int mid)
+{
+	if(sent_mid == mid){
+		disconnect();
+	}else{
+		exit(1);
+	}
+}
+
+int main(int argc, char *argv[])
+{
+	struct mosquittopp_test *mosq;
+
+	mosqpp::lib_init();
+
+	mosq = new mosquittopp_test("publish-qos0-test-np");
+
+	mosq->connect("localhost", 1888, 60);
+
+	while(run == -1){
+		mosq->loop();
+	}
+
+	mosqpp::lib_cleanup();
+
+	return run;
+}

test/lib/cpp/03-publish-qos0.cpp

@@ -0,0 +1,56 @@
+#include <cstring>
+
+#include <mosquittopp.h>
+
+static int run = -1;
+static int sent_mid = -1;
+
+class mosquittopp_test : public mosqpp::mosquittopp
+{
+	public:
+		mosquittopp_test(const char *id);
+
+		void on_connect(int rc);
+		void on_publish(int mid);
+};
+
+mosquittopp_test::mosquittopp_test(const char *id) : mosqpp::mosquittopp(id)
+{
+}
+
+void mosquittopp_test::on_connect(int rc)
+{
+	if(rc){
+		exit(1);
+	}else{
+		publish(&sent_mid, "pub/qos0/test", strlen("message"), "message", 0, false);
+	}
+}
+
+void mosquittopp_test::on_publish(int mid)
+{
+	if(sent_mid == mid){
+		disconnect();
+	}else{
+		exit(1);
+	}
+}
+
+int main(int argc, char *argv[])
+{
+	struct mosquittopp_test *mosq;
+
+	mosqpp::lib_init();
+
+	mosq = new mosquittopp_test("publish-qos0-test");
+
+	mosq->connect("localhost", 1888, 60);
+
+	while(run == -1){
+		mosq->loop();
+	}
+
+	mosqpp::lib_cleanup();
+
+	return run;
+}

test/lib/cpp/04-retain-qos0.cpp

@@ -0,0 +1,45 @@
+#include <cstring>
+
+#include <mosquittopp.h>
+
+static int run = -1;
+
+class mosquittopp_test : public mosqpp::mosquittopp
+{
+	public:
+		mosquittopp_test(const char *id);
+
+		void on_connect(int rc);
+};
+
+mosquittopp_test::mosquittopp_test(const char *id) : mosqpp::mosquittopp(id)
+{
+}
+
+void mosquittopp_test::on_connect(int rc)
+{
+	if(rc){
+		exit(1);
+	}else{
+		publish(NULL, "retain/qos0/test", strlen("retained message"), "retained message", 0, true);
+	}
+}
+
+int main(int argc, char *argv[])
+{
+	struct mosquittopp_test *mosq;
+
+	mosqpp::lib_init();
+
+	mosq = new mosquittopp_test("retain-qos0-test");
+
+	mosq->connect("localhost", 1888, 60);
+
+	while(run == -1){
+		mosq->loop();
+	}
+
+	mosqpp::lib_cleanup();
+
+	return run;
+}

test/lib/cpp/08-ssl-bad-cacert.cpp

@@ -0,0 +1,31 @@
+#include <mosquittopp.h>
+
+static int run = -1;
+
+class mosquittopp_test : public mosqpp::mosquittopp
+{
+	public:
+		mosquittopp_test(const char *id);
+};
+
+mosquittopp_test::mosquittopp_test(const char *id) : mosqpp::mosquittopp(id)
+{
+}
+
+int main(int argc, char *argv[])
+{
+	struct mosquittopp_test *mosq;
+	int rc = 1;
+
+	mosqpp::lib_init();
+
+	mosq = new mosquittopp_test("08-ssl-bad-cacert");
+
+	mosq->tls_opts_set(1, "tlsv1", NULL);
+	if(mosq->tls_set("this/file/doesnt/exist") == MOSQ_ERR_INVAL){
+		rc = 0;
+	}
+	mosqpp::lib_cleanup();
+
+	return rc;
+}

test/lib/cpp/08-ssl-connect-cert-auth.cpp

@@ -0,0 +1,53 @@
+#include <mosquittopp.h>
+
+static int run = -1;
+
+class mosquittopp_test : public mosqpp::mosquittopp
+{
+	public:
+		mosquittopp_test(const char *id);
+
+		void on_connect(int rc);
+		void on_disconnect(int rc);
+};
+
+mosquittopp_test::mosquittopp_test(const char *id) : mosqpp::mosquittopp(id)
+{
+}
+
+void mosquittopp_test::on_connect(int rc)
+{
+	if(rc){
+		exit(1);
+	}else{
+		disconnect();
+	}
+}
+
+void mosquittopp_test::on_disconnect(int rc)
+{
+	run = rc;
+}
+
+
+int main(int argc, char *argv[])
+{
+	struct mosquittopp_test *mosq;
+
+	mosqpp::lib_init();
+
+	mosq = new mosquittopp_test("08-ssl-connect-crt-auth");
+
+	mosq->tls_opts_set(1, "tlsv1", NULL);
+	//mosq->tls_set("../ssl/test-ca.crt", NULL, "../ssl/client.crt", "../ssl/client.key");
+	mosq->tls_set("../ssl/all-ca.crt", NULL, "../ssl/client.crt", "../ssl/client.key");
+	mosq->connect("localhost", 1888, 60);
+
+	while(run == -1){
+		mosq->loop();
+	}
+
+	mosqpp::lib_cleanup();
+
+	return run;
+}

test/lib/cpp/08-ssl-connect-no-auth.cpp

@@ -0,0 +1,53 @@
+#include <mosquittopp.h>
+
+static int run = -1;
+
+class mosquittopp_test : public mosqpp::mosquittopp
+{
+	public:
+		mosquittopp_test(const char *id);
+
+		void on_connect(int rc);
+		void on_disconnect(int rc);
+};
+
+mosquittopp_test::mosquittopp_test(const char *id) : mosqpp::mosquittopp(id)
+{
+}
+
+void mosquittopp_test::on_connect(int rc)
+{
+	if(rc){
+		exit(1);
+	}else{
+		disconnect();
+	}
+}
+
+void mosquittopp_test::on_disconnect(int rc)
+{
+	run = rc;
+}
+
+
+int main(int argc, char *argv[])
+{
+	struct mosquittopp_test *mosq;
+
+	mosqpp::lib_init();
+
+	mosq = new mosquittopp_test("08-ssl-connect-no-auth");
+
+	mosq->tls_opts_set(1, "tlsv1", NULL);
+	//mosq->tls_set("../ssl/test-root-ca.crt");
+	mosq->tls_set("../ssl/all-ca.crt");
+	mosq->connect("localhost", 1888, 60);
+
+	while(run == -1){
+		mosq->loop();
+	}
+
+	mosqpp::lib_cleanup();
+
+	return run;
+}

test/lib/cpp/08-ssl-fake-cacert.cpp

@@ -0,0 +1,42 @@
+#include <errno.h>
+#include <mosquittopp.h>
+
+static int run = -1;
+
+class mosquittopp_test : public mosqpp::mosquittopp
+{
+	public:
+		mosquittopp_test(const char *id);
+
+		void on_connect(int rc);
+};
+
+mosquittopp_test::mosquittopp_test(const char *id) : mosqpp::mosquittopp(id)
+{
+}
+
+void mosquittopp_test::on_connect(int rc)
+{
+	exit(1);
+}
+
+int main(int argc, char *argv[])
+{
+	struct mosquittopp_test *mosq;
+	int rc;
+
+	mosqpp::lib_init();
+
+	mosq = new mosquittopp_test("08-ssl-fake-cacert");
+
+	mosq->tls_opts_set(1, "tlsv1", NULL);
+	mosq->tls_set("../ssl/test-fake-root-ca.crt", NULL, "../ssl/client.crt", "../ssl/client.key");
+	mosq->connect("localhost", 1888, 60);
+
+	rc = mosq->loop_forever();
+	if(rc == MOSQ_ERR_ERRNO && errno == EPROTO){
+		return 0;
+	}else{
+		return 1;
+	}
+}

test/lib/cpp/09-util-topic-matching.cpp

@@ -0,0 +1,47 @@
+#include <cstdio>
+#include <mosquittopp.h>
+
+void do_check(const char *sub, const char *topic, bool bad_res)
+{
+	bool match;
+
+	mosqpp::topic_matches_sub(sub, topic, &match);
+	
+	if(match == bad_res){
+		printf("s: %s t: %s\n", sub, topic);
+		exit(1);
+	}
+}
+
+int main(int argc, char *argv[])
+{
+	do_check("foo/bar", "foo/bar", false);
+	do_check("foo/+", "foo/bar", false);
+	do_check("foo/+/baz", "foo/bar/baz", false);
+
+	do_check("foo/+/#", "foo/bar/baz", false);
+	do_check("#", "foo/bar/baz", false);
+
+	do_check("foo/bar", "foo", true);
+	do_check("foo/+", "foo/bar/baz", true);
+	do_check("foo/+/baz", "foo/bar/bar", true);
+
+	do_check("foo/+/#", "fo2/bar/baz", true);
+
+	do_check("#", "/foo/bar", false);
+	do_check("/#", "/foo/bar", false);
+	do_check("/#", "foo/bar", true);
+
+
+	do_check("foo//bar", "foo//bar", false);
+	do_check("foo//+", "foo//bar", false);
+	do_check("foo/+/+/baz", "foo///baz", false);
+	do_check("foo/bar/+", "foo/bar/", false);
+
+	do_check("$SYS/bar", "$SYS/bar", false);
+	do_check("#", "$SYS/bar", true);
+	do_check("$BOB/bar", "$SYS/bar", true);
+
+	return 0;
+}
+

test/lib/cpp/09-util-topic-tokenise.cpp

@@ -0,0 +1,129 @@
+#include <cstdio>
+#include <cstring>
+#include <mosquittopp.h>
+
+void print_error(const char *topic, char **topics, int topic_count)
+{
+	int i;
+	printf("TOPIC: %s\n", topic);
+	printf("TOKENS: ");
+	for(i=0; i<topic_count; i++){
+		printf("%s", topics[i]);
+		if(i+1<topic_count){
+			printf("/");
+		}
+	}
+	printf("\n");
+}
+
+int main(int argc, char *argv[])
+{
+	char **topics;
+	int topic_count;
+
+	if(mosqpp::sub_topic_tokenise("topic", &topics, &topic_count)){
+		printf("Out of memory.\n");
+		return 1;
+	}
+	if(topic_count != 1 || strcmp(topics[0], "topic")){
+		print_error("topic", topics, topic_count);
+		return 1;
+	}
+
+	if(mosqpp::sub_topic_tokenise("a/deep/topic/hierarchy", &topics, &topic_count)){
+		printf("Out of memory.\n");
+		return 1;
+	}
+	if(topic_count != 4
+			|| strcmp(topics[0], "a")
+			|| strcmp(topics[1], "deep")
+			|| strcmp(topics[2], "topic")
+			|| strcmp(topics[3], "hierarchy")){
+		print_error("a/deep/topic/hierarchy", topics, topic_count);
+		return 1;
+	}
+
+	if(mosqpp::sub_topic_tokenise("/a/deep/topic/hierarchy", &topics, &topic_count)){
+		printf("Out of memory.\n");
+		return 1;
+	}
+	if(topic_count != 5
+			|| topics[0]
+			|| strcmp(topics[1], "a")
+			|| strcmp(topics[2], "deep")
+			|| strcmp(topics[3], "topic")
+			|| strcmp(topics[4], "hierarchy")){
+		print_error("/a/deep/topic/hierarchy", topics, topic_count);
+		return 1;
+	}
+
+	if(mosqpp::sub_topic_tokenise("a/b/c", &topics, &topic_count)){
+		printf("Out of memory.\n");
+		return 1;
+	}
+	if(topic_count != 3
+			|| strcmp(topics[0], "a")
+			|| strcmp(topics[1], "b")
+			|| strcmp(topics[2], "c")){
+		print_error("a/b/c", topics, topic_count);
+		return 1;
+	}
+
+	if(mosqpp::sub_topic_tokenise("/a/b/c", &topics, &topic_count)){
+		printf("Out of memory.\n");
+		return 1;
+	}
+	if(topic_count != 4
+			|| topics[0]
+			|| strcmp(topics[1], "a")
+			|| strcmp(topics[2], "b")
+			|| strcmp(topics[3], "c")){
+		print_error("/a/b/c", topics, topic_count);
+		return 1;
+	}
+
+	if(mosqpp::sub_topic_tokenise("a///hierarchy", &topics, &topic_count)){
+		printf("Out of memory.\n");
+		return 1;
+	}
+	if(topic_count != 4
+			|| strcmp(topics[0], "a")
+			|| topics[1]
+			|| topics[2]
+			|| strcmp(topics[3], "hierarchy")){
+		print_error("a///hierarchy", topics, topic_count);
+		return 1;
+	}
+
+	if(mosqpp::sub_topic_tokenise("/a///hierarchy", &topics, &topic_count)){
+		printf("Out of memory.\n");
+		return 1;
+	}
+	if(topic_count != 5
+			|| topics[0]
+			|| strcmp(topics[1], "a")
+			|| topics[2]
+			|| topics[3]
+			|| strcmp(topics[4], "hierarchy")){
+		print_error("/a///hierarchy", topics, topic_count);
+		return 1;
+	}
+
+	if(mosqpp::sub_topic_tokenise("/a///hierarchy/", &topics, &topic_count)){
+		printf("Out of memory.\n");
+		return 1;
+	}
+	if(topic_count != 6
+			|| topics[0]
+			|| strcmp(topics[1], "a")
+			|| topics[2]
+			|| topics[3]
+			|| strcmp(topics[4], "hierarchy")
+			|| topics[3]){
+		print_error("/a///hierarchy/", topics, topic_count);
+		return 1;
+	}
+
+	return 0;
+}
+

test/lib/cpp/Makefile

@@ -0,0 +1,102 @@
+.PHONY: all test 01 02 03 04 08 09 clean reallyclean
+
+CFLAGS=-I../../../lib -I../../../lib/cpp -DDEBUG -Werror
+LIBS=../../../lib/libmosquitto.so.1 ../../../lib/cpp/libmosquittopp.so.1
+
+all : 01 02 03 04 08 09
+
+01-con-discon-success.test : 01-con-discon-success.cpp
+	$(CXX) $< -o $@ $(CFLAGS) $(LIBS)
+
+01-will-set.test : 01-will-set.cpp
+	$(CXX) $< -o $@ $(CFLAGS) $(LIBS)
+
+01-unpwd-set.test : 01-unpwd-set.cpp
+	$(CXX) $< -o $@ $(CFLAGS) $(LIBS)
+
+01-will-unpwd-set.test : 01-will-unpwd-set.cpp
+	$(CXX) $< -o $@ $(CFLAGS) $(LIBS)
+
+01-no-clean-session.test : 01-no-clean-session.cpp
+	$(CXX) $< -o $@ $(CFLAGS) $(LIBS)
+
+01-keepalive-pingreq.test : 01-keepalive-pingreq.cpp
+	$(CXX) $< -o $@ $(CFLAGS) $(LIBS)
+
+02-subscribe-qos0.test : 02-subscribe-qos0.cpp
+	$(CXX) $< -o $@ $(CFLAGS) $(LIBS)
+
+02-subscribe-qos1.test : 02-subscribe-qos1.cpp
+	$(CXX) $< -o $@ $(CFLAGS) $(LIBS)
+
+02-subscribe-qos2.test : 02-subscribe-qos2.cpp
+	$(CXX) $< -o $@ $(CFLAGS) $(LIBS)
+
+02-unsubscribe.test : 02-unsubscribe.cpp
+	$(CXX) $< -o $@ $(CFLAGS) $(LIBS)
+
+03-publish-qos0.test : 03-publish-qos0.cpp
+	$(CXX) $< -o $@ $(CFLAGS) $(LIBS)
+
+03-publish-qos0-no-payload.test : 03-publish-qos0-no-payload.cpp
+	$(CXX) $< -o $@ $(CFLAGS) $(LIBS)
+
+03-publish-c2b-qos1-timeout.test : 03-publish-c2b-qos1-timeout.cpp
+	$(CXX) $< -o $@ $(CFLAGS) $(LIBS)
+
+03-publish-c2b-qos1-disconnect.test : 03-publish-c2b-qos1-disconnect.cpp
+	$(CXX) $< -o $@ $(CFLAGS) $(LIBS)
+
+03-publish-c2b-qos2.test : 03-publish-c2b-qos2.cpp
+	$(CXX) $< -o $@ $(CFLAGS) $(LIBS)
+
+03-publish-c2b-qos2-disconnect.test : 03-publish-c2b-qos2-disconnect.cpp
+	$(CXX) $< -o $@ $(CFLAGS) $(LIBS)
+
+03-publish-c2b-qos2-timeout.test : 03-publish-c2b-qos2-timeout.cpp
+	$(CXX) $< -o $@ $(CFLAGS) $(LIBS)
+
+03-publish-b2c-qos1.test : 03-publish-b2c-qos1.cpp
+	$(CXX) $< -o $@ $(CFLAGS) $(LIBS)
+
+03-publish-b2c-qos2.test : 03-publish-b2c-qos2.cpp
+	$(CXX) $< -o $@ $(CFLAGS) $(LIBS)
+
+04-retain-qos0.test : 04-retain-qos0.cpp
+	$(CXX) $< -o $@ $(CFLAGS) $(LIBS)
+
+08-ssl-connect-no-auth.test : 08-ssl-connect-no-auth.cpp
+	$(CXX) $< -o $@ $(CFLAGS) $(LIBS)
+
+08-ssl-connect-cert-auth.test : 08-ssl-connect-cert-auth.cpp
+	$(CXX) $< -o $@ $(CFLAGS) $(LIBS)
+
+08-ssl-bad-cacert.test : 08-ssl-bad-cacert.cpp
+	$(CXX) $< -o $@ $(CFLAGS) $(LIBS)
+
+08-ssl-fake-cacert.test : 08-ssl-fake-cacert.cpp
+	$(CXX) $< -o $@ $(CFLAGS) $(LIBS)
+
+09-util-topic-matching.test : 09-util-topic-matching.cpp
+	$(CXX) $< -o $@ $(CFLAGS) $(LIBS)
+
+09-util-topic-tokenise.test : 09-util-topic-tokenise.cpp
+	$(CXX) $< -o $@ $(CFLAGS) $(LIBS)
+
+01 : 01-con-discon-success.test 01-will-set.test 01-unpwd-set.test 01-will-unpwd-set.test 01-no-clean-session.test 01-keepalive-pingreq.test
+
+02 : 02-subscribe-qos0.test 02-subscribe-qos1.test 02-subscribe-qos2.test 02-unsubscribe.test
+
+03 : 03-publish-qos0.test 03-publish-qos0-no-payload.test 03-publish-c2b-qos1-timeout.test 03-publish-c2b-qos1-disconnect.test 03-publish-c2b-qos2.test 03-publish-c2b-qos2-timeout.test 03-publish-c2b-qos2-disconnect.test 03-publish-b2c-qos1.test 03-publish-b2c-qos2.test
+
+04 : 04-retain-qos0.test
+
+08 : 08-ssl-connect-no-auth.test 08-ssl-connect-cert-auth.test 08-ssl-bad-cacert.test 08-ssl-fake-cacert.test
+
+09 : 09-util-topic-matching.test 09-util-topic-tokenise.test
+
+reallyclean : clean
+	-rm -f *.orig
+
+clean :
+	rm -f *.test