generated from guanyuankai/bonus-edge-proxy
1856 lines
58 KiB
C
1856 lines
58 KiB
C
/*******************************************************************************
|
|
* Copyright (c) 2009, 2024 IBM Corp. and others
|
|
*
|
|
* All rights reserved. This program and the accompanying materials
|
|
* are made available under the terms of the Eclipse Public License v2.0
|
|
* and Eclipse Distribution License v1.0 which accompany this distribution.
|
|
*
|
|
* The Eclipse Public License is available at
|
|
* https://www.eclipse.org/legal/epl-2.0/
|
|
* and the Eclipse Distribution License is available at
|
|
* http://www.eclipse.org/org/documents/edl-v10.php.
|
|
*
|
|
* Contributors:
|
|
* Ian Craggs - initial API and implementation and/or initial documentation
|
|
* Ian Craggs - MQTT 5.0 support
|
|
*******************************************************************************/
|
|
|
|
|
|
/**
|
|
* @file
|
|
* MQTT V5 specific tests for the MQTT C client
|
|
*
|
|
* - topic aliases
|
|
* - subscription ids
|
|
* - session expiry
|
|
* - payload format
|
|
* - flow control
|
|
* - QoS 2 exchange termination
|
|
* - request/response
|
|
* - shared subscriptions
|
|
* - server initiated disconnect
|
|
* - auth packets
|
|
* - server assigned clientid returned in a property
|
|
* - server defined keepalive
|
|
* - subscribe failure
|
|
*/
|
|
|
|
|
|
#include "MQTTClient.h"
|
|
#include <string.h>
|
|
#include <stdlib.h>
|
|
|
|
#if !defined(_WINDOWS)
|
|
#include <sys/time.h>
|
|
#include <sys/socket.h>
|
|
#include <unistd.h>
|
|
#include <errno.h>
|
|
#else
|
|
#include <windows.h>
|
|
#define setenv(a, b, c) _putenv_s(a, b)
|
|
#endif
|
|
|
|
#define ARRAY_SIZE(a) (sizeof(a) / sizeof(a[0]))
|
|
|
|
void usage(void)
|
|
{
|
|
printf("help!!\n");
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
|
|
struct Options
|
|
{
|
|
char* connection; /**< connection to system under test. */
|
|
char** haconnections;
|
|
char* proxy_connection;
|
|
int hacount;
|
|
int verbose;
|
|
int test_no;
|
|
int MQTTVersion;
|
|
int iterations;
|
|
} options =
|
|
{
|
|
"tcp://localhost:1883",
|
|
NULL,
|
|
"tcp://localhost:1884",
|
|
0,
|
|
0,
|
|
0,
|
|
MQTTVERSION_5,
|
|
1,
|
|
};
|
|
|
|
void getopts(int argc, char** argv)
|
|
{
|
|
int count = 1;
|
|
|
|
while (count < argc)
|
|
{
|
|
if (strcmp(argv[count], "--test_no") == 0)
|
|
{
|
|
if (++count < argc)
|
|
options.test_no = atoi(argv[count]);
|
|
else
|
|
usage();
|
|
}
|
|
else if (strcmp(argv[count], "--connection") == 0)
|
|
{
|
|
if (++count < argc)
|
|
{
|
|
options.connection = argv[count];
|
|
printf("\nSetting connection to %s\n", options.connection);
|
|
}
|
|
else
|
|
usage();
|
|
}
|
|
else if (strcmp(argv[count], "--haconnections") == 0)
|
|
{
|
|
if (++count < argc)
|
|
{
|
|
char* tok = strtok(argv[count], " ");
|
|
options.hacount = 0;
|
|
options.haconnections = malloc(sizeof(char*) * 5);
|
|
while (tok)
|
|
{
|
|
options.haconnections[options.hacount] = malloc(strlen(tok) + 1);
|
|
strcpy(options.haconnections[options.hacount], tok);
|
|
options.hacount++;
|
|
tok = strtok(NULL, " ");
|
|
}
|
|
}
|
|
else
|
|
usage();
|
|
}
|
|
else if (strcmp(argv[count], "--proxy_connection") == 0)
|
|
{
|
|
if (++count < argc)
|
|
options.proxy_connection = argv[count];
|
|
else
|
|
usage();
|
|
}
|
|
else if (strcmp(argv[count], "--MQTTversion") == 0)
|
|
{
|
|
if (++count < argc)
|
|
{
|
|
options.MQTTVersion = atoi(argv[count]);
|
|
printf("setting MQTT version to %d\n", options.MQTTVersion);
|
|
}
|
|
else
|
|
usage();
|
|
}
|
|
else if (strcmp(argv[count], "--iterations") == 0)
|
|
{
|
|
if (++count < argc)
|
|
options.iterations = atoi(argv[count]);
|
|
else
|
|
usage();
|
|
}
|
|
else if (strcmp(argv[count], "--verbose") == 0)
|
|
{
|
|
options.verbose = 1;
|
|
printf("\nSetting verbose on\n");
|
|
}
|
|
count++;
|
|
}
|
|
}
|
|
|
|
|
|
#define LOGA_DEBUG 0
|
|
#define LOGA_INFO 1
|
|
#include <stdarg.h>
|
|
#include <time.h>
|
|
#include <sys/timeb.h>
|
|
void MyLog(int LOGA_level, char* format, ...)
|
|
{
|
|
static char msg_buf[256];
|
|
va_list args;
|
|
#if defined(_WIN32) || defined(_WINDOWS)
|
|
struct timeb ts;
|
|
#else
|
|
struct timeval ts;
|
|
#endif
|
|
struct tm timeinfo;
|
|
|
|
if (LOGA_level == LOGA_DEBUG && options.verbose == 0)
|
|
return;
|
|
|
|
#if defined(_WIN32) || defined(_WINDOWS)
|
|
ftime(&ts);
|
|
localtime_s(&timeinfo, &ts.time);
|
|
#else
|
|
gettimeofday(&ts, NULL);
|
|
localtime_r(&ts.tv_sec, &timeinfo);
|
|
#endif
|
|
strftime(msg_buf, 80, "%Y%m%d %H%M%S", &timeinfo);
|
|
|
|
#if defined(_WIN32) || defined(_WINDOWS)
|
|
sprintf(&msg_buf[strlen(msg_buf)], ".%.3hu ", ts.millitm);
|
|
#else
|
|
sprintf(&msg_buf[strlen(msg_buf)], ".%.3lu ", ts.tv_usec / 1000L);
|
|
#endif
|
|
|
|
va_start(args, format);
|
|
vsnprintf(&msg_buf[strlen(msg_buf)], sizeof(msg_buf) - strlen(msg_buf), format, args);
|
|
va_end(args);
|
|
|
|
printf("%s\n", msg_buf);
|
|
fflush(stdout);
|
|
}
|
|
|
|
|
|
#if defined(_WIN32) || defined(_WINDOWS)
|
|
#define mqsleep(A) Sleep(1000*A)
|
|
#define START_TIME_TYPE DWORD
|
|
static DWORD start_time = 0;
|
|
START_TIME_TYPE start_clock(void)
|
|
{
|
|
return GetTickCount();
|
|
}
|
|
#elif defined(AIX)
|
|
#define mqsleep sleep
|
|
#define START_TIME_TYPE struct timespec
|
|
START_TIME_TYPE start_clock(void)
|
|
{
|
|
static struct timespec start;
|
|
clock_gettime(CLOCK_REALTIME, &start);
|
|
return start;
|
|
}
|
|
#else
|
|
#define mqsleep sleep
|
|
#define START_TIME_TYPE struct timeval
|
|
/* TODO - unused - remove? static struct timeval start_time; */
|
|
START_TIME_TYPE start_clock(void)
|
|
{
|
|
struct timeval start_time;
|
|
gettimeofday(&start_time, NULL);
|
|
return start_time;
|
|
}
|
|
#endif
|
|
|
|
|
|
#if defined(_WIN32)
|
|
long elapsed(START_TIME_TYPE start_time)
|
|
{
|
|
return GetTickCount() - start_time;
|
|
}
|
|
#elif defined(AIX)
|
|
#define assert(a)
|
|
long elapsed(struct timespec start)
|
|
{
|
|
struct timespec now, res;
|
|
|
|
clock_gettime(CLOCK_REALTIME, &now);
|
|
ntimersub(now, start, res);
|
|
return (res.tv_sec)*1000L + (res.tv_nsec)/1000000L;
|
|
}
|
|
#else
|
|
long elapsed(START_TIME_TYPE start_time)
|
|
{
|
|
struct timeval now, res;
|
|
|
|
gettimeofday(&now, NULL);
|
|
timersub(&now, &start_time, &res);
|
|
return (res.tv_sec)*1000 + (res.tv_usec)/1000;
|
|
}
|
|
#endif
|
|
|
|
|
|
#define assert(a, b, c, d) myassert(__FILE__, __LINE__, a, b, c, d)
|
|
#define assert1(a, b, c, d, e) myassert(__FILE__, __LINE__, a, b, c, d, e)
|
|
|
|
int tests = 0;
|
|
int failures = 0;
|
|
FILE* xml;
|
|
START_TIME_TYPE global_start_time;
|
|
char output[3000];
|
|
char* cur_output = output;
|
|
|
|
|
|
void write_test_result(void)
|
|
{
|
|
long duration = elapsed(global_start_time);
|
|
|
|
fprintf(xml, " time=\"%ld.%.3ld\" >\n", duration / 1000, duration % 1000);
|
|
if (cur_output != output)
|
|
{
|
|
fprintf(xml, "%s", output);
|
|
cur_output = output;
|
|
}
|
|
fprintf(xml, "</testcase>\n");
|
|
}
|
|
|
|
|
|
void myassert(char* filename, int lineno, char* description, int value, char* format, ...)
|
|
{
|
|
++tests;
|
|
if (!value)
|
|
{
|
|
va_list args;
|
|
|
|
++failures;
|
|
MyLog(LOGA_INFO, "Assertion failed, file %s, line %d, description: %s\n", filename, lineno, description);
|
|
|
|
va_start(args, format);
|
|
vprintf(format, args);
|
|
va_end(args);
|
|
|
|
cur_output += sprintf(cur_output, "<failure type=\"%s\">file %s, line %d </failure>\n",
|
|
description, filename, lineno);
|
|
}
|
|
else
|
|
MyLog(LOGA_DEBUG, "Assertion succeeded, file %s, line %d, description: %s", filename, lineno, description);
|
|
}
|
|
|
|
|
|
void logProperties(MQTTProperties *props)
|
|
{
|
|
int i = 0;
|
|
|
|
for (i = 0; i < props->count; ++i)
|
|
{
|
|
int id = props->array[i].identifier;
|
|
const char* name = MQTTPropertyName(id);
|
|
char* intformat = "Property name %s value %d";
|
|
|
|
switch (MQTTProperty_getType(id))
|
|
{
|
|
case MQTTPROPERTY_TYPE_BYTE:
|
|
MyLog(LOGA_INFO, intformat, name, props->array[i].value.byte);
|
|
break;
|
|
case MQTTPROPERTY_TYPE_TWO_BYTE_INTEGER:
|
|
MyLog(LOGA_INFO, intformat, name, props->array[i].value.integer2);
|
|
break;
|
|
case MQTTPROPERTY_TYPE_FOUR_BYTE_INTEGER:
|
|
MyLog(LOGA_INFO, intformat, name, props->array[i].value.integer4);
|
|
break;
|
|
case MQTTPROPERTY_TYPE_VARIABLE_BYTE_INTEGER:
|
|
MyLog(LOGA_INFO, intformat, name, props->array[i].value.integer4);
|
|
break;
|
|
case MQTTPROPERTY_TYPE_BINARY_DATA:
|
|
case MQTTPROPERTY_TYPE_UTF_8_ENCODED_STRING:
|
|
MyLog(LOGA_INFO, "Property name value %s %.*s", name,
|
|
props->array[i].value.data.len, props->array[i].value.data.data);
|
|
break;
|
|
case MQTTPROPERTY_TYPE_UTF_8_STRING_PAIR:
|
|
MyLog(LOGA_INFO, "Property name %s key %.*s value %.*s", name,
|
|
props->array[i].value.data.len, props->array[i].value.data.data,
|
|
props->array[i].value.value.len, props->array[i].value.value.data);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
struct
|
|
{
|
|
int disconnected;
|
|
} test_topic_aliases_globals =
|
|
{
|
|
0,
|
|
};
|
|
|
|
void disconnected(void* context, MQTTProperties* props, enum MQTTReasonCodes rc)
|
|
{
|
|
MQTTClient c = (MQTTClient)context;
|
|
MyLog(LOGA_INFO, "Callback: disconnected, reason code \"%s\"", MQTTReasonCode_toString(rc));
|
|
logProperties(props);
|
|
test_topic_aliases_globals.disconnected = 1;
|
|
}
|
|
|
|
static int messages_arrived = 0;
|
|
|
|
int messageArrived(void* context, char* topicName, int topicLen, MQTTClient_message* message)
|
|
{
|
|
MyLog(LOGA_DEBUG, "Callback: message received on topic %s is %.*s.",
|
|
topicName, message->payloadlen, (char*)(message->payload));
|
|
|
|
assert("Message structure version should be 1", message->struct_version == 1,
|
|
"message->struct_version was %d", message->struct_version);
|
|
if (message->struct_version == 1)
|
|
{
|
|
const int props_count = 0;
|
|
|
|
assert("Properties count should be 0", message->properties.count == props_count,
|
|
"Properties count was %d\n", message->properties.count);
|
|
logProperties(&message->properties);
|
|
}
|
|
messages_arrived++;
|
|
|
|
MQTTClient_free(topicName);
|
|
MQTTClient_freeMessage(&message);
|
|
return 1;
|
|
}
|
|
|
|
|
|
int test_client_topic_aliases(struct Options options)
|
|
{
|
|
int subsqos = 2;
|
|
MQTTClient c;
|
|
MQTTClient_connectOptions opts = MQTTClient_connectOptions_initializer5;
|
|
MQTTClient_willOptions wopts = MQTTClient_willOptions_initializer;
|
|
MQTTProperties props = MQTTProperties_initializer;
|
|
MQTTProperties connect_props = MQTTProperties_initializer;
|
|
MQTTProperty property;
|
|
MQTTSubscribe_options subopts = MQTTSubscribe_options_initializer;
|
|
MQTTClient_message pubmsg = MQTTClient_message_initializer;
|
|
MQTTResponse response = MQTTResponse_initializer;
|
|
MQTTClient_deliveryToken dt;
|
|
int rc = 0;
|
|
int count = 0;
|
|
char* test_topic = "test_client_topic_aliases";
|
|
int topicAliasMaximum = 0;
|
|
MQTTClient_createOptions createOpts = MQTTClient_createOptions_initializer;
|
|
|
|
fprintf(xml, "<testcase classname=\"test_client_topic_aliases\" name=\"client topic aliases\"");
|
|
global_start_time = start_clock();
|
|
failures = 0;
|
|
MyLog(LOGA_INFO, "Starting test 1 - client topic aliases");
|
|
|
|
createOpts.MQTTVersion = MQTTVERSION_5;
|
|
rc = MQTTClient_createWithOptions(&c, options.connection, "client_topic_alias_test",
|
|
MQTTCLIENT_PERSISTENCE_DEFAULT, NULL, &createOpts);
|
|
assert("good rc from create", rc == MQTTCLIENT_SUCCESS, "rc was %d\n", rc);
|
|
if (rc != MQTTCLIENT_SUCCESS)
|
|
{
|
|
MQTTClient_destroy(&c);
|
|
goto exit;
|
|
}
|
|
|
|
rc = MQTTClient_setCallbacks(c, NULL, NULL, messageArrived, NULL);
|
|
assert("Good rc from setCallbacks", rc == MQTTCLIENT_SUCCESS, "rc was %d", rc);
|
|
|
|
rc = MQTTClient_setDisconnected(c, c, disconnected);
|
|
assert("Good rc from setDisconnected", rc == MQTTCLIENT_SUCCESS, "rc was %d", rc);
|
|
|
|
opts.keepAliveInterval = 20;
|
|
opts.cleanstart = 1;
|
|
opts.MQTTVersion = options.MQTTVersion;
|
|
if (options.haconnections != NULL)
|
|
{
|
|
opts.serverURIs = options.haconnections;
|
|
opts.serverURIcount = options.hacount;
|
|
}
|
|
|
|
MyLog(LOGA_DEBUG, "Connecting");
|
|
response = MQTTClient_connect5(c, &opts, NULL, NULL);
|
|
assert("Good rc from connect", response.reasonCode == MQTTCLIENT_SUCCESS, "rc was %d", response.reasonCode);
|
|
if (response.reasonCode != MQTTCLIENT_SUCCESS)
|
|
goto exit;
|
|
|
|
if (response.properties)
|
|
{
|
|
logProperties(response.properties);
|
|
MQTTResponse_free(response);
|
|
}
|
|
|
|
pubmsg.payload = "a much longer message that we can shorten to the extent that we need to payload up to 11";
|
|
pubmsg.payloadlen = 11;
|
|
pubmsg.qos = 1;
|
|
pubmsg.retained = 0;
|
|
|
|
/* a Topic Alias of 0 is not allowed, so we should be disconnected */
|
|
property.identifier = MQTTPROPERTY_CODE_TOPIC_ALIAS;
|
|
property.value.integer2 = 0;
|
|
MQTTProperties_add(&pubmsg.properties, &property);
|
|
|
|
response = MQTTClient_publishMessage5(c, test_topic, &pubmsg, &dt);
|
|
assert("Good rc from publish", response.reasonCode == MQTTCLIENT_SUCCESS, "rc was %d", response.reasonCode);
|
|
|
|
/* Now we expect to receive a disconnect packet telling us why */
|
|
count = 0;
|
|
while (test_topic_aliases_globals.disconnected == 0 && ++count < 10)
|
|
{
|
|
#if defined(_WIN32)
|
|
Sleep(1000);
|
|
#else
|
|
usleep(1000000L);
|
|
#endif
|
|
}
|
|
assert("Disconnected should be called", test_topic_aliases_globals.disconnected == 1,
|
|
"was %d", test_topic_aliases_globals.disconnected);
|
|
|
|
property.identifier = MQTTPROPERTY_CODE_SESSION_EXPIRY_INTERVAL;
|
|
property.value.integer4 = 30;
|
|
MQTTProperties_add(&connect_props, &property);
|
|
|
|
/* Now try a valid topic alias */
|
|
response = MQTTClient_connect5(c, &opts, &connect_props, NULL);
|
|
assert("Good rc from connect", response.reasonCode == MQTTCLIENT_SUCCESS, "rc was %d", response.reasonCode);
|
|
if (response.reasonCode != MQTTCLIENT_SUCCESS)
|
|
goto exit;
|
|
|
|
if (response.properties)
|
|
{
|
|
if (MQTTProperties_hasProperty(response.properties, MQTTPROPERTY_CODE_TOPIC_ALIAS_MAXIMUM))
|
|
topicAliasMaximum = (int)MQTTProperties_getNumericValue(response.properties, MQTTPROPERTY_CODE_TOPIC_ALIAS_MAXIMUM);
|
|
|
|
logProperties(response.properties);
|
|
MQTTResponse_free(response);
|
|
}
|
|
assert("topicAliasMaximum > 0", topicAliasMaximum > 0, "topicAliasMaximum was %d", topicAliasMaximum);
|
|
|
|
/* subscribe to a topic */
|
|
response = MQTTClient_subscribe5(c, test_topic, 2, NULL, NULL);
|
|
assert("Good rc from subscribe", response.reasonCode == MQTTREASONCODE_GRANTED_QOS_2, "rc was %d", response.reasonCode);
|
|
|
|
/* then publish to the topic */
|
|
MQTTProperties_free(&pubmsg.properties);
|
|
property.identifier = MQTTPROPERTY_CODE_TOPIC_ALIAS;
|
|
property.value.integer2 = 1;
|
|
MQTTProperties_add(&pubmsg.properties, &property);
|
|
|
|
messages_arrived = 0;
|
|
response = MQTTClient_publishMessage5(c, test_topic, &pubmsg, &dt);
|
|
assert("Good rc from publish", response.reasonCode == MQTTCLIENT_SUCCESS, "rc was %d", response.reasonCode);
|
|
|
|
/* should get a response */
|
|
while (messages_arrived == 0 && ++count < 10)
|
|
{
|
|
#if defined(_WIN32)
|
|
Sleep(1000);
|
|
#else
|
|
usleep(1000000L);
|
|
#endif
|
|
}
|
|
assert("1 message should have arrived", messages_arrived == 1, "was %d", messages_arrived);
|
|
|
|
/* now publish to the topic alias only */
|
|
messages_arrived = 0;
|
|
response = MQTTClient_publishMessage5(c, "", &pubmsg, &dt);
|
|
assert("Good rc from publish", response.reasonCode == MQTTCLIENT_SUCCESS, "rc was %d", response.reasonCode);
|
|
|
|
/* should get a response */
|
|
while (messages_arrived == 0 && ++count < 10)
|
|
{
|
|
#if defined(_WIN32)
|
|
Sleep(1000);
|
|
#else
|
|
usleep(1000000L);
|
|
#endif
|
|
}
|
|
assert("1 message should have arrived", messages_arrived == 1, "was %d", messages_arrived);
|
|
|
|
rc = MQTTClient_disconnect5(c, 1000, MQTTREASONCODE_SUCCESS, NULL);
|
|
|
|
/* Reconnect. Topic aliases should be deleted, but not subscription */
|
|
opts.cleanstart = 0;
|
|
response = MQTTClient_connect5(c, &opts, NULL, NULL);
|
|
assert("Good rc from connect", response.reasonCode == MQTTCLIENT_SUCCESS, "rc was %d", response.reasonCode);
|
|
MQTTResponse_free(response);
|
|
if (response.reasonCode != MQTTCLIENT_SUCCESS)
|
|
goto exit;
|
|
|
|
/* then publish to the topic */
|
|
MQTTProperties_free(&pubmsg.properties);
|
|
messages_arrived = 0;
|
|
response = MQTTClient_publishMessage5(c, test_topic, &pubmsg, &dt);
|
|
assert("Good rc from publish", response.reasonCode == MQTTCLIENT_SUCCESS, "rc was %d", response.reasonCode);
|
|
|
|
/* should get a response */
|
|
while (messages_arrived == 0 && ++count < 10)
|
|
{
|
|
#if defined(_WIN32)
|
|
Sleep(1000);
|
|
#else
|
|
usleep(1000000L);
|
|
#endif
|
|
}
|
|
assert("1 message should have arrived", messages_arrived == 1, "was %d", messages_arrived);
|
|
|
|
/* now publish to the topic alias only */
|
|
test_topic_aliases_globals.disconnected = 0;
|
|
messages_arrived = 0;
|
|
property.identifier = MQTTPROPERTY_CODE_TOPIC_ALIAS;
|
|
property.value.integer2 = 1;
|
|
MQTTProperties_add(&pubmsg.properties, &property);
|
|
response = MQTTClient_publishMessage5(c, "", &pubmsg, &dt);
|
|
assert("Good rc from publish", response.reasonCode == MQTTCLIENT_SUCCESS, "rc was %d", response.reasonCode);
|
|
|
|
/* should not get a response */
|
|
while (messages_arrived == 0 && ++count < 10)
|
|
{
|
|
#if defined(_WIN32)
|
|
Sleep(1000);
|
|
#else
|
|
usleep(1000000L);
|
|
#endif
|
|
}
|
|
assert("No message should have arrived", messages_arrived == 0, "was %d", messages_arrived);
|
|
|
|
/* Now we expect to receive a disconnect packet telling us why */
|
|
count = 0;
|
|
while (test_topic_aliases_globals.disconnected == 0 && ++count < 10)
|
|
{
|
|
#if defined(_WIN32)
|
|
Sleep(1000);
|
|
#else
|
|
usleep(1000000L);
|
|
#endif
|
|
}
|
|
assert("Disconnected should be called", test_topic_aliases_globals.disconnected == 1,
|
|
"was %d", test_topic_aliases_globals.disconnected);
|
|
|
|
MQTTProperties_free(&pubmsg.properties);
|
|
MQTTProperties_free(&props);
|
|
MQTTProperties_free(&connect_props);
|
|
MQTTClient_destroy(&c);
|
|
|
|
exit:
|
|
MyLog(LOGA_INFO, "TEST1: test %s. %d tests run, %d failures.",
|
|
(failures == 0) ? "passed" : "failed", tests, failures);
|
|
write_test_result();
|
|
return failures;
|
|
}
|
|
|
|
|
|
|
|
int test2_messageArrived(void* context, char* topicName, int topicLen, MQTTClient_message* message)
|
|
{
|
|
static int received = 0;
|
|
static int first_topic_alias = 0;
|
|
int topicAlias = 0;
|
|
|
|
received++;
|
|
MyLog(LOGA_DEBUG, "Callback: message received on topic %s is %.*s.",
|
|
topicName, message->payloadlen, (char*)(message->payload));
|
|
|
|
assert("Message structure version should be 1", message->struct_version == 1,
|
|
"message->struct_version was %d", message->struct_version);
|
|
if (message->struct_version == 1)
|
|
{
|
|
const int props_count = 0;
|
|
|
|
if (MQTTProperties_hasProperty(&message->properties, MQTTPROPERTY_CODE_TOPIC_ALIAS))
|
|
topicAlias = (int)MQTTProperties_getNumericValue(&message->properties, MQTTPROPERTY_CODE_TOPIC_ALIAS);
|
|
|
|
if (received == 1)
|
|
first_topic_alias = topicAlias;
|
|
else
|
|
assert("All topic aliases should be the same", topicAlias == first_topic_alias,
|
|
"Topic alias was %d\n", topicAlias);
|
|
|
|
assert("topicAlias should not be 0", topicAlias > 0, "Topic alias was %d\n", topicAlias);
|
|
logProperties(&message->properties);
|
|
}
|
|
messages_arrived++;
|
|
|
|
MQTTClient_free(topicName);
|
|
MQTTClient_freeMessage(&message);
|
|
return 1;
|
|
}
|
|
|
|
|
|
int test_server_topic_aliases(struct Options options)
|
|
{
|
|
int subsqos = 2;
|
|
MQTTClient c;
|
|
MQTTClient_connectOptions opts = MQTTClient_connectOptions_initializer5;
|
|
MQTTClient_willOptions wopts = MQTTClient_willOptions_initializer;
|
|
MQTTProperties connect_props = MQTTProperties_initializer;
|
|
MQTTProperty property;
|
|
MQTTClient_message pubmsg = MQTTClient_message_initializer;
|
|
MQTTResponse response = MQTTResponse_initializer;
|
|
MQTTClient_deliveryToken dt;
|
|
int rc = 0;
|
|
int count = 0;
|
|
char* test_topic = "test_server_topic_aliases";
|
|
int topicAliasMaximum = 0;
|
|
int qos = 0;
|
|
const int msg_count = 3;
|
|
MQTTClient_createOptions createOpts = MQTTClient_createOptions_initializer;
|
|
|
|
fprintf(xml, "<testcase classname=\"test_server_topic_aliases\" name=\"server topic aliases\"");
|
|
global_start_time = start_clock();
|
|
failures = 0;
|
|
MyLog(LOGA_INFO, "Starting test 2 - server topic aliases");
|
|
|
|
createOpts.MQTTVersion = MQTTVERSION_5;
|
|
rc = MQTTClient_createWithOptions(&c, options.connection, "server_topic_alias_test",
|
|
MQTTCLIENT_PERSISTENCE_DEFAULT, NULL, &createOpts);
|
|
assert("good rc from create", rc == MQTTCLIENT_SUCCESS, "rc was %d\n", rc);
|
|
if (rc != MQTTCLIENT_SUCCESS)
|
|
{
|
|
MQTTClient_destroy(&c);
|
|
goto exit;
|
|
}
|
|
|
|
rc = MQTTClient_setCallbacks(c, NULL, NULL, test2_messageArrived, NULL);
|
|
assert("Good rc from setCallbacks", rc == MQTTCLIENT_SUCCESS, "rc was %d", rc);
|
|
|
|
opts.keepAliveInterval = 20;
|
|
opts.cleanstart = 1;
|
|
opts.MQTTVersion = options.MQTTVersion;
|
|
if (options.haconnections != NULL)
|
|
{
|
|
opts.serverURIs = options.haconnections;
|
|
opts.serverURIcount = options.hacount;
|
|
}
|
|
|
|
/* Allow at least one server topic alias */
|
|
property.identifier = MQTTPROPERTY_CODE_TOPIC_ALIAS_MAXIMUM;
|
|
property.value.integer2 = 1;
|
|
MQTTProperties_add(&connect_props, &property);
|
|
|
|
MyLog(LOGA_DEBUG, "Connecting");
|
|
response = MQTTClient_connect5(c, &opts, &connect_props, NULL);
|
|
assert("Good rc from connect", response.reasonCode == MQTTCLIENT_SUCCESS, "rc was %d", response.reasonCode);
|
|
if (response.reasonCode != MQTTCLIENT_SUCCESS)
|
|
goto exit;
|
|
|
|
if (response.properties)
|
|
{
|
|
if (MQTTProperties_hasProperty(response.properties, MQTTPROPERTY_CODE_TOPIC_ALIAS_MAXIMUM))
|
|
topicAliasMaximum = (int)MQTTProperties_getNumericValue(response.properties, MQTTPROPERTY_CODE_TOPIC_ALIAS_MAXIMUM);
|
|
|
|
logProperties(response.properties);
|
|
MQTTResponse_free(response);
|
|
}
|
|
|
|
/* subscribe to a topic */
|
|
response = MQTTClient_subscribe5(c, test_topic, 2, NULL, NULL);
|
|
assert("Good rc from subscribe", response.reasonCode == MQTTREASONCODE_GRANTED_QOS_2, "rc was %d", response.reasonCode);
|
|
|
|
messages_arrived = 0;
|
|
pubmsg.payload = "a much longer message that we can shorten to the extent that we need to payload up to 11";
|
|
pubmsg.payloadlen = 11;
|
|
pubmsg.retained = 0;
|
|
for (qos = 0; qos < msg_count; ++qos)
|
|
{
|
|
pubmsg.qos = qos;
|
|
response = MQTTClient_publishMessage5(c, test_topic, &pubmsg, &dt);
|
|
assert("Good rc from publish", response.reasonCode == MQTTCLIENT_SUCCESS, "rc was %d", response.reasonCode);
|
|
}
|
|
|
|
/* should get responses */
|
|
while (messages_arrived < msg_count && ++count < 10)
|
|
{
|
|
#if defined(_WIN32)
|
|
Sleep(1000);
|
|
#else
|
|
usleep(1000000L);
|
|
#endif
|
|
}
|
|
assert("3 messages should have arrived", messages_arrived == msg_count, "was %d", messages_arrived);
|
|
|
|
rc = MQTTClient_disconnect5(c, 1000, MQTTREASONCODE_SUCCESS, NULL);
|
|
|
|
MQTTProperties_free(&pubmsg.properties);
|
|
MQTTProperties_free(&connect_props);
|
|
MQTTClient_destroy(&c);
|
|
|
|
exit:
|
|
MyLog(LOGA_INFO, "TEST2: test %s. %d tests run, %d failures.",
|
|
(failures == 0) ? "passed" : "failed", tests, failures);
|
|
write_test_result();
|
|
return failures;
|
|
}
|
|
|
|
|
|
|
|
int test_subscription_ids_messageArrived(void* context, char* topicName, int topicLen, MQTTClient_message* message)
|
|
{
|
|
static int received = 0;
|
|
static int first_topic_alias = 0;
|
|
int topicAlias = 0;
|
|
|
|
received++;
|
|
MyLog(LOGA_DEBUG, "Callback: message received on topic %s is %.*s.",
|
|
topicName, message->payloadlen, (char*)(message->payload));
|
|
|
|
assert("Message structure version should be 1", message->struct_version == 1,
|
|
"message->struct_version was %d", message->struct_version);
|
|
if (message->struct_version == 1)
|
|
{
|
|
int subsidcount = 0, i = 0;
|
|
|
|
subsidcount = MQTTProperties_propertyCount(&message->properties, MQTTPROPERTY_CODE_SUBSCRIPTION_IDENTIFIER);
|
|
|
|
for (i = 0; i < subsidcount; ++i)
|
|
{
|
|
int subsid = (int)MQTTProperties_getNumericValueAt(&message->properties, MQTTPROPERTY_CODE_SUBSCRIPTION_IDENTIFIER, i);
|
|
assert("Subsid is i+1", subsid == i+1, "subsid is not correct %d\n", subsid);
|
|
}
|
|
logProperties(&message->properties);
|
|
}
|
|
messages_arrived++;
|
|
|
|
MQTTClient_free(topicName);
|
|
MQTTClient_freeMessage(&message);
|
|
return 1;
|
|
}
|
|
|
|
|
|
int test_subscription_ids(struct Options options)
|
|
{
|
|
int subsqos = 2;
|
|
MQTTClient c;
|
|
MQTTClient_connectOptions opts = MQTTClient_connectOptions_initializer5;
|
|
MQTTProperties connect_props = MQTTProperties_initializer;
|
|
MQTTProperties subs_props = MQTTProperties_initializer;
|
|
MQTTProperty property;
|
|
MQTTClient_message pubmsg = MQTTClient_message_initializer;
|
|
MQTTResponse response = MQTTResponse_initializer;
|
|
MQTTClient_deliveryToken dt;
|
|
int rc = 0;
|
|
int count = 0;
|
|
char* test_topic = "test_subscription_ids";
|
|
const int msg_count = 1;
|
|
int subsids = 1;
|
|
MQTTClient_createOptions createOpts = MQTTClient_createOptions_initializer;
|
|
|
|
fprintf(xml, "<testcase classname=\"test_subscription_ids\" name=\"subscription ids\"");
|
|
global_start_time = start_clock();
|
|
failures = 0;
|
|
MyLog(LOGA_INFO, "Starting test 3 - subscription ids");
|
|
|
|
createOpts.MQTTVersion = MQTTVERSION_5;
|
|
rc = MQTTClient_createWithOptions(&c, options.connection, "subscription_ids",
|
|
MQTTCLIENT_PERSISTENCE_DEFAULT, NULL, &createOpts);
|
|
assert("good rc from create", rc == MQTTCLIENT_SUCCESS, "rc was %d\n", rc);
|
|
if (rc != MQTTCLIENT_SUCCESS)
|
|
{
|
|
MQTTClient_destroy(&c);
|
|
goto exit;
|
|
}
|
|
|
|
rc = MQTTClient_setCallbacks(c, NULL, NULL, test_subscription_ids_messageArrived, NULL);
|
|
assert("Good rc from setCallbacks", rc == MQTTCLIENT_SUCCESS, "rc was %d", rc);
|
|
|
|
opts.keepAliveInterval = 20;
|
|
opts.cleanstart = 1;
|
|
opts.MQTTVersion = options.MQTTVersion;
|
|
if (options.haconnections != NULL)
|
|
{
|
|
opts.serverURIs = options.haconnections;
|
|
opts.serverURIcount = options.hacount;
|
|
}
|
|
|
|
MyLog(LOGA_DEBUG, "Connecting");
|
|
response = MQTTClient_connect5(c, &opts, &connect_props, NULL);
|
|
assert("Good rc from connect", response.reasonCode == MQTTCLIENT_SUCCESS, "rc was %d", response.reasonCode);
|
|
if (response.reasonCode != MQTTCLIENT_SUCCESS)
|
|
goto exit;
|
|
|
|
if (response.properties)
|
|
{
|
|
if (MQTTProperties_hasProperty(response.properties, MQTTPROPERTY_CODE_SUBSCRIPTION_IDENTIFIERS_AVAILABLE))
|
|
subsids = (int)MQTTProperties_getNumericValue(response.properties, MQTTPROPERTY_CODE_SUBSCRIPTION_IDENTIFIERS_AVAILABLE);
|
|
|
|
logProperties(response.properties);
|
|
MQTTResponse_free(response);
|
|
}
|
|
assert("Subscription ids must be available", subsids == 1, "subsids is %d", subsids);
|
|
|
|
/* subscribe to the test topic */
|
|
property.identifier = MQTTPROPERTY_CODE_SUBSCRIPTION_IDENTIFIER;
|
|
property.value.integer4 = 1;
|
|
MQTTProperties_add(&subs_props, &property);
|
|
response = MQTTClient_subscribe5(c, test_topic, 2, NULL, &subs_props);
|
|
assert("Good rc from subscribe", response.reasonCode == MQTTREASONCODE_GRANTED_QOS_2, "rc was %d", response.reasonCode);
|
|
|
|
/* now to an overlapping topic */
|
|
property.value.integer4 = 2;
|
|
subs_props.array[0].value.integer4 = 2;
|
|
response = MQTTClient_subscribe5(c, "+", 2, NULL, &subs_props);
|
|
assert("Good rc from subscribe", response.reasonCode == MQTTREASONCODE_GRANTED_QOS_2, "rc was %d", response.reasonCode);
|
|
|
|
messages_arrived = 0;
|
|
pubmsg.payload = "a much longer message that we can shorten to the extent that we need to payload up to 11";
|
|
pubmsg.payloadlen = 11;
|
|
pubmsg.retained = 0;
|
|
pubmsg.qos = 2;
|
|
|
|
response = MQTTClient_publishMessage5(c, test_topic, &pubmsg, &dt);
|
|
assert("Good rc from publish", response.reasonCode == MQTTCLIENT_SUCCESS, "rc was %d", response.reasonCode);
|
|
|
|
/* should get responses */
|
|
while (messages_arrived < msg_count && ++count < 10)
|
|
{
|
|
#if defined(_WIN32)
|
|
Sleep(1000);
|
|
#else
|
|
usleep(1000000L);
|
|
#endif
|
|
}
|
|
assert("1 message should have arrived", messages_arrived == msg_count, "was %d", messages_arrived);
|
|
|
|
rc = MQTTClient_disconnect5(c, 1000, MQTTREASONCODE_SUCCESS, NULL);
|
|
|
|
MQTTProperties_free(&pubmsg.properties);
|
|
MQTTProperties_free(&subs_props);
|
|
MQTTProperties_free(&connect_props);
|
|
MQTTClient_destroy(&c);
|
|
|
|
exit:
|
|
MyLog(LOGA_INFO, "TEST3: test %s. %d tests run, %d failures.",
|
|
(failures == 0) ? "passed" : "failed", tests, failures);
|
|
write_test_result();
|
|
return failures;
|
|
}
|
|
|
|
|
|
int test_flow_control_messageArrived(void* context, char* topicName, int topicLen, MQTTClient_message* message)
|
|
{
|
|
static int received = 0;
|
|
static int first_topic_alias = 0;
|
|
int topicAlias = 0;
|
|
|
|
received++;
|
|
MyLog(LOGA_DEBUG, "Callback: message received on topic %s is %.*s.",
|
|
topicName, message->payloadlen, (char*)(message->payload));
|
|
|
|
assert("Message structure version should be 1", message->struct_version == 1,
|
|
"message->struct_version was %d", message->struct_version);
|
|
messages_arrived++;
|
|
|
|
MQTTClient_free(topicName);
|
|
MQTTClient_freeMessage(&message);
|
|
return 1;
|
|
}
|
|
|
|
static int blocking_found = 0;
|
|
|
|
void test_flow_control_trace_callback(enum MQTTCLIENT_TRACE_LEVELS level, char* message)
|
|
{
|
|
static char* msg = "Blocking publish on queue full";
|
|
|
|
if (strstr(message, msg) != NULL)
|
|
blocking_found = 1;
|
|
}
|
|
|
|
|
|
int test_flow_control(struct Options options)
|
|
{
|
|
int subsqos = 2;
|
|
MQTTClient c;
|
|
MQTTClient_connectOptions opts = MQTTClient_connectOptions_initializer5;
|
|
MQTTProperties connect_props = MQTTProperties_initializer;
|
|
MQTTClient_message pubmsg = MQTTClient_message_initializer;
|
|
MQTTResponse response = MQTTResponse_initializer;
|
|
MQTTClient_deliveryToken dt;
|
|
int rc = 0, i = 0, count = 0;
|
|
char* test_topic = "test_flow_control";
|
|
int receive_maximum = 65535;
|
|
MQTTClient_createOptions createOpts = MQTTClient_createOptions_initializer;
|
|
|
|
fprintf(xml, "<testcase classname=\"test_flow_control\" name=\"flow control\"");
|
|
global_start_time = start_clock();
|
|
failures = 0;
|
|
MyLog(LOGA_INFO, "Starting test - flow control");
|
|
|
|
MQTTClient_setTraceLevel(MQTTCLIENT_TRACE_MINIMUM); /* to get the blocking trace message */
|
|
|
|
createOpts.MQTTVersion = MQTTVERSION_5;
|
|
rc = MQTTClient_createWithOptions(&c, options.connection, "flow_control",
|
|
MQTTCLIENT_PERSISTENCE_DEFAULT, NULL, &createOpts);
|
|
assert("good rc from create", rc == MQTTCLIENT_SUCCESS, "rc was %d\n", rc);
|
|
if (rc != MQTTCLIENT_SUCCESS)
|
|
goto exit;
|
|
|
|
rc = MQTTClient_setCallbacks(c, NULL, NULL, test_flow_control_messageArrived, NULL);
|
|
assert("Good rc from setCallbacks", rc == MQTTCLIENT_SUCCESS, "rc was %d", rc);
|
|
|
|
opts.keepAliveInterval = 20;
|
|
opts.cleanstart = 1;
|
|
opts.MQTTVersion = options.MQTTVersion;
|
|
opts.reliable = 0;
|
|
opts.maxInflightMessages = 100;
|
|
if (options.haconnections != NULL)
|
|
{
|
|
opts.serverURIs = options.haconnections;
|
|
opts.serverURIcount = options.hacount;
|
|
}
|
|
|
|
MyLog(LOGA_DEBUG, "Connecting");
|
|
response = MQTTClient_connect5(c, &opts, &connect_props, NULL);
|
|
assert("Good rc from connect", response.reasonCode == MQTTCLIENT_SUCCESS, "rc was %d", response.reasonCode);
|
|
if (response.reasonCode != MQTTCLIENT_SUCCESS)
|
|
goto exit;
|
|
|
|
if (response.properties)
|
|
{
|
|
if (MQTTProperties_hasProperty(response.properties, MQTTPROPERTY_CODE_RECEIVE_MAXIMUM))
|
|
receive_maximum = (int)MQTTProperties_getNumericValue(response.properties, MQTTPROPERTY_CODE_RECEIVE_MAXIMUM);
|
|
|
|
logProperties(response.properties);
|
|
MQTTResponse_free(response);
|
|
}
|
|
|
|
response = MQTTClient_subscribe5(c, test_topic, 2, NULL, NULL);
|
|
assert("Good rc from subscribe", response.reasonCode == MQTTREASONCODE_GRANTED_QOS_2, "rc was %d", response.reasonCode);
|
|
|
|
messages_arrived = 0;
|
|
pubmsg.payload = "a much longer message that we can shorten to the extent that we need to payload up to 11";
|
|
pubmsg.payloadlen = 11;
|
|
pubmsg.retained = 0;
|
|
pubmsg.qos = 2;
|
|
for (i = 0; i < receive_maximum + 2; ++i)
|
|
{
|
|
response = MQTTClient_publishMessage5(c, test_topic, &pubmsg, &dt);
|
|
assert("Good rc from publish", response.reasonCode == MQTTCLIENT_SUCCESS, "rc was %d", response.reasonCode);
|
|
}
|
|
|
|
/* should get responses */
|
|
while (messages_arrived < receive_maximum + 2 && ++count < 10)
|
|
{
|
|
#if defined(_WIN32)
|
|
Sleep(1000);
|
|
#else
|
|
usleep(1000000L);
|
|
#endif
|
|
}
|
|
assert("messages should have arrived", messages_arrived == receive_maximum + 2, "was %d", messages_arrived);
|
|
assert("should have blocked", blocking_found == 1, "was %d\n", blocking_found);
|
|
|
|
rc = MQTTClient_disconnect5(c, 1000, MQTTREASONCODE_SUCCESS, NULL);
|
|
|
|
exit:
|
|
MQTTClient_setTraceCallback(NULL);
|
|
MQTTProperties_free(&pubmsg.properties);
|
|
MQTTProperties_free(&connect_props);
|
|
MQTTClient_destroy(&c);
|
|
|
|
MyLog(LOGA_INFO, "TEST3: test %s. %d tests run, %d failures.",
|
|
(failures == 0) ? "passed" : "failed", tests, failures);
|
|
write_test_result();
|
|
return failures;
|
|
}
|
|
|
|
|
|
int test_error_reporting(struct Options options)
|
|
{
|
|
int subsqos = 2;
|
|
MQTTClient c;
|
|
MQTTClient_connectOptions opts = MQTTClient_connectOptions_initializer5;
|
|
MQTTProperties props = MQTTProperties_initializer;
|
|
MQTTProperty property;
|
|
MQTTResponse response = MQTTResponse_initializer;
|
|
int rc = 0, i = 0, count = 0;
|
|
char* test_topic = "test_error_reporting";
|
|
int receive_maximum = 65535;
|
|
MQTTClient_createOptions createOpts = MQTTClient_createOptions_initializer;
|
|
|
|
fprintf(xml, "<testcase classname=\"test_error_reporting\" name=\"error reporting\"");
|
|
global_start_time = start_clock();
|
|
failures = 0;
|
|
MyLog(LOGA_INFO, "Starting test - error reporting");
|
|
|
|
//MQTTClient_setTraceCallback(test_flow_control_trace_callback);
|
|
|
|
createOpts.MQTTVersion = MQTTVERSION_5;
|
|
rc = MQTTClient_createWithOptions(&c, options.connection, "error_reporting",
|
|
MQTTCLIENT_PERSISTENCE_DEFAULT, NULL, &createOpts);
|
|
assert("good rc from create", rc == MQTTCLIENT_SUCCESS, "rc was %d\n", rc);
|
|
if (rc != MQTTCLIENT_SUCCESS)
|
|
goto exit;
|
|
|
|
rc = MQTTClient_setCallbacks(c, NULL, NULL, test_flow_control_messageArrived, NULL);
|
|
assert("Good rc from setCallbacks", rc == MQTTCLIENT_SUCCESS, "rc was %d", rc);
|
|
|
|
opts.MQTTVersion = options.MQTTVersion;
|
|
if (options.haconnections != NULL)
|
|
{
|
|
opts.serverURIs = options.haconnections;
|
|
opts.serverURIcount = options.hacount;
|
|
}
|
|
|
|
MyLog(LOGA_DEBUG, "Connecting");
|
|
response = MQTTClient_connect5(c, &opts, NULL, NULL);
|
|
assert("Good rc from connect", response.reasonCode == MQTTCLIENT_SUCCESS, "rc was %d", response.reasonCode);
|
|
if (response.reasonCode != MQTTCLIENT_SUCCESS)
|
|
goto exit;
|
|
|
|
if (response.properties)
|
|
{
|
|
if (MQTTProperties_hasProperty(response.properties, MQTTPROPERTY_CODE_RECEIVE_MAXIMUM))
|
|
receive_maximum = (int)MQTTProperties_getNumericValue(response.properties, MQTTPROPERTY_CODE_RECEIVE_MAXIMUM);
|
|
|
|
logProperties(response.properties);
|
|
MQTTResponse_free(response);
|
|
}
|
|
|
|
property.identifier = MQTTPROPERTY_CODE_USER_PROPERTY;
|
|
property.value.data.data = "unsub user property";
|
|
property.value.data.len = (int)strlen(property.value.data.data);
|
|
property.value.value.data = "unsub user property value";
|
|
property.value.value.len = (int)strlen(property.value.value.data);
|
|
MQTTProperties_add(&props, &property);
|
|
response = MQTTClient_subscribe5(c, test_topic, 2, NULL, &props);
|
|
assert("Good rc from subscribe", response.reasonCode == MQTTREASONCODE_GRANTED_QOS_2, "rc was %d", response.reasonCode);
|
|
assert("Properties should exist", response.properties != NULL, "props was %p", response.properties);
|
|
if (response.properties)
|
|
{
|
|
logProperties(response.properties);
|
|
MQTTResponse_free(response);
|
|
}
|
|
|
|
response = MQTTClient_unsubscribe5(c, test_topic, &props);
|
|
assert("Good rc from unsubscribe", response.reasonCode == MQTTCLIENT_SUCCESS, "rc was %d", response.reasonCode);
|
|
assert("Properties should exist", response.properties != NULL, "props was %p", response.properties);
|
|
if (response.properties)
|
|
{
|
|
logProperties(response.properties);
|
|
MQTTResponse_free(response);
|
|
}
|
|
|
|
rc = MQTTClient_disconnect5(c, 1000, MQTTREASONCODE_SUCCESS, NULL);
|
|
|
|
exit:
|
|
MQTTClient_setTraceCallback(NULL);
|
|
MQTTProperties_free(&props);
|
|
MQTTClient_destroy(&c);
|
|
|
|
MyLog(LOGA_INFO, "TEST3: test %s. %d tests run, %d failures.",
|
|
(failures == 0) ? "passed" : "failed", tests, failures);
|
|
write_test_result();
|
|
return failures;
|
|
}
|
|
|
|
struct
|
|
{
|
|
int published;
|
|
int packet_type;
|
|
enum MQTTReasonCodes rc;
|
|
} test_qos_1_2_errors_globals =
|
|
{
|
|
0, -1, MQTTREASONCODE_SUCCESS
|
|
};
|
|
|
|
|
|
void published(void* context, int msgid, int packet_type, MQTTProperties* props, enum MQTTReasonCodes rc)
|
|
{
|
|
MQTTClient c = (MQTTClient)context;
|
|
MyLog(LOGA_INFO, "Callback: published, reason code \"%s\" msgid: %d packet type: %d",
|
|
MQTTReasonCode_toString(rc), msgid, packet_type);
|
|
test_qos_1_2_errors_globals.packet_type = packet_type;
|
|
test_qos_1_2_errors_globals.rc = rc;
|
|
if (props)
|
|
{
|
|
MyLog(LOGA_INFO, "Callback: published, properties:");
|
|
logProperties(props);
|
|
}
|
|
test_qos_1_2_errors_globals.published = 1;
|
|
}
|
|
|
|
void test_trace_callback(enum MQTTCLIENT_TRACE_LEVELS level, char* message)
|
|
{
|
|
printf("%s\n", message);
|
|
}
|
|
|
|
enum msgTypes
|
|
{
|
|
CONNECT = 1, CONNACK, PUBLISH, PUBACK, PUBREC, PUBREL,
|
|
PUBCOMP, SUBSCRIBE, SUBACK, UNSUBSCRIBE, UNSUBACK,
|
|
PINGREQ, PINGRESP, DISCONNECT, AUTH
|
|
};
|
|
|
|
|
|
int test_qos_1_2_errors(struct Options options)
|
|
{
|
|
int subsqos = 2;
|
|
MQTTClient c;
|
|
MQTTClient_connectOptions opts = MQTTClient_connectOptions_initializer5;
|
|
MQTTProperties props = MQTTProperties_initializer;
|
|
MQTTProperty property;
|
|
MQTTResponse response = MQTTResponse_initializer;
|
|
MQTTClient_deliveryToken dt;
|
|
MQTTClient_message pubmsg = MQTTClient_message_initializer;
|
|
int rc = 0, i = 0, count = 0;
|
|
char* test_topic = "test_qos_1_2_errors";
|
|
int receive_maximum = 65535;
|
|
MQTTClient_createOptions createOpts = MQTTClient_createOptions_initializer;
|
|
|
|
fprintf(xml, "<testcase classname=\"test_qos_1_2_errors\" name=\"qos 1 2 errors\"");
|
|
global_start_time = start_clock();
|
|
failures = 0;
|
|
MyLog(LOGA_INFO, "Starting test - qos 1 and 2 errors");
|
|
|
|
//MQTTClient_setTraceCallback(test_trace_callback);
|
|
|
|
createOpts.MQTTVersion = MQTTVERSION_5;
|
|
rc = MQTTClient_createWithOptions(&c, options.connection, "error_reporting",
|
|
MQTTCLIENT_PERSISTENCE_DEFAULT, NULL, &createOpts);
|
|
assert("good rc from create", rc == MQTTCLIENT_SUCCESS, "rc was %d\n", rc);
|
|
if (rc != MQTTCLIENT_SUCCESS)
|
|
goto exit;
|
|
|
|
rc = MQTTClient_setCallbacks(c, NULL, NULL, test_flow_control_messageArrived, NULL);
|
|
assert("Good rc from setCallbacks", rc == MQTTCLIENT_SUCCESS, "rc was %d", rc);
|
|
|
|
rc = MQTTClient_setPublished(c, c, published);
|
|
assert("Good rc from setPublished", rc == MQTTCLIENT_SUCCESS, "rc was %d", rc);
|
|
|
|
opts.MQTTVersion = options.MQTTVersion;
|
|
if (options.haconnections != NULL)
|
|
{
|
|
opts.serverURIs = options.haconnections;
|
|
opts.serverURIcount = options.hacount;
|
|
}
|
|
|
|
MyLog(LOGA_DEBUG, "Connecting");
|
|
response = MQTTClient_connect5(c, &opts, NULL, NULL);
|
|
assert("Good rc from connect", response.reasonCode == MQTTCLIENT_SUCCESS, "rc was %d", response.reasonCode);
|
|
if (response.reasonCode != MQTTCLIENT_SUCCESS)
|
|
goto exit;
|
|
|
|
if (response.properties)
|
|
{
|
|
if (MQTTProperties_hasProperty(response.properties, MQTTPROPERTY_CODE_RECEIVE_MAXIMUM))
|
|
receive_maximum = (int)MQTTProperties_getNumericValue(response.properties, MQTTPROPERTY_CODE_RECEIVE_MAXIMUM);
|
|
|
|
logProperties(response.properties);
|
|
MQTTResponse_free(response);
|
|
}
|
|
|
|
pubmsg.payload = "a much longer message that we can shorten to the extent that we need to payload up to 11";
|
|
pubmsg.payloadlen = 11;
|
|
pubmsg.qos = 1;
|
|
pubmsg.retained = 0;
|
|
|
|
property.identifier = MQTTPROPERTY_CODE_USER_PROPERTY;
|
|
property.value.data.data = "unsub user property";
|
|
property.value.data.len = (int)strlen(property.value.data.data);
|
|
property.value.value.data = "unsub user property value";
|
|
property.value.value.len = (int)strlen(property.value.value.data);
|
|
MQTTProperties_add(&pubmsg.properties, &property);
|
|
|
|
response = MQTTClient_publishMessage5(c, test_topic, &pubmsg, &dt);
|
|
assert("Good rc from publish", response.reasonCode == MQTTREASONCODE_SUCCESS, "rc was %d", response.reasonCode);
|
|
|
|
count = 0;
|
|
while (test_qos_1_2_errors_globals.published == 0 && ++count < 10)
|
|
{
|
|
#if defined(_WIN32)
|
|
Sleep(1000);
|
|
#else
|
|
usleep(1000000L);
|
|
#endif
|
|
}
|
|
assert("Published called", test_qos_1_2_errors_globals.published == 1,
|
|
"published was %d", test_qos_1_2_errors_globals.published);
|
|
assert("Reason code was packet identifier not found",
|
|
test_qos_1_2_errors_globals.rc == MQTTREASONCODE_NOT_AUTHORIZED,
|
|
"Reason code was %d", test_qos_1_2_errors_globals.rc);
|
|
assert("Packet type was PUBACK", test_qos_1_2_errors_globals.packet_type == PUBACK,
|
|
"packet type was %d", test_qos_1_2_errors_globals.packet_type);
|
|
|
|
test_qos_1_2_errors_globals.published = 0;
|
|
pubmsg.qos = 2;
|
|
response = MQTTClient_publishMessage5(c, test_topic, &pubmsg, &dt);
|
|
assert("Good rc from publish", response.reasonCode == MQTTCLIENT_SUCCESS, "rc was %d", response.reasonCode);
|
|
|
|
count = 0;
|
|
while (test_qos_1_2_errors_globals.published == 0 && ++count < 10)
|
|
{
|
|
#if defined(_WIN32)
|
|
Sleep(1000);
|
|
#else
|
|
usleep(1000000L);
|
|
#endif
|
|
}
|
|
assert("Published called", test_qos_1_2_errors_globals.published == 1,
|
|
"published was %d", test_qos_1_2_errors_globals.published);
|
|
assert("Reason code was packet identifier not found",
|
|
test_qos_1_2_errors_globals.rc == MQTTREASONCODE_NOT_AUTHORIZED,
|
|
"Reason code was %d", test_qos_1_2_errors_globals.rc);
|
|
assert("Packet type was PUBREC", test_qos_1_2_errors_globals.packet_type == PUBREC,
|
|
"packet type was %d", test_qos_1_2_errors_globals.packet_type);
|
|
|
|
test_qos_1_2_errors_globals.published = 0;
|
|
response = MQTTClient_publishMessage5(c, "test_qos_1_2_errors_pubcomp", &pubmsg, &dt);
|
|
assert("Good rc from publish", response.reasonCode == MQTTREASONCODE_SUCCESS, "rc was %d", response.reasonCode);
|
|
|
|
count = 0;
|
|
while (test_qos_1_2_errors_globals.published == 0 && ++count < 10)
|
|
{
|
|
#if defined(_WIN32)
|
|
Sleep(1000);
|
|
#else
|
|
usleep(1000000L);
|
|
#endif
|
|
}
|
|
assert("Published called", test_qos_1_2_errors_globals.published == 1,
|
|
"published was %d", test_qos_1_2_errors_globals.published);
|
|
assert("Reason code was packet identifier not found",
|
|
test_qos_1_2_errors_globals.rc == MQTTREASONCODE_PACKET_IDENTIFIER_NOT_FOUND,
|
|
"Reason code was %d", test_qos_1_2_errors_globals.rc);
|
|
assert("Packet type was PUBCOMP", test_qos_1_2_errors_globals.packet_type == PUBCOMP,
|
|
"packet type was %d", test_qos_1_2_errors_globals.packet_type);
|
|
|
|
rc = MQTTClient_disconnect5(c, 1000, MQTTREASONCODE_SUCCESS, NULL);
|
|
|
|
exit:
|
|
MQTTClient_setTraceCallback(NULL);
|
|
MQTTProperties_free(&props);
|
|
MQTTProperties_free(&pubmsg.properties);
|
|
MQTTClient_destroy(&c);
|
|
|
|
MyLog(LOGA_INFO, "TEST6: test %s. %d tests run, %d failures.",
|
|
(failures == 0) ? "passed" : "failed", tests, failures);
|
|
write_test_result();
|
|
return failures;
|
|
}
|
|
|
|
|
|
struct
|
|
{
|
|
char* response_topic;
|
|
char* request_topic;
|
|
int messages_arrived;
|
|
char* correlation_id;
|
|
} test_request_response_globals =
|
|
{
|
|
"my response topic",
|
|
"my request topic",
|
|
0,
|
|
"request no 1",
|
|
};
|
|
|
|
|
|
int test_request_response_messageArrived(void* context, char* topicName, int topicLen, MQTTClient_message* message)
|
|
{
|
|
MyLog(LOGA_DEBUG, "Callback: message received on topic %s is %.*s.",
|
|
topicName, message->payloadlen, (char*)(message->payload));
|
|
|
|
assert("Message structure version should be 1", message->struct_version == 1,
|
|
"message->struct_version was %d", message->struct_version);
|
|
if (message->struct_version == 1)
|
|
{
|
|
const int props_count = 0;
|
|
|
|
MyLog(LOGA_INFO, "Message properties:");
|
|
logProperties(&message->properties);
|
|
}
|
|
test_request_response_globals.messages_arrived++;
|
|
|
|
if (test_request_response_globals.messages_arrived == 1)
|
|
{
|
|
MQTTProperty *prop;
|
|
|
|
assert("Topic should be request",
|
|
strcmp(test_request_response_globals.request_topic, topicName) == 0,
|
|
"topic was %s\n", topicName);
|
|
|
|
if (MQTTProperties_hasProperty(&message->properties, MQTTPROPERTY_CODE_RESPONSE_TOPIC))
|
|
prop = MQTTProperties_getProperty(&message->properties, MQTTPROPERTY_CODE_RESPONSE_TOPIC);
|
|
|
|
assert("Topic should be response",
|
|
strncmp(test_request_response_globals.response_topic, prop->value.data.data, prop->value.data.len) == 0,
|
|
"topic was %.4s\n", prop->value.data.data);
|
|
|
|
if (MQTTProperties_hasProperty(&message->properties, MQTTPROPERTY_CODE_CORRELATION_DATA))
|
|
prop = MQTTProperties_getProperty(&message->properties, MQTTPROPERTY_CODE_CORRELATION_DATA);
|
|
|
|
assert("Correlation data should be",
|
|
strncmp(test_request_response_globals.correlation_id, prop->value.data.data, prop->value.data.len) == 0,
|
|
"Correlation data was %.4s\n", prop->value.data.data);
|
|
|
|
}
|
|
else if (test_request_response_globals.messages_arrived == 2)
|
|
{
|
|
assert("Topic should be response",
|
|
strcmp(test_request_response_globals.response_topic, topicName) == 0,
|
|
"topic was %s\n", topicName);
|
|
}
|
|
|
|
MQTTClient_free(topicName);
|
|
MQTTClient_freeMessage(&message);
|
|
return 1;
|
|
}
|
|
|
|
|
|
int test_request_response(struct Options options)
|
|
{
|
|
int subsqos = 2;
|
|
MQTTClient c;
|
|
MQTTClient_connectOptions opts = MQTTClient_connectOptions_initializer5;
|
|
MQTTProperties connect_props = MQTTProperties_initializer;
|
|
MQTTProperties subs_props = MQTTProperties_initializer;
|
|
MQTTProperty property;
|
|
MQTTClient_message pubmsg = MQTTClient_message_initializer;
|
|
MQTTResponse response = MQTTResponse_initializer;
|
|
MQTTClient_deliveryToken dt;
|
|
int rc = 0;
|
|
int count = 0;
|
|
char* test_topic = "test_request_response";
|
|
const int msg_count = 1;
|
|
int subsids = 1;
|
|
MQTTClient_createOptions createOpts = MQTTClient_createOptions_initializer;
|
|
|
|
fprintf(xml, "<testcase classname=\"test_request_response\" name=\"request/response\"");
|
|
global_start_time = start_clock();
|
|
failures = 0;
|
|
MyLog(LOGA_INFO, "Starting test 7 - request response");
|
|
|
|
createOpts.MQTTVersion = MQTTVERSION_5;
|
|
rc = MQTTClient_createWithOptions(&c, options.connection, "request_response",
|
|
MQTTCLIENT_PERSISTENCE_DEFAULT, NULL, &createOpts);
|
|
assert("good rc from create", rc == MQTTCLIENT_SUCCESS, "rc was %d\n", rc);
|
|
if (rc != MQTTCLIENT_SUCCESS)
|
|
{
|
|
MQTTClient_destroy(&c);
|
|
goto exit;
|
|
}
|
|
|
|
rc = MQTTClient_setCallbacks(c, NULL, NULL, test_request_response_messageArrived, NULL);
|
|
assert("Good rc from setCallbacks", rc == MQTTCLIENT_SUCCESS, "rc was %d", rc);
|
|
|
|
opts.keepAliveInterval = 20;
|
|
opts.cleanstart = 1;
|
|
opts.MQTTVersion = options.MQTTVersion;
|
|
if (options.haconnections != NULL)
|
|
{
|
|
opts.serverURIs = options.haconnections;
|
|
opts.serverURIcount = options.hacount;
|
|
}
|
|
|
|
MyLog(LOGA_DEBUG, "Connecting");
|
|
response = MQTTClient_connect5(c, &opts, &connect_props, NULL);
|
|
assert("Good rc from connect", response.reasonCode == MQTTCLIENT_SUCCESS, "rc was %d", response.reasonCode);
|
|
if (response.reasonCode != MQTTCLIENT_SUCCESS)
|
|
goto exit;
|
|
|
|
if (response.properties)
|
|
{
|
|
if (MQTTProperties_hasProperty(response.properties, MQTTPROPERTY_CODE_SUBSCRIPTION_IDENTIFIERS_AVAILABLE))
|
|
subsids = (int)MQTTProperties_getNumericValue(response.properties, MQTTPROPERTY_CODE_SUBSCRIPTION_IDENTIFIERS_AVAILABLE);
|
|
|
|
MyLog(LOGA_INFO, "Connack properties:");
|
|
logProperties(response.properties);
|
|
MQTTResponse_free(response);
|
|
}
|
|
|
|
response = MQTTClient_subscribe5(c, test_request_response_globals.response_topic, 2, NULL, NULL);
|
|
assert("Good rc from subscribe", response.reasonCode == MQTTREASONCODE_GRANTED_QOS_2, "rc was %d", response.reasonCode);
|
|
|
|
response = MQTTClient_subscribe5(c, test_request_response_globals.request_topic, 2, NULL, NULL);
|
|
assert("Good rc from subscribe", response.reasonCode == MQTTREASONCODE_GRANTED_QOS_2, "rc was %d", response.reasonCode);
|
|
|
|
messages_arrived = 0;
|
|
pubmsg.payload = "a much longer message that we can shorten to the extent that we need to payload up to 11";
|
|
pubmsg.payloadlen = 11;
|
|
pubmsg.retained = 0;
|
|
pubmsg.qos = 2;
|
|
|
|
property.identifier = MQTTPROPERTY_CODE_RESPONSE_TOPIC;
|
|
property.value.data.data = test_request_response_globals.response_topic;
|
|
property.value.data.len = (int)strlen(property.value.data.data);
|
|
MQTTProperties_add(&pubmsg.properties, &property);
|
|
|
|
property.identifier = MQTTPROPERTY_CODE_CORRELATION_DATA;
|
|
property.value.data.data = test_request_response_globals.correlation_id;
|
|
property.value.data.len = (int)strlen(property.value.data.data);
|
|
MQTTProperties_add(&pubmsg.properties, &property);
|
|
|
|
response = MQTTClient_publishMessage5(c, test_request_response_globals.request_topic, &pubmsg, &dt);
|
|
assert("Good rc from publish", response.reasonCode == MQTTREASONCODE_SUCCESS, "rc was %d", response.reasonCode);
|
|
|
|
/* should get the request */
|
|
while (test_request_response_globals.messages_arrived < 1 && ++count < 10)
|
|
{
|
|
#if defined(_WIN32)
|
|
Sleep(1000);
|
|
#else
|
|
usleep(1000000L);
|
|
#endif
|
|
}
|
|
assert("1 message should have arrived", test_request_response_globals.messages_arrived == 1, "was %d",
|
|
test_request_response_globals.messages_arrived);
|
|
|
|
MQTTProperties_free(&pubmsg.properties);
|
|
property.identifier = MQTTPROPERTY_CODE_CORRELATION_DATA;
|
|
property.value.data.data = "request no 1";
|
|
property.value.data.len = (int)strlen(property.value.data.data);
|
|
MQTTProperties_add(&pubmsg.properties, &property);
|
|
|
|
response = MQTTClient_publishMessage5(c, test_request_response_globals.response_topic, &pubmsg, &dt);
|
|
assert("Good rc from publish", response.reasonCode == MQTTREASONCODE_SUCCESS, "rc was %d", response.reasonCode);
|
|
|
|
/* should get the response */
|
|
while (test_request_response_globals.messages_arrived < 1 && ++count < 10)
|
|
{
|
|
#if defined(_WIN32)
|
|
Sleep(1000);
|
|
#else
|
|
usleep(1000000L);
|
|
#endif
|
|
}
|
|
assert("1 message should have arrived", test_request_response_globals.messages_arrived == 1, "was %d",
|
|
test_request_response_globals.messages_arrived);
|
|
|
|
rc = MQTTClient_disconnect5(c, 1000, MQTTREASONCODE_SUCCESS, NULL);
|
|
|
|
MQTTProperties_free(&pubmsg.properties);
|
|
MQTTProperties_free(&subs_props);
|
|
MQTTProperties_free(&connect_props);
|
|
MQTTClient_destroy(&c);
|
|
|
|
exit:
|
|
MyLog(LOGA_INFO, "TEST7: test %s. %d tests run, %d failures.",
|
|
(failures == 0) ? "passed" : "failed", tests, failures);
|
|
write_test_result();
|
|
return failures;
|
|
}
|
|
|
|
|
|
struct
|
|
{
|
|
char* topic;
|
|
int messages_arrived;
|
|
} test_subscribe_options_globals =
|
|
{
|
|
"my response topic",
|
|
0,
|
|
};
|
|
|
|
|
|
int test_subscribe_options_messageArrived(void* context, char* topicName, int topicLen, MQTTClient_message* message)
|
|
{
|
|
int subsidcount = 0, i = 0, subsid = -1;
|
|
|
|
MyLog(LOGA_DEBUG, "Callback: message received on topic %s is %.*s.",
|
|
topicName, message->payloadlen, (char*)(message->payload));
|
|
|
|
assert("Message structure version should be 1", message->struct_version == 1,
|
|
"message->struct_version was %d", message->struct_version);
|
|
if (message->struct_version == 1)
|
|
{
|
|
const int props_count = 0;
|
|
|
|
MyLog(LOGA_INFO, "Message properties:");
|
|
logProperties(&message->properties);
|
|
}
|
|
test_subscribe_options_globals.messages_arrived++;
|
|
|
|
if (test_subscribe_options_globals.messages_arrived == 1)
|
|
{
|
|
subsidcount = MQTTProperties_propertyCount(&message->properties, MQTTPROPERTY_CODE_SUBSCRIPTION_IDENTIFIER);
|
|
assert("Subsidcount is i", subsidcount == 1, "subsidcount is not correct %d\n", subsidcount);
|
|
|
|
subsid = (int)MQTTProperties_getNumericValueAt(&message->properties, MQTTPROPERTY_CODE_SUBSCRIPTION_IDENTIFIER, 0);
|
|
assert("Subsid is 2", subsid == 2, "subsid is not correct %d\n", subsid);
|
|
}
|
|
|
|
MQTTClient_free(topicName);
|
|
MQTTClient_freeMessage(&message);
|
|
return 1;
|
|
}
|
|
|
|
|
|
int test_subscribe_options(struct Options options)
|
|
{
|
|
int subsqos = 2;
|
|
MQTTClient c;
|
|
MQTTClient_connectOptions opts = MQTTClient_connectOptions_initializer5;
|
|
MQTTProperties connect_props = MQTTProperties_initializer;
|
|
MQTTProperties subs_props = MQTTProperties_initializer;
|
|
MQTTProperty property;
|
|
MQTTClient_message pubmsg = MQTTClient_message_initializer;
|
|
MQTTResponse response = MQTTResponse_initializer;
|
|
MQTTClient_deliveryToken dt;
|
|
int rc = 0;
|
|
int count = 0;
|
|
const int msg_count = 1;
|
|
MQTTSubscribe_options subopts = MQTTSubscribe_options_initializer;
|
|
MQTTClient_createOptions createOpts = MQTTClient_createOptions_initializer;
|
|
|
|
fprintf(xml, "<testcase classname=\"test_subscribe_options\" name=\"subscribe options\"");
|
|
global_start_time = start_clock();
|
|
failures = 0;
|
|
MyLog(LOGA_INFO, "Starting test 8 - subscribe options");
|
|
|
|
createOpts.MQTTVersion = MQTTVERSION_5;
|
|
rc = MQTTClient_createWithOptions(&c, options.connection, "subscribe_options",
|
|
MQTTCLIENT_PERSISTENCE_DEFAULT, NULL, &createOpts);
|
|
assert("good rc from create", rc == MQTTCLIENT_SUCCESS, "rc was %d\n", rc);
|
|
if (rc != MQTTCLIENT_SUCCESS)
|
|
{
|
|
MQTTClient_destroy(&c);
|
|
goto exit;
|
|
}
|
|
|
|
rc = MQTTClient_setCallbacks(c, NULL, NULL, test_subscribe_options_messageArrived, NULL);
|
|
assert("Good rc from setCallbacks", rc == MQTTCLIENT_SUCCESS, "rc was %d", rc);
|
|
|
|
opts.keepAliveInterval = 20;
|
|
opts.cleanstart = 1;
|
|
opts.MQTTVersion = options.MQTTVersion;
|
|
if (options.haconnections != NULL)
|
|
{
|
|
opts.serverURIs = options.haconnections;
|
|
opts.serverURIcount = options.hacount;
|
|
}
|
|
|
|
MyLog(LOGA_DEBUG, "Connecting");
|
|
response = MQTTClient_connect5(c, &opts, &connect_props, NULL);
|
|
assert("Good rc from connect", response.reasonCode == MQTTCLIENT_SUCCESS, "rc was %d", response.reasonCode);
|
|
if (response.reasonCode != MQTTCLIENT_SUCCESS)
|
|
goto exit;
|
|
|
|
if (response.properties)
|
|
{
|
|
MyLog(LOGA_INFO, "Connack properties:");
|
|
logProperties(response.properties);
|
|
MQTTResponse_free(response);
|
|
}
|
|
|
|
property.identifier = MQTTPROPERTY_CODE_SUBSCRIPTION_IDENTIFIER;
|
|
property.value.integer4 = 1;
|
|
MQTTProperties_add(&subs_props, &property);
|
|
subopts.noLocal = 1;
|
|
response = MQTTClient_subscribe5(c, test_subscribe_options_globals.topic, 2, &subopts, &subs_props);
|
|
assert("Good rc from subscribe", response.reasonCode == MQTTREASONCODE_GRANTED_QOS_2, "rc was %d", response.reasonCode);
|
|
|
|
subs_props.array[0].value.integer4 = 2;
|
|
subopts.noLocal = 0;
|
|
subopts.retainHandling = 1;
|
|
response = MQTTClient_subscribe5(c, "#", 2, &subopts, &subs_props);
|
|
assert("Good rc from subscribe", response.reasonCode == MQTTREASONCODE_GRANTED_QOS_2, "rc was %d", response.reasonCode);
|
|
|
|
messages_arrived = 0;
|
|
pubmsg.payload = "a much longer message that we can shorten to the extent that we need to payload up to 11";
|
|
pubmsg.payloadlen = 11;
|
|
pubmsg.retained = 0;
|
|
pubmsg.qos = 2;
|
|
|
|
response = MQTTClient_publishMessage5(c, test_subscribe_options_globals.topic, &pubmsg, &dt);
|
|
assert("Good rc from publish", response.reasonCode == MQTTREASONCODE_SUCCESS, "rc was %d", response.reasonCode);
|
|
|
|
/* should get the request */
|
|
while (test_subscribe_options_globals.messages_arrived < 1 && ++count < 10)
|
|
{
|
|
#if defined(_WIN32)
|
|
Sleep(1000);
|
|
#else
|
|
usleep(1000000L);
|
|
#endif
|
|
}
|
|
assert("1 message should have arrived", test_subscribe_options_globals.messages_arrived == 1, "was %d",
|
|
test_subscribe_options_globals.messages_arrived);
|
|
|
|
rc = MQTTClient_disconnect5(c, 1000, MQTTREASONCODE_SUCCESS, NULL);
|
|
|
|
MQTTProperties_free(&pubmsg.properties);
|
|
MQTTProperties_free(&subs_props);
|
|
MQTTProperties_free(&connect_props);
|
|
MQTTClient_destroy(&c);
|
|
|
|
exit:
|
|
MyLog(LOGA_INFO, "TEST8: test %s. %d tests run, %d failures.",
|
|
(failures == 0) ? "passed" : "failed", tests, failures);
|
|
write_test_result();
|
|
return failures;
|
|
}
|
|
|
|
|
|
struct
|
|
{
|
|
char* shared_topic;
|
|
char* topic;
|
|
int messages_arrived;
|
|
} test_shared_subscriptions_globals =
|
|
{
|
|
"$share/share_test/#",
|
|
"a",
|
|
0,
|
|
};
|
|
|
|
MQTTClient c, d;
|
|
|
|
int test_shared_subscriptions_messageArrived(void* context, char* topicName, int topicLen, MQTTClient_message* message)
|
|
{
|
|
int subsidcount = 0, i = 0, subsid = -1;
|
|
|
|
MyLog(LOGA_DEBUG, "Callback: message received on topic %s is %.*s.",
|
|
topicName, message->payloadlen, (char*)(message->payload));
|
|
|
|
assert("Message structure version should be 1", message->struct_version == 1,
|
|
"message->struct_version was %d", message->struct_version);
|
|
if (message->struct_version == 1)
|
|
{
|
|
const int props_count = 0;
|
|
|
|
if (message->properties.count > 0)
|
|
{
|
|
MyLog(LOGA_INFO, "Message properties:");
|
|
logProperties(&message->properties);
|
|
}
|
|
}
|
|
test_shared_subscriptions_globals.messages_arrived++;
|
|
|
|
MQTTClient_free(topicName);
|
|
MQTTClient_freeMessage(&message);
|
|
return 1;
|
|
}
|
|
|
|
|
|
int test_shared_subscriptions(struct Options options)
|
|
{
|
|
int subsqos = 2;
|
|
MQTTClient_connectOptions opts = MQTTClient_connectOptions_initializer5;
|
|
MQTTProperties connect_props = MQTTProperties_initializer;
|
|
MQTTProperties subs_props = MQTTProperties_initializer;
|
|
MQTTClient_message pubmsg = MQTTClient_message_initializer;
|
|
MQTTResponse response = MQTTResponse_initializer;
|
|
MQTTClient_deliveryToken dt;
|
|
int rc = 0;
|
|
int count = 0;
|
|
const int msg_count = 1;
|
|
MQTTSubscribe_options subopts = MQTTSubscribe_options_initializer;
|
|
int i;
|
|
MQTTClient_createOptions createOpts = MQTTClient_createOptions_initializer;
|
|
|
|
fprintf(xml, "<testcase classname=\"test_shared_subscriptions\" name=\"shared subscriptions\"");
|
|
global_start_time = start_clock();
|
|
failures = 0;
|
|
MyLog(LOGA_INFO, "Starting test 8 - shared subscriptions");
|
|
|
|
createOpts.MQTTVersion = MQTTVERSION_5;
|
|
rc = MQTTClient_createWithOptions(&c, options.connection, "shared_subscriptions",
|
|
MQTTCLIENT_PERSISTENCE_DEFAULT, NULL, &createOpts);
|
|
assert("good rc from create", rc == MQTTCLIENT_SUCCESS, "rc was %d\n", rc);
|
|
if (rc != MQTTCLIENT_SUCCESS)
|
|
{
|
|
MQTTClient_destroy(&c);
|
|
goto exit;
|
|
}
|
|
|
|
rc = MQTTClient_createWithOptions(&d, options.connection, "shared_subscriptions_1",
|
|
MQTTCLIENT_PERSISTENCE_DEFAULT, NULL, &createOpts);
|
|
assert("good rc from create", rc == MQTTCLIENT_SUCCESS, "rc was %d\n", rc);
|
|
if (rc != MQTTCLIENT_SUCCESS)
|
|
{
|
|
MQTTClient_destroy(&d);
|
|
goto exit;
|
|
}
|
|
|
|
rc = MQTTClient_setCallbacks(c, c, NULL, test_shared_subscriptions_messageArrived, NULL);
|
|
assert("Good rc from setCallbacks", rc == MQTTCLIENT_SUCCESS, "rc was %d", rc);
|
|
|
|
rc = MQTTClient_setCallbacks(d, d, NULL, test_shared_subscriptions_messageArrived, NULL);
|
|
assert("Good rc from setCallbacks", rc == MQTTCLIENT_SUCCESS, "rc was %d", rc);
|
|
|
|
opts.keepAliveInterval = 20;
|
|
opts.cleanstart = 1;
|
|
opts.MQTTVersion = options.MQTTVersion;
|
|
if (options.haconnections != NULL)
|
|
{
|
|
opts.serverURIs = options.haconnections;
|
|
opts.serverURIcount = options.hacount;
|
|
}
|
|
|
|
MyLog(LOGA_DEBUG, "Connecting");
|
|
response = MQTTClient_connect5(c, &opts, &connect_props, NULL);
|
|
assert("Good rc from connect", response.reasonCode == MQTTCLIENT_SUCCESS, "rc was %d", response.reasonCode);
|
|
if (response.reasonCode != MQTTCLIENT_SUCCESS)
|
|
goto exit;
|
|
|
|
if (response.properties)
|
|
{
|
|
MyLog(LOGA_INFO, "Connack properties:");
|
|
logProperties(response.properties);
|
|
MQTTResponse_free(response);
|
|
}
|
|
|
|
MyLog(LOGA_DEBUG, "Connecting");
|
|
response = MQTTClient_connect5(d, &opts, &connect_props, NULL);
|
|
assert("Good rc from connect", response.reasonCode == MQTTCLIENT_SUCCESS, "rc was %d", response.reasonCode);
|
|
if (response.reasonCode != MQTTCLIENT_SUCCESS)
|
|
goto exit;
|
|
|
|
if (response.properties)
|
|
{
|
|
MyLog(LOGA_INFO, "Connack properties:");
|
|
logProperties(response.properties);
|
|
MQTTResponse_free(response);
|
|
}
|
|
|
|
response = MQTTClient_subscribe5(c, test_shared_subscriptions_globals.shared_topic, 2, &subopts, &subs_props);
|
|
assert("Good rc from subscribe", response.reasonCode == MQTTREASONCODE_GRANTED_QOS_2, "rc was %d", response.reasonCode);
|
|
|
|
response = MQTTClient_subscribe5(d, test_shared_subscriptions_globals.shared_topic, 2, &subopts, &subs_props);
|
|
assert("Good rc from subscribe", response.reasonCode == MQTTREASONCODE_GRANTED_QOS_2, "rc was %d", response.reasonCode);
|
|
|
|
messages_arrived = 0;
|
|
pubmsg.payload = "a much longer message that we can shorten to the extent that we need to payload up to 11";
|
|
pubmsg.payloadlen = 11;
|
|
pubmsg.retained = 0;
|
|
pubmsg.qos = 2;
|
|
|
|
test_shared_subscriptions_globals.messages_arrived = 0;
|
|
for (i = 0; i < 10; ++i)
|
|
{
|
|
response = MQTTClient_publishMessage5(c, test_shared_subscriptions_globals.topic, &pubmsg, &dt);
|
|
assert("Good rc from publish", response.reasonCode == MQTTREASONCODE_SUCCESS, "rc was %d", response.reasonCode);
|
|
|
|
/* should get the request */
|
|
while (test_shared_subscriptions_globals.messages_arrived < i+1 && ++count < 100)
|
|
{
|
|
#if defined(_WIN32)
|
|
Sleep(100);
|
|
#else
|
|
usleep(100000L);
|
|
#endif
|
|
}
|
|
assert("1 message should have arrived", test_shared_subscriptions_globals.messages_arrived == i+1, "was %d",
|
|
test_shared_subscriptions_globals.messages_arrived);
|
|
}
|
|
|
|
rc = MQTTClient_disconnect5(c, 1000, MQTTREASONCODE_SUCCESS, NULL);
|
|
|
|
MQTTProperties_free(&pubmsg.properties);
|
|
MQTTProperties_free(&subs_props);
|
|
MQTTProperties_free(&connect_props);
|
|
MQTTClient_destroy(&c);
|
|
|
|
exit:
|
|
MyLog(LOGA_INFO, "TEST9: test %s. %d tests run, %d failures.",
|
|
(failures == 0) ? "passed" : "failed", tests, failures);
|
|
write_test_result();
|
|
return failures;
|
|
}
|
|
|
|
|
|
int main(int argc, char** argv)
|
|
{
|
|
int rc = 0,
|
|
i;
|
|
int (*tests[])(struct Options) = {NULL,
|
|
test_client_topic_aliases,
|
|
test_server_topic_aliases,
|
|
test_subscription_ids,
|
|
test_flow_control,
|
|
test_error_reporting,
|
|
test_qos_1_2_errors,
|
|
test_request_response,
|
|
test_subscribe_options,
|
|
test_shared_subscriptions
|
|
};
|
|
|
|
xml = fopen("TEST-test1.xml", "w");
|
|
fprintf(xml, "<testsuite name=\"test1\" tests=\"%d\">\n", (int)(ARRAY_SIZE(tests) - 1));
|
|
|
|
MQTTClient_setTraceCallback(test_flow_control_trace_callback);
|
|
|
|
getopts(argc, argv);
|
|
|
|
for (i = 0; i < options.iterations; ++i)
|
|
{
|
|
if (options.test_no == 0)
|
|
{ /* run all the tests */
|
|
for (options.test_no = 1; options.test_no < ARRAY_SIZE(tests); ++options.test_no)
|
|
rc += tests[options.test_no](options); /* return number of failures. 0 = test succeeded */
|
|
}
|
|
else
|
|
rc = tests[options.test_no](options); /* run just the selected test */
|
|
}
|
|
|
|
if (rc == 0)
|
|
MyLog(LOGA_INFO, "verdict pass");
|
|
else
|
|
MyLog(LOGA_INFO, "verdict fail");
|
|
|
|
fprintf(xml, "</testsuite>\n");
|
|
fclose(xml);
|
|
return rc;
|
|
}
|