summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
-rw-r--r--doc/dlt_for_developers.md33
-rw-r--r--include/dlt/dlt_common.h12
-rw-r--r--include/dlt/dlt_user.h.in216
-rw-r--r--include/dlt/dlt_user_macros.h137
-rw-r--r--src/lib/dlt_user.c859
-rw-r--r--src/shared/dlt_common.c135
-rw-r--r--tests/gtest_dlt_user.cpp515
7 files changed, 1376 insertions, 531 deletions
diff --git a/doc/dlt_for_developers.md b/doc/dlt_for_developers.md
index 781f6fb..cd85de0 100644
--- a/doc/dlt_for_developers.md
+++ b/doc/dlt_for_developers.md
@@ -631,6 +631,19 @@ if (dlt_user_log_write_start(&ctx, &ctxdata, DLT_LOG_INFO) > 0) {
}
```
+#### Attributes
+
+In verbose mode, log message arguments can contain attributes. A "name" attribute
+describes the purpose or semantics of an argument, and a "unit" attribute
+describes its unit (if applicable - not all argument data types support having
+a "unit" attribute).
+
+```
+dlt_user_log_write_float64_attr(&myctxdata, 4.2, "speed", "m/s");
+```
+
+In non-verbose mode, these attributes are not added to the message.
+
### Logging parameters
The following parameter types can be used. Multiple parameters can be added to
@@ -640,25 +653,45 @@ exceed 1390 bytes, including the DLT message header.
Type | Description
--- | ---
DLT\_STRING(TEXT) | String
+DLT\_STRING\_ATTR(TEXT,NAME) | String (with attribute)
DLT\_SIZED\_STRING(TEXT,LENGTH) | String with known length
+DLT\_SIZED\_STRING\_ATTR(TEXT,LENGTH,NAME) | String with known length (with attribute)
DLT\_CSTRING(TEXT) | Constant string (not sent in non-verbose mode)
+DLT\_CSTRING\_ATTR(TEXT,NAME) | Constant string (with attribute; not sent in non-verbose mode)
DLT\_SIZED\_CSTRING(TEXT,LENGTH) | Constant string with known length (not sent in non-verbose mode)
+DLT\_SIZED\_CSTRING\_ATTR(TEXT,LENGTH,NAME) | Constant string with known length (with attribute; not sent in non-verbose mode)
DLT\_UTF8(TEXT) | Utf8-encoded string
+DLT\_UTF8\_ATTR(TEXT,NAME) | Utf8-encoded string (with attribute)
DLT\_SIZED\_UTF8(TEXT,LENGTH) | Utf8-encoded string with known length
+DLT\_SIZED\_UTF8\_ATTR(TEXT,LENGTH,NAME) | Utf8-encoded string with known length (with attribute)
DLT\_RAW(BUF,LENGTH) | Raw buffer
+DLT\_RAW\_ATTR(BUF,LENGTH,NAME) | Raw buffer (with attribute)
DLT\_INT(VAR) | Integer variable, dependent on platform
+DLT\_INT\_ATTR(VAR,NAME,UNIT) | Integer variable, dependent on platform (with attributes)
DLT\_INT8(VAR) |Integer 8 Bit variable
+DLT\_INT8\_ATTR(VAR,NAME,UNIT) |Integer 8 Bit variable (with attributes)
DLT\_INT16(VAR) | Integer 16 Bit variable
+DLT\_INT16\_ATTR(VAR,NAME,UNIT) | Integer 16 Bit variable (with attributes)
DLT\_INT32(VAR) | Integer 32 Bit variable
+DLT\_INT32\_ATTR(VAR,NAME,UNIT) | Integer 32 Bit variable (with attributes)
DLT\_INT64(VAR) | Integer 64 bit variable
+DLT\_INT64\_ATTR(VAR,NAME,UNIT) | Integer 64 bit variable (with attributes)
DLT\_UINT(VAR) | Unsigned integer variable
+DLT\_UINT\_ATTR(VAR,NAME,UNIT) | Unsigned integer variable (with attributes)
DLT\_UINT8(VAR) | Unsigned 8 Bit integer variable
+DLT\_UINT8\_ATTR(VAR,NAME,UNIT) | Unsigned 8 Bit integer variable (with attributes)
DLT\_UINT16(VAR) |Unsigned 16 Bit integer variable
+DLT\_UINT16\_ATTR(VAR,NAME,UNIT) |Unsigned 16 Bit integer variable (with attributes)
DLT\_UINT32(VAR) | Unsigned 32 Bit integer variable
+DLT\_UINT32\_ATTR(VAR,NAME,UNIT) | Unsigned 32 Bit integer variable (with attributes)
DLT\_UINT64(VAR) | Unsigned 64 bit integer variable
+DLT\_UINT64\_ATTR(VAR,NAME,UNIT) | Unsigned 64 bit integer variable (with attributes)
DLT\_BOOL(VAR) | Boolean variable
+DLT\_BOOL\_ATTR(VAR,NAME) | Boolean variable (with attribute)
DLT\_FLOAT32(VAR) | Float 32 Bit variable
+DLT\_FLOAT32\_ATTR(VAR,NAME,UNIT) | Float 32 Bit variable (with attributes)
DLT\_FLOAT64(VAR) | Float 64 Bit variable
+DLT\_FLOAT64\_ATTR(VAR,NAME,UNIT) | Float 64 Bit variable (with attributes)
DLT\_HEX8(UINT\_VAR) | 8 Bit hex value
DLT\_HEX16(UINT\_VAR) | 16 Bit hex value
DLT\_HEX32(UINT\_VAR) | 32 Bit hex value
diff --git a/include/dlt/dlt_common.h b/include/dlt/dlt_common.h
index 3e7100e..049b6ee 100644
--- a/include/dlt/dlt_common.h
+++ b/include/dlt/dlt_common.h
@@ -75,6 +75,7 @@
# include <netinet/in.h>
# include <stdio.h>
+# include <stdbool.h>
# ifdef __linux__
# include <linux/limits.h>
# include <sys/socket.h>
@@ -89,8 +90,10 @@
# if defined(__GNUC__)
# define PURE_FUNCTION __attribute__((pure))
+# define PRINTF_FORMAT(a,b) __attribute__ ((format (printf, a, b)))
# else
# define PURE_FUNCTION /* nothing */
+# define PRINTF_FORMAT(a,b) /* nothing */
# endif
# if !defined (__WIN32__) && !defined(_MSC_VER)
@@ -1170,6 +1173,13 @@ void dlt_log_set_fifo_basedir(const char *pipe_dir);
* @param level the level
*/
void dlt_log_set_level(int level);
+
+/**
+ * Set whether to print "name" and "unit" attributes in console output
+ * @param state true = with attributes, false = without attributes
+ */
+void dlt_print_with_attributes(bool state);
+
/**
* Initialize (external) logging facility
* @param mode positive, 0 = log to stdout, 1 = log to syslog, 2 = log to file, 3 = log to stderr
@@ -1180,7 +1190,7 @@ void dlt_log_init(int mode);
* @param format format string for message
* @return negative value if there was an error or the total number of characters written is returned on success
*/
-int dlt_user_printf(const char *format, ...);
+int dlt_user_printf(const char *format, ...) PRINTF_FORMAT(1,2);
/**
* Log ASCII string with null-termination to (external) logging facility
* @param prio priority (see syslog() call)
diff --git a/include/dlt/dlt_user.h.in b/include/dlt/dlt_user.h.in
index e4b2c5a..817cf11 100644
--- a/include/dlt/dlt_user.h.in
+++ b/include/dlt/dlt_user.h.in
@@ -314,6 +314,21 @@ DltReturnValue dlt_user_log_write_finish(DltContextData *log);
DltReturnValue dlt_user_log_write_bool(DltContextData *log, uint8_t data);
/**
+ * Write a boolean parameter with "name" attribute into a DLT log message.
+ * dlt_user_log_write_start has to be called before adding any parameters to the log message.
+ * Finish building a log message by calling dlt_user_log_write_finish.
+ *
+ * If @a name is NULL, this function will add an attribute field with length 0
+ * and no content to the message.
+ *
+ * @param log pointer to an object containing information about logging context data
+ * @param data boolean parameter written into log message (mapped to uint8)
+ * @param name the "name" attribute (or NULL)
+ * @return value from DltReturnValue enum
+ */
+DltReturnValue dlt_user_log_write_bool_attr(DltContextData *log, uint8_t data, const char *name);
+
+/**
* Write a float parameter into a DLT log message.
* dlt_user_log_write_start has to be called before adding any attributes to the log message.
* Finish sending log message by calling dlt_user_log_write_finish.
@@ -334,6 +349,38 @@ DltReturnValue dlt_user_log_write_float32(DltContextData *log, float32_t data);
DltReturnValue dlt_user_log_write_float64(DltContextData *log, double data);
/**
+ * Write a float parameter with attributes into a DLT log message.
+ * dlt_user_log_write_start has to be called before adding any parameters to the log message.
+ * Finish building a log message by calling dlt_user_log_write_finish.
+ *
+ * If @a name or @a unit is NULL, this function will add a corresponding attribute field with length 0
+ * and no content to the message for that attribute.
+ *
+ * @param log pointer to an object containing information about logging context data
+ * @param data float32_t parameter written into log message
+ * @param name the "name" attribute (or NULL)
+ * @param unit the "unit" attribute (or NULL)
+ * @return value from DltReturnValue enum
+ */
+DltReturnValue dlt_user_log_write_float32_attr(DltContextData *log, float32_t data, const char *name, const char *unit);
+
+/**
+ * Write a double parameter with attributes into a DLT log message.
+ * dlt_user_log_write_start has to be called before adding any parameters to the log message.
+ * Finish building a log message by calling dlt_user_log_write_finish.
+ *
+ * If @a name or @a unit is NULL, this function will add a corresponding attribute field with length 0
+ * and no content to the message for that attribute.
+ *
+ * @param log pointer to an object containing information about logging context data
+ * @param data float64_t parameter written into log message
+ * @param name the "name" attribute (or NULL)
+ * @param unit the "unit" attribute (or NULL)
+ * @return value from DltReturnValue enum
+ */
+DltReturnValue dlt_user_log_write_float64_attr(DltContextData *log, float64_t data, const char *name, const char *unit);
+
+/**
* Write a uint parameter into a DLT log message.
* dlt_user_log_write_start has to be called before adding any attributes to the log message.
* Finish sending log message by calling dlt_user_log_write_finish.
@@ -348,6 +395,26 @@ DltReturnValue dlt_user_log_write_uint32(DltContextData *log, uint32_t data);
DltReturnValue dlt_user_log_write_uint64(DltContextData *log, uint64_t data);
/**
+ * Write a uint parameter with attributes into a DLT log message.
+ * dlt_user_log_write_start has to be called before adding any parameters to the log message.
+ * Finish building a log message by calling dlt_user_log_write_finish.
+ *
+ * If @a name or @a unit is NULL, this function will add a corresponding attribute field with length 0
+ * and no content to the message for that attribute.
+ *
+ * @param log pointer to an object containing information about logging context data
+ * @param data unsigned int parameter written into log message
+ * @param name the "name" attribute (or NULL)
+ * @param unit the "unit" attribute (or NULL)
+ * @return value from DltReturnValue enum
+ */
+DltReturnValue dlt_user_log_write_uint_attr(DltContextData *log, unsigned int data, const char *name, const char *unit);
+DltReturnValue dlt_user_log_write_uint8_attr(DltContextData *log, uint8_t data, const char *name, const char *unit);
+DltReturnValue dlt_user_log_write_uint16_attr(DltContextData *log, uint16_t data, const char *name, const char *unit);
+DltReturnValue dlt_user_log_write_uint32_attr(DltContextData *log, uint32_t data, const char *name, const char *unit);
+DltReturnValue dlt_user_log_write_uint64_attr(DltContextData *log, uint64_t data, const char *name, const char *unit);
+
+/**
* Write a uint parameter into a DLT log message. The output will be formatted as given by the parameter type.
* dlt_user_log_write_start has to be called before adding any attributes to the log message.
* Finish sending log message by calling dlt_user_log_write_finish.
@@ -384,6 +451,27 @@ DltReturnValue dlt_user_log_write_int8(DltContextData *log, int8_t data);
DltReturnValue dlt_user_log_write_int16(DltContextData *log, int16_t data);
DltReturnValue dlt_user_log_write_int32(DltContextData *log, int32_t data);
DltReturnValue dlt_user_log_write_int64(DltContextData *log, int64_t data);
+
+/**
+ * Write an int parameter with attributes into a DLT log message.
+ * dlt_user_log_write_start has to be called before adding any parameters to the log message.
+ * Finish building a log message by calling dlt_user_log_write_finish.
+ *
+ * If @a name or @a unit is NULL, this function will add a corresponding attribute field with length 0
+ * and no content to the message for that attribute.
+ *
+ * @param log pointer to an object containing information about logging context data
+ * @param data int parameter written into log message
+ * @param name the "name" attribute (or NULL)
+ * @param unit the "unit" attribute (or NULL)
+ * @return value from DltReturnValue enum
+ */
+DltReturnValue dlt_user_log_write_int_attr(DltContextData *log, int data, const char *name, const char *unit);
+DltReturnValue dlt_user_log_write_int8_attr(DltContextData *log, int8_t data, const char *name, const char *unit);
+DltReturnValue dlt_user_log_write_int16_attr(DltContextData *log, int16_t data, const char *name, const char *unit);
+DltReturnValue dlt_user_log_write_int32_attr(DltContextData *log, int32_t data, const char *name, const char *unit);
+DltReturnValue dlt_user_log_write_int64_attr(DltContextData *log, int64_t data, const char *name, const char *unit);
+
/**
* Write a null terminated ASCII string into a DLT log message.
* dlt_user_log_write_start has to be called before adding any attributes to the log message.
@@ -450,6 +538,101 @@ DltReturnValue dlt_user_log_write_utf8_string(DltContextData *log, const char *t
DltReturnValue dlt_user_log_write_sized_utf8_string(DltContextData *log, const char *text, uint16_t length);
/**
+ * Write a null-terminated ASCII string with "name" attribute into a DLT log message.
+ * dlt_user_log_write_start has to be called before adding any parameters to the log message.
+ * Finish building a log message by calling dlt_user_log_write_finish.
+ *
+ * If @a name is NULL, this function will add an attribute field with length 0
+ * and no content to the message.
+ *
+ * @param log pointer to an object containing information about logging context data
+ * @param text pointer to the parameter written into log message containing null termination
+ * @param name the "name" attribute (or NULL)
+ * @return value from DltReturnValue enum
+ */
+DltReturnValue dlt_user_log_write_string_attr(DltContextData *log, const char *text, const char *name);
+
+/**
+ * Write a potentially non-null-terminated ASCII string with "name" attribute into a DLT log message.
+ * dlt_user_log_write_start has to be called before adding any parameters to the log message.
+ * Finish building a log message by calling dlt_user_log_write_finish.
+ *
+ * If @a name is NULL, this function will add an attribute field with length 0
+ * and no content to the message.
+ *
+ * @param log pointer to an object containing information about logging context data
+ * @param text pointer to the parameter written into log message
+ * @param length length in bytes of @a text (without any termination character)
+ * @param name the "name" attribute (or NULL)
+ * @return value from DltReturnValue enum
+ */
+DltReturnValue dlt_user_log_write_sized_string_attr(DltContextData *log, const char *text, uint16_t length, const char *name);
+
+/**
+ * Write a constant, null-terminated ASCII string with "name" attribute into a DLT log message.
+ * In non-verbose mode, this parameter will not be sent at all.
+ * dlt_user_log_write_start has to be called before adding any parameters to the log message.
+ * Finish building a log message by calling dlt_user_log_write_finish.
+ *
+ * If @a name is NULL, this function will add an attribute field with length 0
+ * and no content to the message.
+ *
+ * @param log pointer to an object containing information about logging context data
+ * @param text pointer to the parameter written into log message containing null termination
+ * @param name the "name" attribute (or NULL)
+ * @return value from DltReturnValue enum
+ */
+DltReturnValue dlt_user_log_write_constant_string_attr(DltContextData *log, const char *text, const char *name);
+
+/**
+ * Write a constant, potentially non-null-terminated ASCII string with "name" attribute into a DLT log message.
+ * In non-verbose mode, this parameter will not be sent at all.
+ * dlt_user_log_write_start has to be called before adding any parameters to the log message.
+ * Finish building a log message by calling dlt_user_log_write_finish.
+ *
+ * If @a name is NULL, this function will add an attribute field with length 0
+ * and no content to the message.
+ *
+ * @param log pointer to an object containing information about logging context data
+ * @param text pointer to the parameter written into log message containing null termination
+ * @param length length in bytes of @a text (without any termination character)
+ * @param name the "name" attribute (or NULL)
+ * @return value from DltReturnValue enum
+ */
+DltReturnValue dlt_user_log_write_sized_constant_string_attr(DltContextData *log, const char *text, uint16_t length, const char *name);
+
+/**
+ * Write a null-terminated UTF-8 string with "name" attribute into a DLT log message.
+ * dlt_user_log_write_start has to be called before adding any parameters to the log message.
+ * Finish building a log message by calling dlt_user_log_write_finish.
+ *
+ * If @a name is NULL, this function will add an attribute field with length 0
+ * and no content to the message.
+ *
+ * @param log pointer to an object containing information about logging context data
+ * @param text pointer to the parameter written into log message containing null termination
+ * @param name the "name" attribute (or NULL)
+ * @return value from DltReturnValue enum
+ */
+DltReturnValue dlt_user_log_write_utf8_string_attr(DltContextData *log, const char *text, const char *name);
+
+/**
+ * Write a potentially non-null-terminated UTF-8 string with "name" attribute into a DLT log message.
+ * dlt_user_log_write_start has to be called before adding any parameters to the log message.
+ * Finish building a log message by calling dlt_user_log_write_finish.
+ *
+ * If @a name is NULL, this function will add an attribute field with length 0
+ * and no content to the message.
+ *
+ * @param log pointer to an object containing information about logging context data
+ * @param text pointer to the parameter written into log message
+ * @param length length in bytes of @a text (without any termination character)
+ * @param name the "name" attribute (or NULL)
+ * @return value from DltReturnValue enum
+ */
+DltReturnValue dlt_user_log_write_sized_utf8_string_attr(DltContextData *log, const char *text, uint16_t length, const char *name);
+
+/**
* Write a binary memory block into a DLT log message.
* dlt_user_log_write_start has to be called before adding any attributes to the log message.
* Finish sending log message by calling dlt_user_log_write_finish.
@@ -473,6 +656,39 @@ DltReturnValue dlt_user_log_write_raw(DltContextData *log, void *data, uint16_t
DltReturnValue dlt_user_log_write_raw_formatted(DltContextData *log, void *data, uint16_t length, DltFormatType type);
/**
+ * Write a binary memory block with "name" attribute into a DLT log message.
+ * dlt_user_log_write_start has to be called before adding any parameters to the log message.
+ * Finish building a log message by calling dlt_user_log_write_finish.
+ *
+ * If @a name is NULL, this function will add an attribute field with length 0
+ * and no content to the message.
+ *
+ * @param log pointer to an object containing information about logging context data
+ * @param data pointer to the parameter written into log message.
+ * @param length length in bytes of the parameter written into log message
+ * @param name the "name" attribute (or NULL)
+ * @return value from DltReturnValue enum
+ */
+DltReturnValue dlt_user_log_write_raw_attr(DltContextData *log, const void *data, uint16_t length, const char *name);
+
+/**
+ * Write a binary memory block with "name" attribute into a DLT log message.
+ * dlt_user_log_write_start has to be called before adding any parameters to the log message.
+ * Finish building a log message by calling dlt_user_log_write_finish.
+ *
+ * If @a name is NULL, this function will add an attribute field with length 0
+ * and no content to the message.
+ *
+ * @param log pointer to an object containing information about logging context data
+ * @param data pointer to the parameter written into log message.
+ * @param length length in bytes of the parameter written into log message
+ * @param type the format information
+ * @param name the "name" attribute (or NULL)
+ * @return value from DltReturnValue enum
+ */
+DltReturnValue dlt_user_log_write_raw_formatted_attr(DltContextData *log, const void *data, uint16_t length, DltFormatType type, const char *name);
+
+/**
* Trace network message
* @param handle pointer to an object containing information about one special logging context
* @param nw_trace_type type of network trace (DLT_NW_TRACE_IPC, DLT_NW_TRACE_CAN, DLT_NW_TRACE_FLEXRAY, or DLT_NW_TRACE_MOST)
diff --git a/include/dlt/dlt_user_macros.h b/include/dlt/dlt_user_macros.h
index f313270..24b7b7a 100644
--- a/include/dlt/dlt_user_macros.h
+++ b/include/dlt/dlt_user_macros.h
@@ -369,6 +369,66 @@
(void)dlt_user_log_write_sized_utf8_string(&log_local, TEXT, LEN)
/**
+ * Add string parameter with "name" attribute to the log messsage.
+ * @param TEXT ASCII string
+ * @param NAME "name" attribute
+ */
+#define DLT_STRING_ATTR(TEXT, NAME) \
+ (void)dlt_user_log_write_string_attr(&log_local, TEXT, NAME)
+
+/**
+ * Add string parameter with given length and "name" attribute to the log messsage.
+ * The string in @a TEXT does not need to be null-terminated, but
+ * the copied string will be null-terminated at its destination
+ * in the message buffer.
+ * @param TEXT ASCII string
+ * @param LEN length in bytes to take from @a TEXT
+ * @param NAME "name" attribute
+ */
+#define DLT_SIZED_STRING_ATTR(TEXT, LEN, NAME) \
+ (void)dlt_user_log_write_sized_string_attr(&log_local, TEXT, LEN, NAME)
+
+/**
+ * Add constant string parameter with "name" attribute to the log messsage.
+ * @param TEXT Constant ASCII string
+ * @param NAME "name" attribute
+ */
+#define DLT_CSTRING_ATTR(TEXT, NAME) \
+ (void)dlt_user_log_write_constant_string_attr(&log_local, TEXT, NAME)
+
+/**
+ * Add constant string parameter with given length and "name" attribute to the log messsage.
+ * The string in @a TEXT does not need to be null-terminated, but
+ * the copied string will be null-terminated at its destination
+ * in the message buffer.
+ * @param TEXT Constant ASCII string
+ * @param LEN length in bytes to take from @a TEXT
+ * @param NAME "name" attribute
+ */
+#define DLT_SIZED_CSTRING_ATTR(TEXT, LEN, NAME) \
+ (void)dlt_user_log_write_sized_constant_string_attr(&log_local, TEXT, LEN, NAME)
+
+/**
+ * Add utf8-encoded string parameter with "name" attribute to the log messsage.
+ * @param TEXT UTF8-encoded string
+ * @param NAME "name" attribute
+ */
+#define DLT_UTF8_ATTR(TEXT, NAME) \
+ (void)dlt_user_log_write_utf8_string_attr(&log_local, TEXT, NAME)
+
+/**
+ * Add utf8-encoded string parameter with given length and "name" attribute to the log messsage.
+ * The string in @a TEXT does not need to be null-terminated, but
+ * the copied string will be null-terminated at its destination
+ * in the message buffer.
+ * @param TEXT UTF8-encoded string
+ * @param LEN length in bytes to take from @a TEXT
+ * @param NAME "name" attribute
+ */
+#define DLT_SIZED_UTF8_ATTR(TEXT, LEN, NAME) \
+ (void)dlt_user_log_write_sized_utf8_string_attr(&log_local, TEXT, LEN, ATTR)
+
+/**
* Add boolean parameter to the log messsage.
* @param BOOL_VAR Boolean value (mapped to uint8)
*/
@@ -376,6 +436,14 @@
(void)dlt_user_log_write_bool(&log_local, BOOL_VAR)
/**
+ * Add boolean parameter with "name" attribute to the log messsage.
+ * @param BOOL_VAR Boolean value (mapped to uint8)
+ * @param NAME "name" attribute
+ */
+#define DLT_BOOL_ATTR(BOOL_VAR, NAME) \
+ (void)dlt_user_log_write_bool_attr(&log_local, BOOL_VAR, NAME)
+
+/**
* Add float32 parameter to the log messsage.
* @param FLOAT32_VAR Float32 value (mapped to float)
*/
@@ -390,6 +458,24 @@
(void)dlt_user_log_write_float64(&log_local, FLOAT64_VAR)
/**
+ * Add float32 parameter with attributes to the log messsage.
+ * @param FLOAT32_VAR Float32 value (mapped to float)
+ * @param NAME "name" attribute
+ * @param UNIT "unit" attribute
+ */
+#define DLT_FLOAT32_ATTR(FLOAT32_VAR, NAME, UNIT) \
+ (void)dlt_user_log_write_float32_attr(&log_local, FLOAT32_VAR, NAME, UNIT)
+
+/**
+ * Add float64 parameter with attributes to the log messsage.
+ * @param FLOAT64_VAR Float64 value (mapped to double)
+ * @param NAME "name" attribute
+ * @param UNIT "unit" attribute
+ */
+#define DLT_FLOAT64_ATTR(FLOAT64_VAR, NAME, UNIT) \
+ (void)dlt_user_log_write_float64_attr(&log_local, FLOAT64_VAR, NAME, UNIT)
+
+/**
* Add integer parameter to the log messsage.
* @param INT_VAR integer value
*/
@@ -409,6 +495,27 @@
(void)dlt_user_log_write_int64(&log_local, INT_VAR)
/**
+ * Add integer parameter with attributes to the log messsage.
+ * @param INT_VAR integer value
+ * @param NAME "name" attribute
+ * @param UNIT "unit" attribute
+ */
+#define DLT_INT_ATTR(INT_VAR, NAME, UNIT) \
+ (void)dlt_user_log_write_int_attr(&log_local, INT_VAR, NAME, UNIT)
+
+#define DLT_INT8_ATTR(INT_VAR, NAME, UNIT) \
+ (void)dlt_user_log_write_int8_attr(&log_local, INT_VAR, NAME, UNIT)
+
+#define DLT_INT16_ATTR(INT_VAR, NAME, UNIT) \
+ (void)dlt_user_log_write_int16_attr(&log_local, INT_VAR, NAME, UNIT)
+
+#define DLT_INT32_ATTR(INT_VAR, NAME, UNIT) \
+ (void)dlt_user_log_write_int32_attr(&log_local, INT_VAR, NAME, UNIT)
+
+#define DLT_INT64_ATTR(INT_VAR, NAME, UNIT) \
+ (void)dlt_user_log_write_int64_attr(&log_local, INT_VAR, NAME, UNIT)
+
+/**
* Add unsigned integer parameter to the log messsage.
* @param UINT_VAR unsigned integer value
*/
@@ -428,6 +535,27 @@
(void)dlt_user_log_write_uint64(&log_local, UINT_VAR)
/**
+ * Add unsigned integer parameter with attributes to the log messsage.
+ * @param UINT_VAR unsigned integer value
+ * @param NAME "name" attribute
+ * @param UNIT "unit" attribute
+ */
+#define DLT_UINT_ATTR(UINT_VAR, NAME, UNIT) \
+ (void)dlt_user_log_write_uint_attr(&log_local, UINT_VAR, NAME, UNIT)
+
+#define DLT_UINT8_ATTR(UINT_VAR, NAME, UNIT) \
+ (void)dlt_user_log_write_uint8_attr(&log_local, UINT_VAR, NAME, UNIT)
+
+#define DLT_UINT16_ATTR(UINT_VAR, NAME, UNIT) \
+ (void)dlt_user_log_write_uint16_attr(&log_local, UINT_VAR, NAME, UNIT)
+
+#define DLT_UINT32_ATTR(UINT_VAR, NAME, UNIT) \
+ (void)dlt_user_log_write_uint32_attr(&log_local, UINT_VAR, NAME, UNIT)
+
+#define DLT_UINT64_ATTR(UINT_VAR, NAME, UNIT) \
+ (void)dlt_user_log_write_uint64_attr(&log_local, UINT_VAR, NAME, UNIT)
+
+/**
* Add binary memory block to the log messages.
* @param BUF pointer to memory block
* @param LEN length of memory block
@@ -448,6 +576,15 @@
(void)dlt_user_log_write_uint16_formatted(&log_local, UINT_VAR, DLT_FORMAT_BIN16)
/**
+ * Add binary memory block with "name" attribute to the log messages.
+ * @param BUF pointer to memory block
+ * @param LEN length of memory block
+ * @param NAME "name" attribute
+ */
+#define DLT_RAW_ATTR(BUF, LEN, NAME) \
+ (void)dlt_user_log_write_raw_attr(&log_local, BUF, LEN, NAME)
+
+/**
* Architecture independent macro to print pointers
*/
#define DLT_PTR(PTR_VAR) \
diff --git a/src/lib/dlt_user.c b/src/lib/dlt_user.c
index ae6eb55..4dc8d42 100644
--- a/src/lib/dlt_user.c
+++ b/src/lib/dlt_user.c
@@ -115,6 +115,16 @@ enum StringType
UTF8_STRING = 1
};
+/* Data type holding "Variable Info" (VARI) properties
+ * Some of the supported data types (eg. bool, string, raw) have only "name", but not "unit".
+ */
+typedef struct VarInfo
+{
+ const char *name; // the "name" attribute (can be NULL)
+ const char *unit; // the "unit" attribute (can be NULL)
+ bool with_unit; // true if the "unit" field is to be considered
+} VarInfo;
+
#define DLT_UNUSED(x) (void)(x)
/* Network trace */
@@ -191,10 +201,8 @@ static void dlt_user_trace_network_segmented_thread(void *unused);
static void dlt_user_trace_network_segmented_thread_segmenter(s_segmented_data *data);
#endif
-static DltReturnValue dlt_user_log_write_string_utils(DltContextData *log, const char *text,
- const enum StringType type);
-static DltReturnValue dlt_user_log_write_sized_string_utils(DltContextData *log, const char *text,
- uint16_t text_len, const enum StringType type);
+static DltReturnValue dlt_user_log_write_string_utils_attr(DltContextData *log, const char *text, const enum StringType type, const char *name, bool with_var_info);
+static DltReturnValue dlt_user_log_write_sized_string_utils_attr(DltContextData *log, const char *text, uint16_t length, const enum StringType type, const char *name, bool with_var_info);
static DltReturnValue dlt_unregister_app_util(bool force_sending_messages);
@@ -1756,16 +1764,8 @@ DltReturnValue dlt_user_log_write_finish(DltContextData *log)
return ret;
}
-DltReturnValue dlt_user_log_write_raw(DltContextData *log, void *data, uint16_t length)
-{
- return dlt_user_log_write_raw_formatted(log, data, length, DLT_FORMAT_DEFAULT);
-}
-
-DltReturnValue dlt_user_log_write_raw_formatted(DltContextData *log, void *data, uint16_t length, DltFormatType type)
+static DltReturnValue dlt_user_log_write_raw_internal(DltContextData *log, const void *data, uint16_t length, DltFormatType type, const char *name, bool with_var_info)
{
- size_t new_log_size = 0;
- uint32_t type_info = 0;
-
/* check nullpointer */
if ((log == NULL) || ((data == NULL) && (length != 0)))
return DLT_RETURN_WRONG_PARAMETER;
@@ -1781,20 +1781,27 @@ DltReturnValue dlt_user_log_write_raw_formatted(DltContextData *log, void *data,
return DLT_RETURN_ERROR;
}
- new_log_size = log->size + length + sizeof(uint16_t);
+ const uint16_t name_size = (name != NULL) ? strlen(name)+1 : 0;
- if (new_log_size > dlt_user.log_buf_len)
+ size_t needed_size = length + sizeof(uint16_t);
+ if ((log->size + needed_size) > dlt_user.log_buf_len)
return DLT_RETURN_USER_BUFFER_FULL;
if (dlt_user.verbose_mode) {
- new_log_size = log->size + length + sizeof(uint32_t) + sizeof(uint16_t);
+ uint32_t type_info = DLT_TYPE_INFO_RAWD;
- if (new_log_size > dlt_user.log_buf_len)
- return DLT_RETURN_USER_BUFFER_FULL;
+ needed_size += sizeof(uint32_t); // Type Info field
+ if (with_var_info) {
+ needed_size += sizeof(uint16_t); // length of name
+ needed_size += name_size; // the name itself
- /* Transmit type information */
- type_info = DLT_TYPE_INFO_RAWD;
+ type_info |= DLT_TYPE_INFO_VARI;
+ }
+ if ((log->size + needed_size) > dlt_user.log_buf_len)
+ return DLT_RETURN_USER_BUFFER_FULL;
+ // Genivi extension: put formatting hints into the unused (for RAWD) TYLE + SCOD fields.
+ // The SCOD field holds the base (hex or bin); the TYLE field holds the column width (8bit..64bit).
if ((type >= DLT_FORMAT_HEX8) && (type <= DLT_FORMAT_HEX64)) {
type_info |= DLT_SCOD_HEX;
type_info += type;
@@ -1805,15 +1812,31 @@ DltReturnValue dlt_user_log_write_raw_formatted(DltContextData *log, void *data,
type_info += type - DLT_FORMAT_BIN8 + 1;
}
- memcpy((log->buffer) + log->size, &(type_info), sizeof(uint32_t));
+ memcpy(log->buffer + log->size, &type_info, sizeof(uint32_t));
log->size += sizeof(uint32_t);
}
- /* First transmit length of raw data, then the raw data itself */
- memcpy((log->buffer) + log->size, &(length), sizeof(uint16_t));
+ memcpy(log->buffer + log->size, &length, sizeof(uint16_t));
log->size += sizeof(uint16_t);
- memcpy((log->buffer) + log->size, data, length);
+ if (dlt_user.verbose_mode) {
+ if (with_var_info) {
+ // Write length of "name" attribute.
+ // We assume that the protocol allows zero-sized strings here (which this code will create
+ // when the input pointer is NULL).
+ memcpy(log->buffer + log->size, &name_size, sizeof(uint16_t));
+ log->size += sizeof(uint16_t);
+
+ // Write name string itself.
+ // Must not use NULL as source pointer for memcpy. This check assures that.
+ if (name_size != 0) {
+ memcpy(log->buffer + log->size, name, name_size);
+ log->size += name_size;
+ }
+ }
+ }
+
+ memcpy(log->buffer + log->size, data, length);
log->size += length;
log->args_num++;
@@ -1821,10 +1844,29 @@ DltReturnValue dlt_user_log_write_raw_formatted(DltContextData *log, void *data,
return DLT_RETURN_OK;
}
-DltReturnValue dlt_user_log_write_float32(DltContextData *log, float32_t data)
+DltReturnValue dlt_user_log_write_raw(DltContextData *log, void *data, uint16_t length)
+{
+ return dlt_user_log_write_raw_internal(log, data, length, DLT_FORMAT_DEFAULT, NULL, false);
+}
+
+DltReturnValue dlt_user_log_write_raw_formatted(DltContextData *log, void *data, uint16_t length, DltFormatType type)
{
- uint32_t type_info;
+ return dlt_user_log_write_raw_internal(log, data, length, type, NULL, false);
+}
+
+DltReturnValue dlt_user_log_write_raw_attr(DltContextData *log, const void *data, uint16_t length, const char *name)
+{
+ return dlt_user_log_write_raw_internal(log, data, length, DLT_FORMAT_DEFAULT, name, true);
+}
+
+DltReturnValue dlt_user_log_write_raw_formatted_attr(DltContextData *log, const void *data, uint16_t length, DltFormatType type, const char *name)
+{
+ return dlt_user_log_write_raw_internal(log, data, length, type, name, true);
+}
+// Generic implementation for all "simple" types, possibly with attributes
+static DltReturnValue dlt_user_log_write_generic_attr(DltContextData *log, const void *datap, size_t datalen, uint32_t type_info, const VarInfo *varinfo)
+{
if (log == NULL)
return DLT_RETURN_WRONG_PARAMETER;
@@ -1833,67 +1875,152 @@ DltReturnValue dlt_user_log_write_float32(DltContextData *log, float32_t data)
return DLT_RETURN_ERROR;
}
- if (sizeof(float32_t) != 4)
- return DLT_RETURN_ERROR;
-
- if ((log->size + sizeof(float32_t)) > dlt_user.log_buf_len)
+ size_t needed_size = datalen;
+ if ((log->size + needed_size) > dlt_user.log_buf_len)
return DLT_RETURN_USER_BUFFER_FULL;
if (dlt_user.verbose_mode) {
- if ((log->size + sizeof(uint32_t) + sizeof(float32_t)) > dlt_user.log_buf_len)
- return DLT_RETURN_USER_BUFFER_FULL;
+ bool with_var_info = (varinfo != NULL);
+
+ uint16_t name_size;
+ uint16_t unit_size;
+
+ needed_size += sizeof(uint32_t); // Type Info field
+ if (with_var_info) {
+ name_size = (varinfo->name != NULL) ? strlen(varinfo->name)+1 : 0;
+ unit_size = (varinfo->unit != NULL) ? strlen(varinfo->unit)+1 : 0;
+
+ needed_size += sizeof(uint16_t); // length of name
+ needed_size += name_size; // the name itself
+ if (varinfo->with_unit) {
+ needed_size += sizeof(uint16_t); // length of unit
+ needed_size += unit_size; // the unit itself
+ }
- type_info = DLT_TYPE_INFO_FLOA | DLT_TYLE_32BIT;
+ type_info |= DLT_TYPE_INFO_VARI;
+ }
+ if ((log->size + needed_size) > dlt_user.log_buf_len)
+ return DLT_RETURN_USER_BUFFER_FULL;
- memcpy((log->buffer) + log->size, &(type_info), sizeof(uint32_t));
+ memcpy(log->buffer + log->size, &type_info, sizeof(uint32_t));
log->size += sizeof(uint32_t);
+
+ if (with_var_info) {
+ // Write lengths of name/unit strings
+ // We assume here that the protocol allows zero-sized strings here (which occur
+ // when the input pointers are NULL).
+ memcpy(log->buffer + log->size, &name_size, sizeof(uint16_t));
+ log->size += sizeof(uint16_t);
+ if (varinfo->with_unit) {
+ memcpy(log->buffer + log->size, &unit_size, sizeof(uint16_t));
+ log->size += sizeof(uint16_t);
+ }
+
+ // Write name/unit strings themselves
+ // Must not use NULL as source pointer for memcpy.
+ if (name_size != 0) {
+ memcpy(log->buffer + log->size, varinfo->name, name_size);
+ log->size += name_size;
+ }
+ if (unit_size != 0) {
+ memcpy(log->buffer + log->size, varinfo->unit, unit_size);
+ log->size += unit_size;
+ }
+ }
}
- memcpy((log->buffer) + log->size, &data, sizeof(float32_t));
- log->size += sizeof(float32_t);
+ memcpy(log->buffer + log->size, datap, datalen);
+ log->size += datalen;
log->args_num++;
return DLT_RETURN_OK;
}
-DltReturnValue dlt_user_log_write_float64(DltContextData *log, float64_t data)
+// Generic implementation for all "simple" types
+static DltReturnValue dlt_user_log_write_generic_formatted(DltContextData *log, const void *datap, size_t datalen, uint32_t type_info, DltFormatType type)
{
- uint32_t type_info;
-
if (log == NULL)
return DLT_RETURN_WRONG_PARAMETER;
+ /* Have to cast type to signed type because some compilers assume that DltFormatType is unsigned and issue a warning */
+ if (((int16_t)type < DLT_FORMAT_DEFAULT) || (type >= DLT_FORMAT_MAX)) {
+ dlt_vlog(LOG_ERR, "Format type %d is outside valid range", type);
+ return DLT_RETURN_WRONG_PARAMETER;
+ }
+
if (!dlt_user_initialised) {
dlt_vlog(LOG_WARNING, "%s dlt_user_initialised false\n", __FUNCTION__);
return DLT_RETURN_ERROR;
}
- if (sizeof(float64_t) != 8)
- return DLT_RETURN_ERROR;
-
- if ((log->size + sizeof(float64_t)) > dlt_user.log_buf_len)
+ size_t needed_size = datalen;
+ if ((log->size + needed_size) > dlt_user.log_buf_len)
return DLT_RETURN_USER_BUFFER_FULL;
if (dlt_user.verbose_mode) {
- if ((log->size + sizeof(uint32_t) + sizeof(float64_t)) > dlt_user.log_buf_len)
+ needed_size += sizeof(uint32_t); // Type Info field
+ if ((log->size + needed_size) > dlt_user.log_buf_len)
return DLT_RETURN_USER_BUFFER_FULL;
- type_info = DLT_TYPE_INFO_FLOA | DLT_TYLE_64BIT;
+ // Genivi extension: put formatting hints into the unused (for SINT/UINT/FLOA) SCOD field.
+ if ((type >= DLT_FORMAT_HEX8) && (type <= DLT_FORMAT_HEX64))
+ type_info |= DLT_SCOD_HEX;
- memcpy((log->buffer) + log->size, &(type_info), sizeof(uint32_t));
+ else if ((type >= DLT_FORMAT_BIN8) && (type <= DLT_FORMAT_BIN16))
+ type_info |= DLT_SCOD_BIN;
+
+ memcpy(log->buffer + log->size, &type_info, sizeof(uint32_t));
log->size += sizeof(uint32_t);
}
- memcpy((log->buffer) + log->size, &data, sizeof(float64_t));
- log->size += sizeof(float64_t);
+ memcpy(log->buffer + log->size, datap, datalen);
+ log->size += datalen;
log->args_num++;
return DLT_RETURN_OK;
}
-DltReturnValue dlt_user_log_write_uint(DltContextData *log, unsigned int data)
+DltReturnValue dlt_user_log_write_float32(DltContextData *log, float32_t data)
+{
+ if (sizeof(float32_t) != 4)
+ return DLT_RETURN_ERROR;
+
+ uint32_t type_info = DLT_TYPE_INFO_FLOA | DLT_TYLE_32BIT;
+ return dlt_user_log_write_generic_attr(log, &data, sizeof(float32_t), type_info, NULL);
+}
+
+DltReturnValue dlt_user_log_write_float64(DltContextData *log, float64_t data)
+{
+ if (sizeof(float64_t) != 8)
+ return DLT_RETURN_ERROR;
+
+ uint32_t type_info = DLT_TYPE_INFO_FLOA | DLT_TYLE_64BIT;
+ return dlt_user_log_write_generic_attr(log, &data, sizeof(float64_t), type_info, NULL);
+}
+
+DltReturnValue dlt_user_log_write_float32_attr(DltContextData *log, float32_t data, const char *name, const char *unit)
+{
+ if (sizeof(float32_t) != 4)
+ return DLT_RETURN_ERROR;
+
+ uint32_t type_info = DLT_TYPE_INFO_FLOA | DLT_TYLE_32BIT;
+ const VarInfo var_info = { name, unit, true };
+ return dlt_user_log_write_generic_attr(log, &data, sizeof(float32_t), type_info, &var_info);
+}
+
+DltReturnValue dlt_user_log_write_float64_attr(DltContextData *log, float64_t data, const char *name, const char *unit)
+{
+ if (sizeof(float64_t) != 8)
+ return DLT_RETURN_ERROR;
+
+ uint32_t type_info = DLT_TYPE_INFO_FLOA | DLT_TYLE_64BIT;
+ const VarInfo var_info = { name, unit, true };
+ return dlt_user_log_write_generic_attr(log, &data, sizeof(float64_t), type_info, &var_info);
+}
+
+DltReturnValue dlt_user_log_write_uint_attr(DltContextData *log, unsigned int data, const char *name, const char *unit)
{
if (log == NULL)
return DLT_RETURN_WRONG_PARAMETER;
@@ -1906,22 +2033,22 @@ DltReturnValue dlt_user_log_write_uint(DltContextData *log, unsigned int data)
switch (sizeof(unsigned int)) {
case 1:
{
- return dlt_user_log_write_uint8(log, (uint8_t)data);
+ return dlt_user_log_write_uint8_attr(log, (uint8_t)data, name, unit);
break;
}
case 2:
{
- return dlt_user_log_write_uint16(log, (uint16_t)data);
+ return dlt_user_log_write_uint16_attr(log, (uint16_t)data, name, unit);
break;
}
case 4:
{
- return dlt_user_log_write_uint32(log, (uint32_t)data);
+ return dlt_user_log_write_uint32_attr(log, (uint32_t)data, name, unit);
break;
}
case 8:
{
- return dlt_user_log_write_uint64(log, (uint64_t)data);
+ return dlt_user_log_write_uint64_attr(log, (uint64_t)data, name, unit);
break;
}
default:
@@ -1936,314 +2063,83 @@ DltReturnValue dlt_user_log_write_uint(DltContextData *log, unsigned int data)
DltReturnValue dlt_user_log_write_uint8(DltContextData *log, uint8_t data)
{
- uint32_t type_info;
-
- if (log == NULL)
- return DLT_RETURN_WRONG_PARAMETER;
-
- if (!dlt_user_initialised) {
- dlt_vlog(LOG_WARNING, "%s dlt_user_initialised false\n", __FUNCTION__);
- return DLT_RETURN_ERROR;
- }
-
- if ((log->size + sizeof(uint8_t)) > dlt_user.log_buf_len)
- return DLT_RETURN_USER_BUFFER_FULL;
-
- if (dlt_user.verbose_mode) {
- if ((log->size + sizeof(uint32_t) + sizeof(uint8_t)) > dlt_user.log_buf_len)
- return DLT_RETURN_USER_BUFFER_FULL;
-
- type_info = DLT_TYPE_INFO_UINT | DLT_TYLE_8BIT;
-
- memcpy((log->buffer) + log->size, &(type_info), sizeof(uint32_t));
- log->size += sizeof(uint32_t);
- }
-
- memcpy((log->buffer) + log->size, &data, sizeof(uint8_t));
- log->size += sizeof(uint8_t);
-
- log->args_num++;
-
- return DLT_RETURN_OK;
+ uint32_t type_info = DLT_TYPE_INFO_UINT | DLT_TYLE_8BIT;
+ return dlt_user_log_write_generic_attr(log, &data, sizeof(uint8_t), type_info, NULL);
}
DltReturnValue dlt_user_log_write_uint16(DltContextData *log, uint16_t data)
{
- uint32_t type_info;
-
- if (log == NULL)
- return DLT_RETURN_WRONG_PARAMETER;
-
- if (!dlt_user_initialised) {
- dlt_vlog(LOG_WARNING, "%s dlt_user_initialised false\n", __FUNCTION__);
- return DLT_RETURN_ERROR;
- }
-
- if ((log->size + sizeof(uint16_t)) > dlt_user.log_buf_len)
- return DLT_RETURN_USER_BUFFER_FULL;
-
- if (dlt_user.verbose_mode) {
- if ((log->size + sizeof(uint32_t) + sizeof(uint16_t)) > dlt_user.log_buf_len)
- return DLT_RETURN_USER_BUFFER_FULL;
-
- type_info = DLT_TYPE_INFO_UINT | DLT_TYLE_16BIT;
-
- memcpy((log->buffer) + log->size, &(type_info), sizeof(uint32_t));
- log->size += sizeof(uint32_t);
- }
-
- memcpy((log->buffer) + log->size, &data, sizeof(uint16_t));
- log->size += sizeof(uint16_t);
-
- log->args_num++;
-
- return DLT_RETURN_OK;
+ uint32_t type_info = DLT_TYPE_INFO_UINT | DLT_TYLE_16BIT;
+ return dlt_user_log_write_generic_attr(log, &data, sizeof(uint16_t), type_info, NULL);
}
DltReturnValue dlt_user_log_write_uint32(DltContextData *log, uint32_t data)
{
- uint32_t type_info;
-
- if (log == NULL)
- return DLT_RETURN_WRONG_PARAMETER;
-
- if (!dlt_user_initialised) {
- dlt_vlog(LOG_WARNING, "%s dlt_user_initialised false\n", __FUNCTION__);
- return DLT_RETURN_ERROR;
- }
-
- if ((log->size + sizeof(uint32_t)) > dlt_user.log_buf_len)
- return DLT_RETURN_USER_BUFFER_FULL;
-
- if (dlt_user.verbose_mode) {
- if ((log->size + sizeof(uint32_t) + sizeof(uint32_t)) > dlt_user.log_buf_len)
- return DLT_RETURN_USER_BUFFER_FULL;
-
- type_info = DLT_TYPE_INFO_UINT | DLT_TYLE_32BIT;
-
- memcpy((log->buffer) + log->size, &(type_info), sizeof(uint32_t));
- log->size += sizeof(uint32_t);
- }
-
- memcpy((log->buffer) + log->size, &data, sizeof(uint32_t));
- log->size += sizeof(uint32_t);
-
- log->args_num++;
-
- return DLT_RETURN_OK;
+ uint32_t type_info = DLT_TYPE_INFO_UINT | DLT_TYLE_32BIT;
+ return dlt_user_log_write_generic_attr(log, &data, sizeof(uint32_t), type_info, NULL);
}
DltReturnValue dlt_user_log_write_uint64(DltContextData *log, uint64_t data)
{
- uint32_t type_info;
-
- if (log == NULL)
- return DLT_RETURN_WRONG_PARAMETER;
-
- if (!dlt_user_initialised) {
- dlt_vlog(LOG_WARNING, "%s dlt_user_initialised false\n", __FUNCTION__);
- return DLT_RETURN_ERROR;
- }
-
- if ((log->size + sizeof(uint64_t)) > dlt_user.log_buf_len)
- return DLT_RETURN_USER_BUFFER_FULL;
-
- if (dlt_user.verbose_mode) {
- if ((log->size + sizeof(uint32_t) + sizeof(uint64_t)) > dlt_user.log_buf_len)
- return DLT_RETURN_USER_BUFFER_FULL;
+ uint32_t type_info = DLT_TYPE_INFO_UINT | DLT_TYLE_64BIT;
+ return dlt_user_log_write_generic_attr(log, &data, sizeof(uint64_t), type_info, NULL);
+}
- type_info = DLT_TYPE_INFO_UINT | DLT_TYLE_64BIT;
+DltReturnValue dlt_user_log_write_uint(DltContextData *log, unsigned int data)
+{
+ return dlt_user_log_write_uint_attr(log, data, NULL, NULL);
+}
- memcpy((log->buffer) + log->size, &(type_info), sizeof(uint32_t));
- log->size += sizeof(uint32_t);
- }
+DltReturnValue dlt_user_log_write_uint8_attr(DltContextData *log, uint8_t data, const char *name, const char *unit)
+{
+ uint32_t type_info = DLT_TYPE_INFO_UINT | DLT_TYLE_8BIT;
+ const VarInfo var_info = { name, unit, true };
+ return dlt_user_log_write_generic_attr(log, &data, sizeof(uint8_t), type_info, &var_info);
+}
- memcpy((log->buffer) + log->size, &data, sizeof(uint64_t));
- log->size += sizeof(uint64_t);
+DltReturnValue dlt_user_log_write_uint16_attr(DltContextData *log, uint16_t data, const char *name, const char *unit)
+{
+ uint32_t type_info = DLT_TYPE_INFO_UINT | DLT_TYLE_16BIT;
+ const VarInfo var_info = { name, unit, true };
+ return dlt_user_log_write_generic_attr(log, &data, sizeof(uint16_t), type_info, &var_info);
+}
- log->args_num++;
+DltReturnValue dlt_user_log_write_uint32_attr(DltContextData *log, uint32_t data, const char *name, const char *unit)
+{
+ uint32_t type_info = DLT_TYPE_INFO_UINT | DLT_TYLE_32BIT;
+ const VarInfo var_info = { name, unit, true };
+ return dlt_user_log_write_generic_attr(log, &data, sizeof(uint32_t), type_info, &var_info);
+}
- return DLT_RETURN_OK;
+DltReturnValue dlt_user_log_write_uint64_attr(DltContextData *log, uint64_t data, const char *name, const char *unit)
+{
+ uint32_t type_info = DLT_TYPE_INFO_UINT | DLT_TYLE_64BIT;
+ const VarInfo var_info = { name, unit, true };
+ return dlt_user_log_write_generic_attr(log, &data, sizeof(uint64_t), type_info, &var_info);
}
DltReturnValue dlt_user_log_write_uint8_formatted(DltContextData *log, uint8_t data, DltFormatType type)
{
- uint32_t type_info;
-
- if (log == NULL)
- return DLT_RETURN_WRONG_PARAMETER;
-
- /* Have to cast type to signed type because some compilers assume that DltFormatType is unsigned and issue a warning */
- if (((int16_t)type < DLT_FORMAT_DEFAULT) || (type >= DLT_FORMAT_MAX)) {
- dlt_vlog(LOG_ERR, "Format type %d is outside valid range", type);
- return DLT_RETURN_WRONG_PARAMETER;
- }
-
- if (!dlt_user_initialised) {
- dlt_vlog(LOG_WARNING, "%s dlt_user_initialised false\n", __FUNCTION__);
- return DLT_RETURN_ERROR;
- }
-
- if ((log->size + sizeof(uint16_t)) > dlt_user.log_buf_len)
- return DLT_RETURN_USER_BUFFER_FULL;
-
- if (dlt_user.verbose_mode) {
- if ((log->size + sizeof(uint32_t) + sizeof(uint16_t)) > dlt_user.log_buf_len)
- return DLT_RETURN_USER_BUFFER_FULL;
-
- type_info = DLT_TYPE_INFO_UINT | DLT_TYLE_8BIT;
-
- if ((type >= DLT_FORMAT_HEX8) && (type <= DLT_FORMAT_HEX64))
- type_info |= DLT_SCOD_HEX;
-
- else if ((type >= DLT_FORMAT_BIN8) && (type <= DLT_FORMAT_BIN16))
- type_info |= DLT_SCOD_BIN;
-
- memcpy((log->buffer) + log->size, &(type_info), sizeof(uint32_t));
- log->size += sizeof(uint32_t);
- }
-
- memcpy((log->buffer) + log->size, &data, sizeof(uint8_t));
- log->size += sizeof(uint8_t);
-
- log->args_num++;
-
- return DLT_RETURN_OK;
+ uint32_t type_info = DLT_TYPE_INFO_UINT | DLT_TYLE_8BIT;
+ return dlt_user_log_write_generic_formatted(log, &data, sizeof(uint8_t), type_info, type);
}
DltReturnValue dlt_user_log_write_uint16_formatted(DltContextData *log, uint16_t data, DltFormatType type)
{
- uint32_t type_info;
-
- if (log == NULL)
- return DLT_RETURN_WRONG_PARAMETER;
-
- /* Have to cast type to signed type because some compilers assume that DltFormatType is unsigned and issue a warning */
- if (((int16_t)type < DLT_FORMAT_DEFAULT) || (type >= DLT_FORMAT_MAX)) {
- dlt_vlog(LOG_ERR, "Format type %d is outside valid range", type);
- return DLT_RETURN_WRONG_PARAMETER;
- }
-
- if (!dlt_user_initialised) {
- dlt_vlog(LOG_WARNING, "%s dlt_user_initialised false\n", __FUNCTION__);
- return DLT_RETURN_ERROR;
- }
-
- if ((log->size + sizeof(uint16_t)) > dlt_user.log_buf_len)
- return DLT_RETURN_USER_BUFFER_FULL;
-
- if (dlt_user.verbose_mode) {
- if ((log->size + sizeof(uint32_t) + sizeof(uint16_t)) > dlt_user.log_buf_len)
- return DLT_RETURN_USER_BUFFER_FULL;
-
- type_info = DLT_TYPE_INFO_UINT | DLT_TYLE_16BIT;
-
- if ((type >= DLT_FORMAT_HEX8) && (type <= DLT_FORMAT_HEX64))
- type_info |= DLT_SCOD_HEX;
-
- else if ((type >= DLT_FORMAT_BIN8) && (type <= DLT_FORMAT_BIN16))
- type_info |= DLT_SCOD_BIN;
-
- memcpy((log->buffer) + log->size, &(type_info), sizeof(uint32_t));
- log->size += sizeof(uint32_t);
- }
-
- memcpy((log->buffer) + log->size, &data, sizeof(uint16_t));
- log->size += sizeof(uint16_t);
-
- log->args_num++;
-
- return DLT_RETURN_OK;
+ uint32_t type_info = DLT_TYPE_INFO_UINT | DLT_TYLE_16BIT;
+ return dlt_user_log_write_generic_formatted(log, &data, sizeof(uint16_t), type_info, type);
}
DltReturnValue dlt_user_log_write_uint32_formatted(DltContextData *log, uint32_t data, DltFormatType type)
{
- uint32_t type_info;
-
- if (log == NULL)
- return DLT_RETURN_WRONG_PARAMETER;
-
- /* Have to cast type to signed type because some compilers assume that DltFormatType is unsigned and issue a warning */
- if (((int16_t)type < DLT_FORMAT_DEFAULT) || (type >= DLT_FORMAT_MAX)) {
- dlt_vlog(LOG_ERR, "Format type %d is outside valid range", type);
- return DLT_RETURN_WRONG_PARAMETER;
- }
-
- if (!dlt_user_initialised) {
- dlt_vlog(LOG_WARNING, "%s dlt_user_initialised false\n", __FUNCTION__);
- return DLT_RETURN_ERROR;
- }
-
- if ((log->size + sizeof(uint16_t)) > dlt_user.log_buf_len)
- return DLT_RETURN_USER_BUFFER_FULL;
-
- if (dlt_user.verbose_mode) {
- if ((log->size + sizeof(uint32_t) + sizeof(uint16_t)) > dlt_user.log_buf_len)
- return DLT_RETURN_USER_BUFFER_FULL;
-
- type_info = DLT_TYPE_INFO_UINT | DLT_TYLE_32BIT;
-
- if ((type >= DLT_FORMAT_HEX8) && (type <= DLT_FORMAT_HEX64))
- type_info |= DLT_SCOD_HEX;
-
- else if ((type >= DLT_FORMAT_BIN8) && (type <= DLT_FORMAT_BIN16))
- type_info |= DLT_SCOD_BIN;
-
- memcpy((log->buffer) + log->size, &(type_info), sizeof(uint32_t));
- log->size += sizeof(uint32_t);
- }
-
- memcpy((log->buffer) + log->size, &data, sizeof(uint32_t));
- log->size += sizeof(uint32_t);
-
- log->args_num++;
-
- return DLT_RETURN_OK;
+ uint32_t type_info = DLT_TYPE_INFO_UINT | DLT_TYLE_32BIT;
+ return dlt_user_log_write_generic_formatted(log, &data, sizeof(uint32_t), type_info, type);
}
DltReturnValue dlt_user_log_write_uint64_formatted(DltContextData *log, uint64_t data, DltFormatType type)
{
- uint32_t type_info;
-
- if (log == NULL)
- return DLT_RETURN_WRONG_PARAMETER;
-
- /* Have to cast type to signed type because some compilers assume that DltFormatType is unsigned and issue a warning */
- if (((int16_t)type < DLT_FORMAT_DEFAULT) || (type >= DLT_FORMAT_MAX)) {
- dlt_vlog(LOG_ERR, "Format type %d is outside valid range", type);
- return DLT_RETURN_WRONG_PARAMETER;
- }
-
- if (!dlt_user_initialised) {
- dlt_vlog(LOG_WARNING, "%s dlt_user_initialised false\n", __FUNCTION__);
- return DLT_RETURN_ERROR;
- }
-
- if ((log->size + sizeof(uint16_t)) > dlt_user.log_buf_len)
- return DLT_RETURN_USER_BUFFER_FULL;
-
- if (dlt_user.verbose_mode) {
- if ((log->size + sizeof(uint32_t) + sizeof(uint16_t)) > dlt_user.log_buf_len)
- return DLT_RETURN_USER_BUFFER_FULL;
-
- type_info = DLT_TYPE_INFO_UINT | DLT_TYLE_64BIT;
-
- if ((type >= DLT_FORMAT_HEX8) && (type <= DLT_FORMAT_HEX64))
- type_info |= DLT_SCOD_HEX;
-
- else if ((type >= DLT_FORMAT_BIN8) && (type <= DLT_FORMAT_BIN16))
- type_info |= DLT_SCOD_BIN;
-
- memcpy((log->buffer) + log->size, &(type_info), sizeof(uint32_t));
- log->size += sizeof(uint32_t);
- }
-
- memcpy((log->buffer) + log->size, &data, sizeof(uint64_t));
- log->size += sizeof(uint64_t);
-
- log->args_num++;
-
- return DLT_RETURN_OK;
+ uint32_t type_info = DLT_TYPE_INFO_UINT | DLT_TYLE_64BIT;
+ return dlt_user_log_write_generic_formatted(log, &data, sizeof(uint64_t), type_info, type);
}
DltReturnValue dlt_user_log_write_ptr(DltContextData *log, void *data)
@@ -2274,7 +2170,7 @@ DltReturnValue dlt_user_log_write_ptr(DltContextData *log, void *data)
return DLT_RETURN_OK;
}
-DltReturnValue dlt_user_log_write_int(DltContextData *log, int data)
+DltReturnValue dlt_user_log_write_int_attr(DltContextData *log, int data, const char *name, const char *unit)
{
if (log == NULL)
return DLT_RETURN_WRONG_PARAMETER;
@@ -2287,22 +2183,22 @@ DltReturnValue dlt_user_log_write_int(DltContextData *log, int data)
switch (sizeof(int)) {
case 1:
{
- return dlt_user_log_write_int8(log, (int8_t)data);
+ return dlt_user_log_write_int8_attr(log, (int8_t)data, name, unit);
break;
}
case 2:
{
- return dlt_user_log_write_int16(log, (int16_t)data);
+ return dlt_user_log_write_int16_attr(log, (int16_t)data, name, unit);
break;
}
case 4:
{
- return dlt_user_log_write_int32(log, (int32_t)data);
+ return dlt_user_log_write_int32_attr(log, (int32_t)data, name, unit);
break;
}
case 8:
{
- return dlt_user_log_write_int64(log, (int64_t)data);
+ return dlt_user_log_write_int64_attr(log, (int64_t)data, name, unit);
break;
}
default:
@@ -2317,177 +2213,92 @@ DltReturnValue dlt_user_log_write_int(DltContextData *log, int data)
DltReturnValue dlt_user_log_write_int8(DltContextData *log, int8_t data)
{
- uint32_t type_info;
-
- if (log == NULL)
- return DLT_RETURN_WRONG_PARAMETER;
-
- if (!dlt_user_initialised) {
- dlt_vlog(LOG_WARNING, "%s dlt_user_initialised false\n", __FUNCTION__);
- return DLT_RETURN_ERROR;
- }
-
- if ((log->size + sizeof(int8_t)) > dlt_user.log_buf_len)
- return DLT_RETURN_USER_BUFFER_FULL;
-
- if (dlt_user.verbose_mode) {
- if ((log->size + sizeof(uint32_t) + sizeof(int8_t)) > dlt_user.log_buf_len)
- return DLT_RETURN_USER_BUFFER_FULL;
-
- type_info = DLT_TYPE_INFO_SINT | DLT_TYLE_8BIT;
-
- memcpy((log->buffer) + log->size, &(type_info), sizeof(uint32_t));
- log->size += sizeof(uint32_t);
- }
-
- memcpy((log->buffer) + log->size, &data, sizeof(int8_t));
- log->size += sizeof(int8_t);
-
- log->args_num++;
-
- return DLT_RETURN_OK;
+ uint32_t type_info = DLT_TYPE_INFO_SINT | DLT_TYLE_8BIT;
+ return dlt_user_log_write_generic_attr(log, &data, sizeof(int8_t), type_info, NULL);
}
DltReturnValue dlt_user_log_write_int16(DltContextData *log, int16_t data)
{
- uint32_t type_info;
-
- if (log == NULL)
- return DLT_RETURN_WRONG_PARAMETER;
-
- if (!dlt_user_initialised) {
- dlt_vlog(LOG_WARNING, "%s dlt_user_initialised false\n", __FUNCTION__);
- return DLT_RETURN_ERROR;
- }
-
- if ((log->size + sizeof(int16_t)) > dlt_user.log_buf_len)
- return DLT_RETURN_USER_BUFFER_FULL;
-
- if (dlt_user.verbose_mode) {
- if ((log->size + sizeof(uint32_t) + sizeof(int16_t)) > dlt_user.log_buf_len)
- return DLT_RETURN_USER_BUFFER_FULL;
-
- type_info = DLT_TYPE_INFO_SINT | DLT_TYLE_16BIT;
-
- memcpy((log->buffer) + log->size, &(type_info), sizeof(uint32_t));
- log->size += sizeof(uint32_t);
- }
-
- memcpy((log->buffer) + log->size, &data, sizeof(int16_t));
- log->size += sizeof(int16_t);
-
- log->args_num++;
-
- return DLT_RETURN_OK;
+ uint32_t type_info = DLT_TYPE_INFO_SINT | DLT_TYLE_16BIT;
+ return dlt_user_log_write_generic_attr(log, &data, sizeof(int16_t), type_info, NULL);
}
DltReturnValue dlt_user_log_write_int32(DltContextData *log, int32_t data)
{
- uint32_t type_info;
-
- if (log == NULL)
- return DLT_RETURN_WRONG_PARAMETER;
-
- if (!dlt_user_initialised) {
- dlt_vlog(LOG_WARNING, "%s dlt_user_initialised false\n", __FUNCTION__);
- return DLT_RETURN_ERROR;
- }
-
- if ((log->size + sizeof(int32_t)) > dlt_user.log_buf_len)
- return DLT_RETURN_USER_BUFFER_FULL;
-
- if (dlt_user.verbose_mode) {
- if ((log->size + sizeof(uint32_t) + sizeof(int32_t)) > dlt_user.log_buf_len)
- return DLT_RETURN_USER_BUFFER_FULL;
-
- type_info = DLT_TYPE_INFO_SINT | DLT_TYLE_32BIT;
-
- memcpy((log->buffer) + log->size, &(type_info), sizeof(uint32_t));
- log->size += sizeof(uint32_t);
- }
-
- memcpy((log->buffer) + log->size, &data, sizeof(int32_t));
- log->size += sizeof(int32_t);
-
- log->args_num++;
-
- return DLT_RETURN_OK;
+ uint32_t type_info = DLT_TYPE_INFO_SINT | DLT_TYLE_32BIT;
+ return dlt_user_log_write_generic_attr(log, &data, sizeof(int32_t), type_info, NULL);
}
DltReturnValue dlt_user_log_write_int64(DltContextData *log, int64_t data)
{
- uint32_t type_info;
-
- if (log == NULL)
- return DLT_RETURN_WRONG_PARAMETER;
-
- if (!dlt_user_initialised) {
- dlt_vlog(LOG_WARNING, "%s dlt_user_initialised false\n", __FUNCTION__);
- return DLT_RETURN_ERROR;
- }
-
- if ((log->size + sizeof(int64_t)) > dlt_user.log_buf_len)
- return DLT_RETURN_USER_BUFFER_FULL;
-
- if (dlt_user.verbose_mode) {
- if ((log->size + sizeof(uint32_t) + sizeof(int64_t)) > dlt_user.log_buf_len)
- return DLT_RETURN_USER_BUFFER_FULL;
+ uint32_t type_info = DLT_TYPE_INFO_SINT | DLT_TYLE_64BIT;
+ return dlt_user_log_write_generic_attr(log, &data, sizeof(int64_t), type_info, NULL);
+}
- type_info = DLT_TYPE_INFO_SINT | DLT_TYLE_64BIT;
+DltReturnValue dlt_user_log_write_int(DltContextData *log, int data)
+{
+ return dlt_user_log_write_int_attr(log, data, NULL, NULL);
+}
- memcpy((log->buffer) + log->size, &(type_info), sizeof(uint32_t));
- log->size += sizeof(uint32_t);
- }
+DltReturnValue dlt_user_log_write_int8_attr(DltContextData *log, int8_t data, const char *name, const char *unit)
+{
+ uint32_t type_info = DLT_TYPE_INFO_SINT | DLT_TYLE_8BIT;
+ const VarInfo var_info = { name, unit, true };
+ return dlt_user_log_write_generic_attr(log, &data, sizeof(int8_t), type_info, &var_info);
+}
- memcpy((log->buffer) + log->size, &data, sizeof(int64_t));
- log->size += sizeof(int64_t);
+DltReturnValue dlt_user_log_write_int16_attr(DltContextData *log, int16_t data, const char *name, const char *unit)
+{
+ uint32_t type_info = DLT_TYPE_INFO_SINT | DLT_TYLE_16BIT;
+ const VarInfo var_info = { name, unit, true };
+ return dlt_user_log_write_generic_attr(log, &data, sizeof(int16_t), type_info, &var_info);
+}
- log->args_num++;
+DltReturnValue dlt_user_log_write_int32_attr(DltContextData *log, int32_t data, const char *name, const char *unit)
+{
+ uint32_t type_info = DLT_TYPE_INFO_SINT | DLT_TYLE_32BIT;
+ const VarInfo var_info = { name, unit, true };
+ return dlt_user_log_write_generic_attr(log, &data, sizeof(int32_t), type_info, &var_info);
+}
- return DLT_RETURN_OK;
+DltReturnValue dlt_user_log_write_int64_attr(DltContextData *log, int64_t data, const char *name, const char *unit)
+{
+ uint32_t type_info = DLT_TYPE_INFO_SINT | DLT_TYLE_64BIT;
+ const VarInfo var_info = { name, unit, true };
+ return dlt_user_log_write_generic_attr(log, &data, sizeof(int64_t), type_info, &var_info);
}
DltReturnValue dlt_user_log_write_bool(DltContextData *log, uint8_t data)
{
- uint32_t type_info;
-
- if (log == NULL)
- return DLT_RETURN_WRONG_PARAMETER;
-
- if (!dlt_user_initialised) {
- dlt_vlog(LOG_WARNING, "%s dlt_user_initialised false\n", __FUNCTION__);
- return DLT_RETURN_ERROR;
- }
-
- if ((log->size + sizeof(uint8_t)) > dlt_user.log_buf_len)
- return DLT_RETURN_USER_BUFFER_FULL;
-
- if (dlt_user.verbose_mode) {
- if ((log->size + sizeof(uint32_t) + sizeof(uint8_t)) > dlt_user.log_buf_len)
- return DLT_RETURN_USER_BUFFER_FULL;
-
- type_info = DLT_TYPE_INFO_BOOL;
-
- memcpy((log->buffer) + log->size, &(type_info), sizeof(uint32_t));
- log->size += sizeof(uint32_t);
- }
-
- memcpy((log->buffer) + log->size, &data, sizeof(uint8_t));
- log->size += sizeof(uint8_t);
-
- log->args_num++;
+ uint32_t type_info = DLT_TYPE_INFO_BOOL;
+ return dlt_user_log_write_generic_attr(log, &data, sizeof(uint8_t), type_info, NULL);
+}
- return DLT_RETURN_OK;
+DltReturnValue dlt_user_log_write_bool_attr(DltContextData *log, uint8_t data, const char *name)
+{
+ uint32_t type_info = DLT_TYPE_INFO_BOOL;
+ const VarInfo var_info = { name, NULL, false };
+ return dlt_user_log_write_generic_attr(log, &data, sizeof(uint8_t), type_info, &var_info);
}
DltReturnValue dlt_user_log_write_string(DltContextData *log, const char *text)
{
- return dlt_user_log_write_string_utils(log, text, ASCII_STRING);
+ return dlt_user_log_write_string_utils_attr(log, text, ASCII_STRING, NULL, false);
+}
+
+DltReturnValue dlt_user_log_write_string_attr(DltContextData *log, const char *text, const char *name)
+{
+ return dlt_user_log_write_string_utils_attr(log, text, ASCII_STRING, name, true);
}
DltReturnValue dlt_user_log_write_sized_string(DltContextData *log, const char *text, uint16_t length)
{
- return dlt_user_log_write_sized_string_utils(log, text, length, ASCII_STRING);
+ return dlt_user_log_write_sized_string_utils_attr(log, text, length, ASCII_STRING, NULL, false);
+}
+
+DltReturnValue dlt_user_log_write_sized_string_attr(DltContextData *log, const char *text, uint16_t length, const char *name)
+{
+ return dlt_user_log_write_sized_string_utils_attr(log, text, length, ASCII_STRING, name, true);
}
DltReturnValue dlt_user_log_write_constant_string(DltContextData *log, const char *text)
@@ -2496,32 +2307,46 @@ DltReturnValue dlt_user_log_write_constant_string(DltContextData *log, const cha
return dlt_user.verbose_mode ? dlt_user_log_write_string(log, text) : DLT_RETURN_OK;
}
+DltReturnValue dlt_user_log_write_constant_string_attr(DltContextData *log, const char *text, const char *name)
+{
+ /* Send parameter only in verbose mode */
+ return dlt_user.verbose_mode ? dlt_user_log_write_string_attr(log, text, name) : DLT_RETURN_OK;
+}
+
DltReturnValue dlt_user_log_write_sized_constant_string(DltContextData *log, const char *text, uint16_t length)
{
/* Send parameter only in verbose mode */
return dlt_user.verbose_mode ? dlt_user_log_write_sized_string(log, text, length) : DLT_RETURN_OK;
}
+DltReturnValue dlt_user_log_write_sized_constant_string_attr(DltContextData *log, const char *text, uint16_t length, const char *name)
+{
+ /* Send parameter only in verbose mode */
+ return dlt_user.verbose_mode ? dlt_user_log_write_sized_string_attr(log, text, length, name) : DLT_RETURN_OK;
+}
+
DltReturnValue dlt_user_log_write_utf8_string(DltContextData *log, const char *text)
{
- return dlt_user_log_write_string_utils(log, text, UTF8_STRING);
+ return dlt_user_log_write_string_utils_attr(log, text, UTF8_STRING, NULL, false);
}
-DltReturnValue dlt_user_log_write_sized_utf8_string(DltContextData *log, const char *text, uint16_t length)
+DltReturnValue dlt_user_log_write_utf8_string_attr(DltContextData *log, const char *text, const char *name)
{
- return dlt_user_log_write_sized_string_utils(log, text, length, UTF8_STRING);
+ return dlt_user_log_write_string_utils_attr(log, text, UTF8_STRING, name, true);
}
-DltReturnValue dlt_user_log_write_sized_string_utils(DltContextData *log, const char *text, uint16_t length, const enum StringType type)
+DltReturnValue dlt_user_log_write_sized_utf8_string(DltContextData *log, const char *text, uint16_t length)
{
- uint16_t arg_size = 0;
- uint32_t type_info = 0;
- size_t new_log_size = 0;
- DltReturnValue ret = DLT_RETURN_OK;
+ return dlt_user_log_write_sized_string_utils_attr(log, text, length, UTF8_STRING, NULL, false);
+}
- size_t str_truncate_message_length = strlen(STR_TRUNCATED_MESSAGE) + 1;
- size_t max_payload_str_msg;
+DltReturnValue dlt_user_log_write_sized_utf8_string_attr(DltContextData *log, const char *text, uint16_t length, const char *name)
+{
+ return dlt_user_log_write_sized_string_utils_attr(log, text, length, UTF8_STRING, name, true);
+}
+static DltReturnValue dlt_user_log_write_sized_string_utils_attr(DltContextData *log, const char *text, uint16_t length, const enum StringType type, const char *name, bool with_var_info)
+{
if ((log == NULL) || (text == NULL))
return DLT_RETURN_WRONG_PARAMETER;
@@ -2530,12 +2355,27 @@ DltReturnValue dlt_user_log_write_sized_string_utils(DltContextData *log, const
return DLT_RETURN_ERROR;
}
- arg_size = (uint16_t) (length + 1);
+ const uint16_t name_size = (name != NULL) ? strlen(name)+1 : 0;
- new_log_size = log->size + arg_size + sizeof(uint16_t);
+ uint16_t arg_size = (uint16_t) (length + 1);
- if (dlt_user.verbose_mode)
+ size_t new_log_size = log->size + arg_size + sizeof(uint16_t);
+
+ uint32_t type_info = 0;
+
+ if (dlt_user.verbose_mode) {
new_log_size += sizeof(uint32_t);
+ if (with_var_info) {
+ new_log_size += sizeof(uint16_t); // length of "name" attribute
+ new_log_size += name_size; // the "name" attribute itself
+
+ type_info |= DLT_TYPE_INFO_VARI;
+ }
+ }
+
+ size_t str_truncate_message_length = strlen(STR_TRUNCATED_MESSAGE) + 1;
+ size_t max_payload_str_msg;
+ DltReturnValue ret = DLT_RETURN_OK;
/* Check log size condition */
if (new_log_size > dlt_user.log_buf_len) {
@@ -2549,6 +2389,10 @@ DltReturnValue dlt_user_log_write_sized_string_utils(DltContextData *log, const
if (dlt_user.verbose_mode) {
min_payload_str_truncate_msg += sizeof(uint32_t);
arg_size -= (uint16_t) sizeof(uint32_t);
+ if (with_var_info) {
+ min_payload_str_truncate_msg += sizeof(uint16_t) + name_size;
+ arg_size -= sizeof(uint16_t) + name_size;
+ }
}
/* Return when dlt_user.log_buf_len does not have enough space for min_payload_str_truncate_msg */
@@ -2589,34 +2433,45 @@ DltReturnValue dlt_user_log_write_sized_string_utils(DltContextData *log, const
if (dlt_user.verbose_mode) {
switch (type) {
case ASCII_STRING:
- {
- type_info = DLT_TYPE_INFO_STRG | DLT_SCOD_ASCII;
+ type_info |= DLT_TYPE_INFO_STRG | DLT_SCOD_ASCII;
break;
- }
case UTF8_STRING:
- {
- type_info = DLT_TYPE_INFO_STRG | DLT_SCOD_UTF8;
+ type_info |= DLT_TYPE_INFO_STRG | DLT_SCOD_UTF8;
break;
- }
default:
- {
/* Do nothing */
break;
}
- }
- memcpy((log->buffer) + log->size, &(type_info), sizeof(uint32_t));
+ memcpy(log->buffer + log->size, &type_info, sizeof(uint32_t));
log->size += sizeof(uint32_t);
}
- memcpy((log->buffer) + log->size, &(arg_size), sizeof(uint16_t));
+ memcpy(log->buffer + log->size, &arg_size, sizeof(uint16_t));
log->size += sizeof(uint16_t);
+ if (dlt_user.verbose_mode) {
+ if (with_var_info) {
+ // Write length of "name" attribute.
+ // We assume that the protocol allows zero-sized strings here (which this code will create
+ // when the input pointer is NULL).
+ memcpy(log->buffer + log->size, &name_size, sizeof(uint16_t));
+ log->size += sizeof(uint16_t);
+
+ // Write name string itself.
+ // Must not use NULL as source pointer for memcpy. This check assures that.
+ if (name_size != 0) {
+ memcpy(log->buffer + log->size, name, name_size);
+ log->size += name_size;
+ }
+ }
+ }
+
switch (ret) {
case DLT_RETURN_OK:
{
/* Whole string will be copied */
- memcpy((log->buffer) + log->size, text, length);
+ memcpy(log->buffer + log->size, text, length);
/* The input string might not be null-terminated, so we're doing that by ourselves */
log->buffer[log->size + length] = '\0';
log->size += arg_size;
@@ -2625,11 +2480,11 @@ DltReturnValue dlt_user_log_write_sized_string_utils(DltContextData *log, const
case DLT_RETURN_USER_BUFFER_FULL:
{
/* Only copy partial string */
- memcpy((log->buffer) + log->size, text, max_payload_str_msg);
+ memcpy(log->buffer + log->size, text, max_payload_str_msg);
log->size += max_payload_str_msg;
/* Append string truncate the input string */
- memcpy((log->buffer) + log->size, STR_TRUNCATED_MESSAGE, str_truncate_message_length);
+ memcpy(log->buffer + log->size, STR_TRUNCATED_MESSAGE, str_truncate_message_length);
log->size += str_truncate_message_length;
break;
}
@@ -2645,13 +2500,13 @@ DltReturnValue dlt_user_log_write_sized_string_utils(DltContextData *log, const
return ret;
}
-DltReturnValue dlt_user_log_write_string_utils(DltContextData *log, const char *text, const enum StringType type)
+static DltReturnValue dlt_user_log_write_string_utils_attr(DltContextData *log, const char *text, const enum StringType type, const char *name, bool with_var_info)
{
if ((log == NULL) || (text == NULL))
return DLT_RETURN_WRONG_PARAMETER;
uint16_t length = (uint16_t) strlen(text);
- return dlt_user_log_write_sized_string_utils(log, text, length, type);
+ return dlt_user_log_write_sized_string_utils_attr(log, text, length, type, name, with_var_info);
}
DltReturnValue dlt_register_injection_callback_with_id(DltContext *handle, uint32_t service_id,
diff --git a/src/shared/dlt_common.c b/src/shared/dlt_common.c
index 5c28113..af7a373 100644
--- a/src/shared/dlt_common.c
+++ b/src/shared/dlt_common.c
@@ -31,6 +31,7 @@
#include <time.h> /* for localtime_r(), strftime() */
#include <limits.h> /* for NAME_MAX */
#include <inttypes.h> /* for PRI formatting macro */
+#include <stdbool.h>
#include <stdarg.h>
#include <err.h>
@@ -81,6 +82,7 @@ static int logging_mode = DLT_LOG_TO_CONSOLE;
static int logging_level = LOG_INFO;
static char logging_filename[NAME_MAX + 1] = "";
static FILE *logging_handle = NULL;
+static bool print_with_attributes = false;
char *message_type[] = { "log", "app_trace", "nw_trace", "control", "", "", "", "" };
char *log_info[] = { "", "fatal", "error", "warn", "info", "debug", "verbose", "", "", "", "", "", "", "", "", "" };
@@ -1778,6 +1780,11 @@ void dlt_log_set_shm_name(const char * env_shm_name)
}
#endif
+void dlt_print_with_attributes(bool state)
+{
+ print_with_attributes = state;
+}
+
void dlt_log_init(int mode)
{
if ((mode < DLT_LOG_TO_CONSOLE) || (mode > DLT_LOG_DROPPED)) {
@@ -3297,6 +3304,13 @@ DltReturnValue dlt_message_argument_print(DltMessage *msg,
uint32_t quantisation_tmp = 0;
+ // pointer to the value string
+ char* value_text = text;
+ // pointer to the "unit" attribute string, if there is one (only for *INT and FLOAT*)
+ const uint8_t* unit_text_src = NULL;
+ // length of the "unit" attribute string, if there is one (only for *INT and FLOAT*)
+ size_t unit_text_len = 0;
+
/* apparently this makes no sense but needs to be done to prevent compiler warning.
* This variable is only written by DLT_MSG_READ_VALUE macro in if (type_info & DLT_TYPE_INFO_FIXP)
* case but never read anywhere */
@@ -3328,11 +3342,20 @@ DltReturnValue dlt_message_argument_print(DltMessage *msg,
if ((*datalength) < length2)
return DLT_RETURN_ERROR;
+ if (print_with_attributes) {
+ // Print "name" attribute, if we have one with non-zero size.
+ if (length2 > 1) {
+ snprintf(text, textlength, "%s:", *ptr);
+ value_text += length2+1-1; // +1 for ":" and -1 for NUL
+ textlength -= length2+1-1;
+ }
+ }
+
*ptr += length2;
*datalength -= length2;
}
- DLT_MSG_READ_STRING(text, *ptr, *datalength, textlength, length);
+ DLT_MSG_READ_STRING(value_text, *ptr, *datalength, textlength, length);
if ((*datalength) < 0)
return DLT_RETURN_ERROR;
@@ -3351,6 +3374,15 @@ DltReturnValue dlt_message_argument_print(DltMessage *msg,
if ((*datalength) < length2)
return DLT_RETURN_ERROR;
+ if (print_with_attributes) {
+ // Print "name" attribute, if we have one with non-zero size.
+ if (length2 > 1) {
+ snprintf(text, textlength, "%s:", *ptr);
+ value_text += length2+1-1; // +1 for ":" and -1 for NUL
+ textlength -= length2+1-2;
+ }
+ }
+
*ptr += length2;
*datalength -= length2;
}
@@ -3361,7 +3393,7 @@ DltReturnValue dlt_message_argument_print(DltMessage *msg,
if ((*datalength) < 0)
return DLT_RETURN_ERROR;
- snprintf(text, textlength, "%d", value8u);
+ snprintf(value_text, textlength, "%d", value8u);
}
else if ((type_info & DLT_TYPE_INFO_UINT) && (DLT_SCOD_BIN == (type_info & DLT_TYPE_INFO_SCOD)))
{
@@ -3381,7 +3413,7 @@ DltReturnValue dlt_message_argument_print(DltMessage *msg,
strcat(binary, (i == (value8u & i)) ? "1" : "0");
}
- snprintf(text, textlength, "0b%s", binary);
+ snprintf(value_text, textlength, "0b%s", binary);
}
if (DLT_TYLE_16BIT == (type_info & DLT_TYPE_INFO_TYLE)) {
@@ -3400,7 +3432,7 @@ DltReturnValue dlt_message_argument_print(DltMessage *msg,
strcat(binary, (i == (value16u & i)) ? "1" : "0");
}
- snprintf(text, textlength, "0b%s", binary);
+ snprintf(value_text, textlength, "0b%s", binary);
}
}
else if ((type_info & DLT_TYPE_INFO_UINT) && (DLT_SCOD_HEX == (type_info & DLT_TYPE_INFO_SCOD)))
@@ -3411,7 +3443,7 @@ DltReturnValue dlt_message_argument_print(DltMessage *msg,
if ((*datalength) < 0)
return DLT_RETURN_ERROR;
- snprintf(text, textlength, "0x%02x", value8u);
+ snprintf(value_text, textlength, "0x%02x", value8u);
}
if (DLT_TYLE_16BIT == (type_info & DLT_TYPE_INFO_TYLE)) {
@@ -3420,7 +3452,7 @@ DltReturnValue dlt_message_argument_print(DltMessage *msg,
if ((*datalength) < 0)
return DLT_RETURN_ERROR;
- snprintf(text, textlength, "0x%04x", value16u);
+ snprintf(value_text, textlength, "0x%04x", value16u);
}
if (DLT_TYLE_32BIT == (type_info & DLT_TYPE_INFO_TYLE)) {
@@ -3429,7 +3461,7 @@ DltReturnValue dlt_message_argument_print(DltMessage *msg,
if ((*datalength) < 0)
return DLT_RETURN_ERROR;
- snprintf(text, textlength, "0x%08x", value32u);
+ snprintf(value_text, textlength, "0x%08x", value32u);
}
if (DLT_TYLE_64BIT == (type_info & DLT_TYPE_INFO_TYLE)) {
@@ -3439,14 +3471,14 @@ DltReturnValue dlt_message_argument_print(DltMessage *msg,
if ((*datalength) < 0)
return DLT_RETURN_ERROR;
- snprintf(text, textlength, "0x%08x", value32u);
+ snprintf(value_text, textlength, "0x%08x", value32u);
*ptr -= 8;
DLT_MSG_READ_VALUE(value32u, *ptr, *datalength, uint32_t);
if ((*datalength) < 0)
return DLT_RETURN_ERROR;
- snprintf(text + strlen(text), textlength - strlen(text), "%08x", value32u);
+ snprintf(value_text + strlen(value_text), textlength - strlen(value_text), "%08x", value32u);
*ptr += 4;
}
}
@@ -3470,12 +3502,25 @@ DltReturnValue dlt_message_argument_print(DltMessage *msg,
if ((*datalength) < length2)
return DLT_RETURN_ERROR;
+ if (print_with_attributes) {
+ // Print "name" attribute, if we have one with non-zero size.
+ if (length2 > 1) {
+ snprintf(text, textlength, "%s:", *ptr);
+ value_text += length2+1-1; // +1 for the ":", and -1 for nul
+ textlength -= length2+1-1;
+ }
+ }
+
*ptr += length2;
*datalength -= length2;
if ((*datalength) < length3)
return DLT_RETURN_ERROR;
+ // We want to add the "unit" attribute only after the value, so remember its pointer and length here.
+ unit_text_src = *ptr;
+ unit_text_len = length3;
+
*ptr += length3;
*datalength -= length3;
}
@@ -3533,7 +3578,7 @@ DltReturnValue dlt_message_argument_print(DltMessage *msg,
if ((*datalength) < 0)
return DLT_RETURN_ERROR;
- snprintf(text, textlength, "%d", value8i);
+ snprintf(value_text, textlength, "%d", value8i);
}
else {
value8u = 0;
@@ -3542,7 +3587,7 @@ DltReturnValue dlt_message_argument_print(DltMessage *msg,
if ((*datalength) < 0)
return DLT_RETURN_ERROR;
- snprintf(text, textlength, "%d", value8u);
+ snprintf(value_text, textlength, "%d", value8u);
}
break;
@@ -3558,7 +3603,7 @@ DltReturnValue dlt_message_argument_print(DltMessage *msg,
return DLT_RETURN_ERROR;
value16i = (int16_t) DLT_ENDIAN_GET_16(msg->standardheader->htyp, value16i_tmp);
- snprintf(text, textlength, "%hd", value16i);
+ snprintf(value_text, textlength, "%hd", value16i);
}
else {
value16u = 0;
@@ -3569,7 +3614,7 @@ DltReturnValue dlt_message_argument_print(DltMessage *msg,
return DLT_RETURN_ERROR;
value16u = (uint16_t) DLT_ENDIAN_GET_16(msg->standardheader->htyp, value16u_tmp);
- snprintf(text, textlength, "%hu", value16u);
+ snprintf(value_text, textlength, "%hu", value16u);
}
break;
@@ -3585,7 +3630,7 @@ DltReturnValue dlt_message_argument_print(DltMessage *msg,
return DLT_RETURN_ERROR;
value32i = (int32_t) DLT_ENDIAN_GET_32(msg->standardheader->htyp, (uint32_t)value32i_tmp);
- snprintf(text, textlength, "%d", value32i);
+ snprintf(value_text, textlength, "%d", value32i);
}
else {
value32u = 0;
@@ -3596,7 +3641,7 @@ DltReturnValue dlt_message_argument_print(DltMessage *msg,
return DLT_RETURN_ERROR;
value32u = DLT_ENDIAN_GET_32(msg->standardheader->htyp, value32u_tmp);
- snprintf(text, textlength, "%u", value32u);
+ snprintf(value_text, textlength, "%u", value32u);
}
break;
@@ -3613,9 +3658,9 @@ DltReturnValue dlt_message_argument_print(DltMessage *msg,
value64i = (int64_t) DLT_ENDIAN_GET_64(msg->standardheader->htyp, (uint64_t)value64i_tmp);
#if defined (__WIN32__) && !defined(_MSC_VER)
- snprintf(text, textlength, "%I64d", value64i);
+ snprintf(value_text, textlength, "%I64d", value64i);
#else
- snprintf(text, textlength, "%" PRId64, value64i);
+ snprintf(value_text, textlength, "%" PRId64, value64i);
#endif
}
else {
@@ -3628,9 +3673,9 @@ DltReturnValue dlt_message_argument_print(DltMessage *msg,
value64u = DLT_ENDIAN_GET_64(msg->standardheader->htyp, value64u_tmp);
#if defined (__WIN32__) && !defined(_MSC_VER)
- snprintf(text, textlength, "%I64u", value64u);
+ snprintf(value_text, textlength, "%I64u", value64u);
#else
- snprintf(text, textlength, "%" PRIu64, value64u);
+ snprintf(value_text, textlength, "%" PRIu64, value64u);
#endif
}
@@ -3639,7 +3684,7 @@ DltReturnValue dlt_message_argument_print(DltMessage *msg,
case DLT_TYLE_128BIT:
{
if (*datalength >= 16)
- dlt_print_hex_string(text, (int) textlength, *ptr, 16);
+ dlt_print_hex_string(value_text, (int) textlength, *ptr, 16);
if ((*datalength) < 16)
return DLT_RETURN_ERROR;
@@ -3674,12 +3719,25 @@ DltReturnValue dlt_message_argument_print(DltMessage *msg,
if ((*datalength) < length2)
return DLT_RETURN_ERROR;
+ if (print_with_attributes) {
+ // Print "name" attribute, if we have one with non-zero size.
+ if (length2 > 1) {
+ snprintf(text, textlength, "%s:", *ptr);
+ value_text += length2+1-1; // +1 for ":" and -1 for NUL
+ textlength -= length2+1-1;
+ }
+ }
+
*ptr += length2;
*datalength -= length2;
if ((*datalength) < length3)
return DLT_RETURN_ERROR;
+ // We want to add the "unit" attribute only after the value, so remember its pointer and length here.
+ unit_text_src = *ptr;
+ unit_text_len = length3;
+
*ptr += length3;
*datalength -= length3;
}
@@ -3688,7 +3746,7 @@ DltReturnValue dlt_message_argument_print(DltMessage *msg,
case DLT_TYLE_8BIT:
{
if (*datalength >= 1)
- dlt_print_hex_string(text, (int) textlength, *ptr, 1);
+ dlt_print_hex_string(value_text, (int) textlength, *ptr, 1);
if ((*datalength) < 1)
return DLT_RETURN_ERROR;
@@ -3700,7 +3758,7 @@ DltReturnValue dlt_message_argument_print(DltMessage *msg,
case DLT_TYLE_16BIT:
{
if (*datalength >= 2)
- dlt_print_hex_string(text, (int) textlength, *ptr, 2);
+ dlt_print_hex_string(value_text, (int) textlength, *ptr, 2);
if ((*datalength) < 2)
return DLT_RETURN_ERROR;
@@ -3725,7 +3783,7 @@ DltReturnValue dlt_message_argument_print(DltMessage *msg,
value32f_tmp_int32i_swaped =
(int32_t) DLT_ENDIAN_GET_32(msg->standardheader->htyp, (uint32_t)value32f_tmp_int32i);
memcpy(&value32f, &value32f_tmp_int32i_swaped, sizeof(float32_t));
- snprintf(text, textlength, "%g", value32f);
+ snprintf(value_text, textlength, "%g", value32f);
}
else {
dlt_log(LOG_ERR, "Invalid size of float32_t\n");
@@ -3751,9 +3809,9 @@ DltReturnValue dlt_message_argument_print(DltMessage *msg,
(int64_t) DLT_ENDIAN_GET_64(msg->standardheader->htyp, (uint64_t)value64f_tmp_int64i);
memcpy(&value64f, &value64f_tmp_int64i_swaped, sizeof(float64_t));
#ifdef __arm__
- snprintf(text, textlength, "ILLEGAL");
+ snprintf(value_text, textlength, "ILLEGAL");
#else
- snprintf(text, textlength, "%g", value64f);
+ snprintf(value_text, textlength, "%g", value64f);
#endif
}
else {
@@ -3766,7 +3824,7 @@ DltReturnValue dlt_message_argument_print(DltMessage *msg,
case DLT_TYLE_128BIT:
{
if (*datalength >= 16)
- dlt_print_hex_string(text, textlength, *ptr, 16);
+ dlt_print_hex_string(value_text, textlength, *ptr, 16);
if ((*datalength) < 16)
return DLT_RETURN_ERROR;
@@ -3802,6 +3860,15 @@ DltReturnValue dlt_message_argument_print(DltMessage *msg,
if ((*datalength) < length2)
return DLT_RETURN_ERROR;
+ if (print_with_attributes) {
+ // Print "name" attribute, if we have one with non-zero size.
+ if (length2 > 1) {
+ snprintf(text, textlength, "%s:", *ptr);
+ value_text += length2+1-1; // +1 for ":" and -1 for NUL
+ textlength -= length2+1-1;
+ }
+ }
+
*ptr += length2;
*datalength -= length2;
}
@@ -3809,7 +3876,7 @@ DltReturnValue dlt_message_argument_print(DltMessage *msg,
if ((*datalength) < length)
return DLT_RETURN_ERROR;
- dlt_print_hex_string(text, (int) textlength, *ptr, length);
+ dlt_print_hex_string(value_text, (int) textlength, *ptr, length);
*ptr += length;
*datalength -= length;
}
@@ -3823,7 +3890,7 @@ DltReturnValue dlt_message_argument_print(DltMessage *msg,
length = DLT_ENDIAN_GET_16(msg->standardheader->htyp, value16u_tmp);
- DLT_MSG_READ_STRING(text, *ptr, *datalength, textlength, length);
+ DLT_MSG_READ_STRING(value_text, *ptr, *datalength, textlength, length);
if ((*datalength) < 0)
return DLT_RETURN_ERROR;
@@ -3837,6 +3904,18 @@ DltReturnValue dlt_message_argument_print(DltMessage *msg,
return DLT_RETURN_ERROR;
}
+ // Now write "unit" attribute, but only if it has more than only a nul-termination char.
+ if (print_with_attributes) {
+ if (unit_text_len > 1) {
+ // 'value_text' still points to the +start+ of the value text
+ size_t currLen = strlen(value_text);
+
+ char* unitText = value_text + currLen;
+ textlength -= currLen;
+ snprintf(unitText, textlength, ":%s", unit_text_src);
+ }
+ }
+
return DLT_RETURN_OK;
}
diff --git a/tests/gtest_dlt_user.cpp b/tests/gtest_dlt_user.cpp
index ef40d2e..ca5117c 100644
--- a/tests/gtest_dlt_user.cpp
+++ b/tests/gtest_dlt_user.cpp
@@ -48,30 +48,51 @@ extern "C" {
* int dlt_user_log_write_start_id(DltContext *handle, DltContextData *log, DltLogLevelType loglevel, uint32_t messageid);
* int dlt_user_log_write_finish(DltContextData *log);
* int dlt_user_log_write_bool(DltContextData *log, uint8_t data);
+ * int dlt_user_log_write_bool_attr(DltContextData *log, uint8_t data, const char *name);
* int dlt_user_log_write_float32(DltContextData *log, float32_t data);
+ * int dlt_user_log_write_float32_attr(DltContextData *log, float32_t data, const char *name, const char *unit);
* int dlt_user_log_write_float64(DltContextData *log, double data);
+ * int dlt_user_log_write_float64_attr(DltContextData *log, double data, const char *name, const char *unit);
* int dlt_user_log_write_uint(DltContextData *log, unsigned int data);
+ * int dlt_user_log_write_uint_attr(DltContextData *log, unsigned int data, const char *name, const char *unit);
* int dlt_user_log_write_uint8(DltContextData *log, uint8_t data);
+ * int dlt_user_log_write_uint8_attr(DltContextData *log, uint8_t data, const char *name, const char *unit);
* int dlt_user_log_write_uint16(DltContextData *log, uint16_t data);
+ * int dlt_user_log_write_uint16_attr(DltContextData *log, uint16_t data, const char *name, const char *unit);
* int dlt_user_log_write_uint32(DltContextData *log, uint32_t data);
+ * int dlt_user_log_write_uint32_attr(DltContextData *log, uint32_t data, const char *name, const char *unit);
* int dlt_user_log_write_uint64(DltContextData *log, uint64_t data);
+ * int dlt_user_log_write_uint64_attr(DltContextData *log, uint64_t data, const char *name, const char *unit);
* int dlt_user_log_write_uint8_formatted(DltContextData *log, uint8_t data, DltFormatType type);
* int dlt_user_log_write_uint16_formatted(DltContextData *log, uint16_t data, DltFormatType type);
* int dlt_user_log_write_uint32_formatted(DltContextData *log, uint32_t data, DltFormatType type);
* int dlt_user_log_write_uint64_formatted(DltContextData *log, uint64_t data, DltFormatType type);
* int dlt_user_log_write_int(DltContextData *log, int data);
+ * int dlt_user_log_write_int_attr(DltContextData *log, int data, const char *name, const char *unit);
* int dlt_user_log_write_int8(DltContextData *log, int8_t data);
+ * int dlt_user_log_write_int8_attr(DltContextData *log, int8_t data, const char *name, const char *unit);
* int dlt_user_log_write_int16(DltContextData *log, int16_t data);
+ * int dlt_user_log_write_int16_attr(DltContextData *log, int16_t data, const char *name, const char *unit);
* int dlt_user_log_write_int32(DltContextData *log, int32_t data);
+ * int dlt_user_log_write_int32_attr(DltContextData *log, int32_t data, const char *name, const char *unit);
* int dlt_user_log_write_int64(DltContextData *log, int64_t data);
+ * int dlt_user_log_write_int64_attr(DltContextData *log, int64_t data, const char *name, const char *unit);
* int dlt_user_log_write_string( DltContextData *log, const char *text);
+ * int dlt_user_log_write_string_attr(DltContextData *log, const char *text, const char *name);
* int dlt_user_log_write_sized_string(DltContextData *log, const char *text, uint16_t length);
+ * int dlt_user_log_write_sized_string_attr(DltContextData *log, const char *text, uint16_t length, const char *name);
* int dlt_user_log_write_constant_string( DltContextData *log, const char *text);
+ * int dlt_user_log_write_constant_string_attr(DltContextData *log, const char *text, const char *name);
* int dlt_user_log_write_sized_constant_string(DltContextData *log, const char *text, uint16_t length);
+ * int dlt_user_log_write_sized_constant_string_attr(DltContextData *log, const char *text, uint16_t length, const char *name);
* int dlt_user_log_write_utf8_string(DltContextData *log, const char *text);
+ * int dlt_user_log_write_utf8_string_attr(DltContextData *log, const char *text, const char *name);
* int dlt_user_log_write_sized_utf8_string(DltContextData *log, const char *text, uint16_t length);
+ * int dlt_user_log_write_sized_utf8_string_attr(DltContextData *log, const char *text, uint16_t length, const char *name);
* int dlt_user_log_write_raw(DltContextData *log,void *data,uint16_t length);
+ * int dlt_user_log_write_raw_attr(DltContextData *log,void *data,uint16_t length, const char *name);
* int dlt_user_log_write_raw_formatted(DltContextData *log,void *data,uint16_t length,DltFormatType type);
+ * int dlt_user_log_write_raw_formatted_attr(DltContextData *log,void *data,uint16_t length,DltFormatType type, const char *name);
*/
/*
@@ -463,6 +484,28 @@ TEST(t_dlt_user_log_write_bool, nullpointer)
}
/*/////////////////////////////////////// */
+/* t_dlt_user_log_write_bool_attr */
+TEST(t_dlt_user_log_write_bool_attr, normal)
+{
+ DltContext context;
+ DltContextData contextData;
+ uint8_t data;
+
+ EXPECT_LE(DLT_RETURN_OK, dlt_register_app("TUSR", "dlt_user.c tests"));
+ EXPECT_LE(DLT_RETURN_OK, dlt_register_context(&context, "TEST", "dlt_user.c t_dlt_user_log_write_bool_attr normal"));
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_start(&context, &contextData, DLT_LOG_DEFAULT));
+
+ data = true;
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_bool_attr(&contextData, data, "state"));
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_bool_attr(&contextData, data, ""));
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_bool_attr(&contextData, data, NULL));
+
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_finish(&contextData));
+ EXPECT_LE(DLT_RETURN_OK, dlt_unregister_context(&context));
+ EXPECT_LE(DLT_RETURN_OK, dlt_unregister_app());
+}
+
+/*/////////////////////////////////////// */
/* t_dlt_user_log_write_float32 */
TEST(t_dlt_user_log_write_float32, normal)
{
@@ -515,6 +558,32 @@ TEST(t_dlt_user_log_write_float32, nullpointer)
}
/*/////////////////////////////////////// */
+/* t_dlt_user_log_write_float32_attr */
+TEST(t_dlt_user_log_write_float32_attr, normal)
+{
+ DltContext context;
+ DltContextData contextData;
+ float32_t data;
+
+ EXPECT_LE(DLT_RETURN_OK, dlt_register_app("TUSR", "dlt_user.c tests"));
+ EXPECT_LE(DLT_RETURN_OK, dlt_register_context(&context, "TEST", "dlt_user.c t_dlt_user_log_write_float32_attr normal"));
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_start(&context, &contextData, DLT_LOG_DEFAULT));
+
+ data = 3.141592653589793238f;
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_float32_attr(&contextData, data, "name", "unit"));
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_float32_attr(&contextData, data, "", "unit"));
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_float32_attr(&contextData, data, "name", ""));
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_float32_attr(&contextData, data, "", ""));
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_float32_attr(&contextData, data, NULL, ""));
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_float32_attr(&contextData, data, "", NULL));
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_float32_attr(&contextData, data, NULL, NULL));
+
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_finish(&contextData));
+ EXPECT_LE(DLT_RETURN_OK, dlt_unregister_context(&context));
+ EXPECT_LE(DLT_RETURN_OK, dlt_unregister_app());
+}
+
+/*/////////////////////////////////////// */
/* t_dlt_user_log_write_float64 */
TEST(t_dlt_user_log_write_float64, normal)
{
@@ -567,6 +636,32 @@ TEST(t_dlt_user_log_write_float64, nullpointer)
}
/*/////////////////////////////////////// */
+/* t_dlt_user_log_write_float64_attr */
+TEST(t_dlt_user_log_write_float64_attr, normal)
+{
+ DltContext context;
+ DltContextData contextData;
+ double data;
+
+ EXPECT_LE(DLT_RETURN_OK, dlt_register_app("TUSR", "dlt_user.c tests"));
+ EXPECT_LE(DLT_RETURN_OK, dlt_register_context(&context, "TEST", "dlt_user.c t_dlt_user_log_write_float64_attr normal"));
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_start(&context, &contextData, DLT_LOG_DEFAULT));
+
+ data = 3.14159265358979323846;
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_float64_attr(&contextData, data, "name", "unit"));
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_float64_attr(&contextData, data, "", "unit"));
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_float64_attr(&contextData, data, "name", ""));
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_float64_attr(&contextData, data, "", ""));
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_float64_attr(&contextData, data, NULL, ""));
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_float64_attr(&contextData, data, "", NULL));
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_float64_attr(&contextData, data, NULL, NULL));
+
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_finish(&contextData));
+ EXPECT_LE(DLT_RETURN_OK, dlt_unregister_context(&context));
+ EXPECT_LE(DLT_RETURN_OK, dlt_unregister_app());
+}
+
+/*/////////////////////////////////////// */
/* t_dlt_user_log_write_uint */
TEST(t_dlt_user_log_write_uint, normal)
{
@@ -634,6 +729,32 @@ TEST(t_dlt_user_log_write_uint, nullpointer)
}
/*/////////////////////////////////////// */
+/* t_dlt_user_log_write_uint_attr */
+TEST(t_dlt_user_log_write_uint_attr, normal)
+{
+ DltContext context;
+ DltContextData contextData;
+ unsigned int data;
+
+ EXPECT_LE(DLT_RETURN_OK, dlt_register_app("TUSR", "dlt_user.c tests"));
+ EXPECT_LE(DLT_RETURN_OK, dlt_register_context(&context, "TEST", "dlt_user.c t_dlt_user_log_write_uint_attr normal"));
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_start(&context, &contextData, DLT_LOG_DEFAULT));
+
+ data = 42;
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_uint_attr(&contextData, data, "name", "unit"));
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_uint_attr(&contextData, data, "", "unit"));
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_uint_attr(&contextData, data, "name", ""));
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_uint_attr(&contextData, data, "", ""));
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_uint_attr(&contextData, data, NULL, ""));
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_uint_attr(&contextData, data, "", NULL));
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_uint_attr(&contextData, data, NULL, NULL));
+
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_finish(&contextData));
+ EXPECT_LE(DLT_RETURN_OK, dlt_unregister_context(&context));
+ EXPECT_LE(DLT_RETURN_OK, dlt_unregister_app());
+}
+
+/*/////////////////////////////////////// */
/* t_dlt_user_log_write_uint8 */
TEST(t_dlt_user_log_write_uint8, normal)
{
@@ -680,6 +801,31 @@ TEST(t_dlt_user_log_write_uint8, nullpointer)
}
/*/////////////////////////////////////// */
+/* t_dlt_user_log_write_uint8_attr */
+TEST(t_dlt_user_log_write_uint8_attr, normal)
+{
+ DltContext context;
+ DltContextData contextData;
+
+ EXPECT_LE(DLT_RETURN_OK, dlt_register_app("TUSR", "dlt_user.c tests"));
+ EXPECT_LE(DLT_RETURN_OK, dlt_register_context(&context, "TEST", "dlt_user.c t_dlt_user_log_write_uint8_attr normal"));
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_start(&context, &contextData, DLT_LOG_DEFAULT));
+
+ uint8_t data = 0xaa;
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_uint8_attr(&contextData, data, "name", "unit"));
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_uint8_attr(&contextData, data, "", "unit"));
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_uint8_attr(&contextData, data, "name", ""));
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_uint8_attr(&contextData, data, "", ""));
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_uint8_attr(&contextData, data, NULL, ""));
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_uint8_attr(&contextData, data, "", NULL));
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_uint8_attr(&contextData, data, NULL, NULL));
+
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_finish(&contextData));
+ EXPECT_LE(DLT_RETURN_OK, dlt_unregister_context(&context));
+ EXPECT_LE(DLT_RETURN_OK, dlt_unregister_app());
+}
+
+/*/////////////////////////////////////// */
/* t_dlt_user_log_write_uint16 */
TEST(t_dlt_user_log_write_uint16, normal)
{
@@ -726,6 +872,31 @@ TEST(t_dlt_user_log_write_uint16, nullpointer)
}
/*/////////////////////////////////////// */
+/* t_dlt_user_log_write_uint16_attr */
+TEST(t_dlt_user_log_write_uint16_attr, normal)
+{
+ DltContext context;
+ DltContextData contextData;
+
+ EXPECT_LE(DLT_RETURN_OK, dlt_register_app("TUSR", "dlt_user.c tests"));
+ EXPECT_LE(DLT_RETURN_OK, dlt_register_context(&context, "TEST", "dlt_user.c t_dlt_user_log_write_uint16_attr normal"));
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_start(&context, &contextData, DLT_LOG_DEFAULT));
+
+ uint16_t data = 0xaa55;
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_uint16_attr(&contextData, data, "name", "unit"));
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_uint16_attr(&contextData, data, "", "unit"));
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_uint16_attr(&contextData, data, "name", ""));
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_uint16_attr(&contextData, data, "", ""));
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_uint16_attr(&contextData, data, NULL, ""));
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_uint16_attr(&contextData, data, "", NULL));
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_uint16_attr(&contextData, data, NULL, NULL));
+
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_finish(&contextData));
+ EXPECT_LE(DLT_RETURN_OK, dlt_unregister_context(&context));
+ EXPECT_LE(DLT_RETURN_OK, dlt_unregister_app());
+}
+
+/*/////////////////////////////////////// */
/* t_dlt_user_log_write_uint32 */
TEST(t_dlt_user_log_write_uint32, normal)
{
@@ -772,6 +943,31 @@ TEST(t_dlt_user_log_write_uint32, nullpointer)
}
/*/////////////////////////////////////// */
+/* t_dlt_user_log_write_uint32_attr */
+TEST(t_dlt_user_log_write_uint32_attr, normal)
+{
+ DltContext context;
+ DltContextData contextData;
+
+ EXPECT_LE(DLT_RETURN_OK, dlt_register_app("TUSR", "dlt_user.c tests"));
+ EXPECT_LE(DLT_RETURN_OK, dlt_register_context(&context, "TEST", "dlt_user.c t_dlt_user_log_write_uint32_attr normal"));
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_start(&context, &contextData, DLT_LOG_DEFAULT));
+
+ uint32_t data = 0xaabbccdd;
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_uint32_attr(&contextData, data, "name", "unit"));
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_uint32_attr(&contextData, data, "", "unit"));
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_uint32_attr(&contextData, data, "name", ""));
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_uint32_attr(&contextData, data, "", ""));
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_uint32_attr(&contextData, data, NULL, ""));
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_uint32_attr(&contextData, data, "", NULL));
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_uint32_attr(&contextData, data, NULL, NULL));
+
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_finish(&contextData));
+ EXPECT_LE(DLT_RETURN_OK, dlt_unregister_context(&context));
+ EXPECT_LE(DLT_RETURN_OK, dlt_unregister_app());
+}
+
+/*/////////////////////////////////////// */
/* t_dlt_user_log_write_uint64 */
TEST(t_dlt_user_log_write_uint64, normal)
{
@@ -818,6 +1014,31 @@ TEST(t_dlt_user_log_write_uint64, nullpointer)
}
/*/////////////////////////////////////// */
+/* t_dlt_user_log_write_uint64_attr */
+TEST(t_dlt_user_log_write_uint64_attr, normal)
+{
+ DltContext context;
+ DltContextData contextData;
+
+ EXPECT_LE(DLT_RETURN_OK, dlt_register_app("TUSR", "dlt_user.c tests"));
+ EXPECT_LE(DLT_RETURN_OK, dlt_register_context(&context, "TEST", "dlt_user.c t_dlt_user_log_write_uint64_attr normal"));
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_start(&context, &contextData, DLT_LOG_DEFAULT));
+
+ uint64_t data = 0x11223344aabbccddULL;
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_uint64_attr(&contextData, data, "name", "unit"));
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_uint64_attr(&contextData, data, "", "unit"));
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_uint64_attr(&contextData, data, "name", ""));
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_uint64_attr(&contextData, data, "", ""));
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_uint64_attr(&contextData, data, NULL, ""));
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_uint64_attr(&contextData, data, "", NULL));
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_uint64_attr(&contextData, data, NULL, NULL));
+
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_finish(&contextData));
+ EXPECT_LE(DLT_RETURN_OK, dlt_unregister_context(&context));
+ EXPECT_LE(DLT_RETURN_OK, dlt_unregister_app());
+}
+
+/*/////////////////////////////////////// */
/* t_dlt_user_log_write_uint8_formatted */
TEST(t_dlt_user_log_write_uint8_formatted, normal)
{
@@ -1251,6 +1472,31 @@ TEST(t_dlt_user_log_write_int, nullpointer)
}
/*/////////////////////////////////////// */
+/* t_dlt_user_log_write_int_attr */
+TEST(t_dlt_user_log_write_int_attr, normal)
+{
+ DltContext context;
+ DltContextData contextData;
+
+ EXPECT_LE(DLT_RETURN_OK, dlt_register_app("TUSR", "dlt_user.c tests"));
+ EXPECT_LE(DLT_RETURN_OK, dlt_register_context(&context, "TEST", "dlt_user.c t_dlt_user_log_write_int_attr normal"));
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_start(&context, &contextData, DLT_LOG_DEFAULT));
+
+ int data = -42;
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_int_attr(&contextData, data, "name", "unit"));
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_int_attr(&contextData, data, "", "unit"));
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_int_attr(&contextData, data, "name", ""));
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_int_attr(&contextData, data, "", ""));
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_int_attr(&contextData, data, NULL, ""));
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_int_attr(&contextData, data, "", NULL));
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_int_attr(&contextData, data, NULL, NULL));
+
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_finish(&contextData));
+ EXPECT_LE(DLT_RETURN_OK, dlt_unregister_context(&context));
+ EXPECT_LE(DLT_RETURN_OK, dlt_unregister_app());
+}
+
+/*/////////////////////////////////////// */
/* t_dlt_user_log_write_int8 */
TEST(t_dlt_user_log_write_int8, normal)
{
@@ -1301,6 +1547,31 @@ TEST(t_dlt_user_log_write_int8, nullpointer)
}
/*/////////////////////////////////////// */
+/* t_dlt_user_log_write_int8_attr */
+TEST(t_dlt_user_log_write_int8_attr, normal)
+{
+ DltContext context;
+ DltContextData contextData;
+
+ EXPECT_LE(DLT_RETURN_OK, dlt_register_app("TUSR", "dlt_user.c tests"));
+ EXPECT_LE(DLT_RETURN_OK, dlt_register_context(&context, "TEST", "dlt_user.c t_dlt_user_log_write_int8_attr normal"));
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_start(&context, &contextData, DLT_LOG_DEFAULT));
+
+ int8_t data = 0xaa;
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_int8_attr(&contextData, data, "name", "unit"));
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_int8_attr(&contextData, data, "", "unit"));
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_int8_attr(&contextData, data, "name", ""));
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_int8_attr(&contextData, data, "", ""));
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_int8_attr(&contextData, data, NULL, ""));
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_int8_attr(&contextData, data, "", NULL));
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_int8_attr(&contextData, data, NULL, NULL));
+
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_finish(&contextData));
+ EXPECT_LE(DLT_RETURN_OK, dlt_unregister_context(&context));
+ EXPECT_LE(DLT_RETURN_OK, dlt_unregister_app());
+}
+
+/*/////////////////////////////////////// */
/* t_dlt_user_log_write_int16 */
TEST(t_dlt_user_log_write_int16, normal)
{
@@ -1351,6 +1622,31 @@ TEST(t_dlt_user_log_write_int16, nullpointer)
}
/*/////////////////////////////////////// */
+/* t_dlt_user_log_write_int16_attr */
+TEST(t_dlt_user_log_write_int16_attr, normal)
+{
+ DltContext context;
+ DltContextData contextData;
+
+ EXPECT_LE(DLT_RETURN_OK, dlt_register_app("TUSR", "dlt_user.c tests"));
+ EXPECT_LE(DLT_RETURN_OK, dlt_register_context(&context, "TEST", "dlt_user.c t_dlt_user_log_write_int16_attr normal"));
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_start(&context, &contextData, DLT_LOG_DEFAULT));
+
+ int16_t data = 0xaa55;
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_int16_attr(&contextData, data, "name", "unit"));
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_int16_attr(&contextData, data, "", "unit"));
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_int16_attr(&contextData, data, "name", ""));
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_int16_attr(&contextData, data, "", ""));
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_int16_attr(&contextData, data, NULL, ""));
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_int16_attr(&contextData, data, "", NULL));
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_int16_attr(&contextData, data, NULL, NULL));
+
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_finish(&contextData));
+ EXPECT_LE(DLT_RETURN_OK, dlt_unregister_context(&context));
+ EXPECT_LE(DLT_RETURN_OK, dlt_unregister_app());
+}
+
+/*/////////////////////////////////////// */
/* t_dlt_user_log_write_int32 */
TEST(t_dlt_user_log_write_int32, normal)
{
@@ -1401,6 +1697,31 @@ TEST(t_dlt_user_log_write_int32, nullpointer)
}
/*/////////////////////////////////////// */
+/* t_dlt_user_log_write_int32_attr */
+TEST(t_dlt_user_log_write_int32_attr, normal)
+{
+ DltContext context;
+ DltContextData contextData;
+
+ EXPECT_LE(DLT_RETURN_OK, dlt_register_app("TUSR", "dlt_user.c tests"));
+ EXPECT_LE(DLT_RETURN_OK, dlt_register_context(&context, "TEST", "dlt_user.c t_dlt_user_log_write_int32_attr normal"));
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_start(&context, &contextData, DLT_LOG_DEFAULT));
+
+ int32_t data = 0xffeeddcc;
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_int32_attr(&contextData, data, "name", "unit"));
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_int32_attr(&contextData, data, "", "unit"));
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_int32_attr(&contextData, data, "name", ""));
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_int32_attr(&contextData, data, "", ""));
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_int32_attr(&contextData, data, NULL, ""));
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_int32_attr(&contextData, data, "", NULL));
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_int32_attr(&contextData, data, NULL, NULL));
+
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_finish(&contextData));
+ EXPECT_LE(DLT_RETURN_OK, dlt_unregister_context(&context));
+ EXPECT_LE(DLT_RETURN_OK, dlt_unregister_app());
+}
+
+/*/////////////////////////////////////// */
/* t_dlt_user_log_write_int64 */
TEST(t_dlt_user_log_write_int64, normal)
{
@@ -1451,6 +1772,31 @@ TEST(t_dlt_user_log_write_int64, nullpointer)
}
/*/////////////////////////////////////// */
+/* t_dlt_user_log_write_int64_attr */
+TEST(t_dlt_user_log_write_int64_attr, normal)
+{
+ DltContext context;
+ DltContextData contextData;
+
+ EXPECT_LE(DLT_RETURN_OK, dlt_register_app("TUSR", "dlt_user.c tests"));
+ EXPECT_LE(DLT_RETURN_OK, dlt_register_context(&context, "TEST", "dlt_user.c t_dlt_user_log_write_int64_attr normal"));
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_start(&context, &contextData, DLT_LOG_DEFAULT));
+
+ int64_t data = 0xffeeddcc44332211LL;
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_int64_attr(&contextData, data, "name", "unit"));
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_int64_attr(&contextData, data, "", "unit"));
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_int64_attr(&contextData, data, "name", ""));
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_int64_attr(&contextData, data, "", ""));
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_int64_attr(&contextData, data, NULL, ""));
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_int64_attr(&contextData, data, "", NULL));
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_int64_attr(&contextData, data, NULL, NULL));
+
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_finish(&contextData));
+ EXPECT_LE(DLT_RETURN_OK, dlt_unregister_context(&context));
+ EXPECT_LE(DLT_RETURN_OK, dlt_unregister_app());
+}
+
+/*/////////////////////////////////////// */
/* t_dlt_user_log_write_string */
TEST(t_dlt_user_log_write_string, normal)
{
@@ -2992,6 +3338,132 @@ TEST(t_dlt_user_log_write_sized_utf8_string, nullpointer)
}
/*/////////////////////////////////////// */
+/* t_dlt_user_log_write_string_attr */
+TEST(t_dlt_user_log_write_string_attr, normal)
+{
+ DltContext context;
+ DltContextData contextData;
+
+ EXPECT_LE(DLT_RETURN_OK, dlt_register_app("TUSR", "dlt_user.c tests"));
+ EXPECT_LE(DLT_RETURN_OK, dlt_register_context(&context, "TEST", "dlt_user.c t_dlt_user_log_write_string_attr normal"));
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_start(&context, &contextData, DLT_LOG_DEFAULT));
+
+ char data[] = "123456";
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_string_attr(&contextData, data, "name"));
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_string_attr(&contextData, data, ""));
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_string_attr(&contextData, data, NULL));
+
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_finish(&contextData));
+ EXPECT_LE(DLT_RETURN_OK, dlt_unregister_context(&context));
+ EXPECT_LE(DLT_RETURN_OK, dlt_unregister_app());
+}
+
+/*/////////////////////////////////////// */
+/* t_dlt_user_log_write_sized_string_attr */
+TEST(t_dlt_user_log_write_sized_string_attr, normal)
+{
+ DltContext context;
+ DltContextData contextData;
+
+ EXPECT_LE(DLT_RETURN_OK, dlt_register_app("TUSR", "dlt_user.c tests"));
+ EXPECT_LE(DLT_RETURN_OK, dlt_register_context(&context, "TEST", "dlt_user.c t_dlt_user_log_write_sized_string_attr normal"));
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_start(&context, &contextData, DLT_LOG_DEFAULT));
+
+ char data[] = "123456789";
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_sized_string_attr(&contextData, data, 6, "name"));
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_sized_string_attr(&contextData, data, 6, ""));
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_sized_string_attr(&contextData, data, 6, NULL));
+
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_finish(&contextData));
+ EXPECT_LE(DLT_RETURN_OK, dlt_unregister_context(&context));
+ EXPECT_LE(DLT_RETURN_OK, dlt_unregister_app());
+}
+
+/*/////////////////////////////////////// */
+/* t_dlt_user_log_write_constant_string_attr */
+TEST(t_dlt_user_log_write_constant_string_attr, normal)
+{
+ DltContext context;
+ DltContextData contextData;
+
+ EXPECT_LE(DLT_RETURN_OK, dlt_register_app("TUSR", "dlt_user.c tests"));
+ EXPECT_LE(DLT_RETURN_OK, dlt_register_context(&context, "TEST", "dlt_user.c t_dlt_user_log_write_constant_string_attr normal"));
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_start(&context, &contextData, DLT_LOG_DEFAULT));
+
+ char data[] = "123456";
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_constant_string_attr(&contextData, data, "name"));
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_constant_string_attr(&contextData, data, ""));
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_constant_string_attr(&contextData, data, NULL));
+
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_finish(&contextData));
+ EXPECT_LE(DLT_RETURN_OK, dlt_unregister_context(&context));
+ EXPECT_LE(DLT_RETURN_OK, dlt_unregister_app());
+}
+
+/*/////////////////////////////////////// */
+/* t_dlt_user_log_write_sized_constant_string_attr */
+TEST(t_dlt_user_log_write_sized_constant_string_attr, normal)
+{
+ DltContext context;
+ DltContextData contextData;
+
+ EXPECT_LE(DLT_RETURN_OK, dlt_register_app("TUSR", "dlt_user.c tests"));
+ EXPECT_LE(DLT_RETURN_OK, dlt_register_context(&context, "TEST", "dlt_user.c t_dlt_user_log_write_sized_constant_string_attr normal"));
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_start(&context, &contextData, DLT_LOG_DEFAULT));
+
+ char data[] = "123456789";
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_sized_constant_string_attr(&contextData, data, 6, "name"));
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_sized_constant_string_attr(&contextData, data, 6, ""));
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_sized_constant_string_attr(&contextData, data, 6, NULL));
+
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_finish(&contextData));
+ EXPECT_LE(DLT_RETURN_OK, dlt_unregister_context(&context));
+ EXPECT_LE(DLT_RETURN_OK, dlt_unregister_app());
+}
+
+/*/////////////////////////////////////// */
+/* t_dlt_user_log_write_utf8_string_attr */
+TEST(t_dlt_user_log_write_utf8_string_attr, normal)
+{
+ DltContext context;
+ DltContextData contextData;
+
+ EXPECT_LE(DLT_RETURN_OK, dlt_register_app("TUSR", "dlt_user.c tests"));
+ EXPECT_LE(DLT_RETURN_OK, dlt_register_context(&context, "TEST", "dlt_user.c t_dlt_user_log_write_utf8_string_attr normal"));
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_start(&context, &contextData, DLT_LOG_DEFAULT));
+
+ char data[] = "123456";
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_utf8_string_attr(&contextData, data, "name"));
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_utf8_string_attr(&contextData, data, ""));
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_utf8_string_attr(&contextData, data, NULL));
+
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_finish(&contextData));
+ EXPECT_LE(DLT_RETURN_OK, dlt_unregister_context(&context));
+ EXPECT_LE(DLT_RETURN_OK, dlt_unregister_app());
+}
+
+/*/////////////////////////////////////// */
+/* t_dlt_user_log_write_sized_utf8_string_attr */
+TEST(t_dlt_user_log_write_sized_utf8_string_attr, normal)
+{
+ DltContext context;
+ DltContextData contextData;
+
+ EXPECT_LE(DLT_RETURN_OK, dlt_register_app("TUSR", "dlt_user.c tests"));
+ EXPECT_LE(DLT_RETURN_OK, dlt_register_context(&context, "TEST", "dlt_user.c t_dlt_user_log_write_sized_utf8_string_attr normal"));
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_start(&context, &contextData, DLT_LOG_DEFAULT));
+
+ char data[] = "123456789";
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_sized_utf8_string_attr(&contextData, data, 6, "name"));
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_sized_utf8_string_attr(&contextData, data, 6, ""));
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_sized_utf8_string_attr(&contextData, data, 6, NULL));
+
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_finish(&contextData));
+ EXPECT_LE(DLT_RETURN_OK, dlt_unregister_context(&context));
+ EXPECT_LE(DLT_RETURN_OK, dlt_unregister_app());
+}
+
+/*/////////////////////////////////////// */
/* t_dlt_user_log_write_raw */
TEST(t_dlt_user_log_write_raw, normal)
{
@@ -3039,6 +3511,27 @@ TEST(t_dlt_user_log_write_raw, nullpointer)
}
/*/////////////////////////////////////// */
+/* t_dlt_user_log_write_raw_attr */
+TEST(t_dlt_user_log_write_raw_attr, normal)
+{
+ DltContext context;
+ DltContextData contextData;
+
+ EXPECT_LE(DLT_RETURN_OK, dlt_register_app("TUSR", "dlt_user.c tests"));
+ EXPECT_LE(DLT_RETURN_OK, dlt_register_context(&context, "TEST", "dlt_user.c t_dlt_user_log_write_raw_attr normal"));
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_start(&context, &contextData, DLT_LOG_DEFAULT));
+
+ char data[] = "123456";
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_raw_attr(&contextData, data, 6, "name"));
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_raw_attr(&contextData, data, 6, ""));
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_raw_attr(&contextData, data, 6, NULL));
+
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_finish(&contextData));
+ EXPECT_LE(DLT_RETURN_OK, dlt_unregister_context(&context));
+ EXPECT_LE(DLT_RETURN_OK, dlt_unregister_app());
+}
+
+/*/////////////////////////////////////// */
/* t_dlt_user_log_write_raw_formatted */
TEST(t_dlt_user_log_write_raw_formatted, normal)
{
@@ -3131,6 +3624,28 @@ TEST(t_dlt_user_log_write_raw_formatted, nullpointer)
EXPECT_LE(DLT_RETURN_OK, dlt_unregister_app());
}
+/*/////////////////////////////////////// */
+/* t_dlt_user_log_write_raw_formatted_attr */
+TEST(t_dlt_user_log_write_raw_formatted_attr, normal)
+{
+ DltContext context;
+ DltContextData contextData;
+
+ EXPECT_LE(DLT_RETURN_OK, dlt_register_app("TUSR", "dlt_user.c tests"));
+ EXPECT_LE(DLT_RETURN_OK, dlt_register_context(&context, "TEST", "dlt_user.c t_dlt_user_log_write_raw_formatted_attr normal"));
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_start(&context, &contextData, DLT_LOG_DEFAULT));
+
+ char data[] = "123456";
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_raw_formatted_attr(&contextData, data, 6, DLT_FORMAT_DEFAULT, "name"));
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_raw_formatted_attr(&contextData, data, 6, DLT_FORMAT_DEFAULT, ""));
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_raw_formatted_attr(&contextData, data, 6, DLT_FORMAT_DEFAULT, NULL));
+
+ EXPECT_LE(DLT_RETURN_OK, dlt_user_log_write_finish(&contextData));
+ EXPECT_LE(DLT_RETURN_OK, dlt_unregister_context(&context));
+ EXPECT_LE(DLT_RETURN_OK, dlt_unregister_app());
+}
+
+/*/////////////////////////////////////// */
/*
* int dlt_log_string(DltContext *handle,DltLogLevelType loglevel, const char *text);
* int dlt_log_string_int(DltContext *handle,DltLogLevelType loglevel, const char *text, int data);