(272) Added the wide string entry message functions

include/stumpless/entry.h

@@ -1340,6 +1340,39 @@ struct stumpless_entry *
 stumpless_set_entry_message_str( struct stumpless_entry *entry,
                                  const char *message );
 
+/**
+ * Sets the message of a given entry.
+ *
+ * **Thread Safety: MT-Safe**
+ * This function is thread safe. A mutex is used to coordinate changes to the
+ * entry while it is being modified.
+ *
+ * **Async Signal Safety: AS-Unsafe lock heap**
+ * This function is not safe to call from signal handlers due to the use of a
+ * non-reentrant lock to coordinate changes and the use of memory management
+ * functions to create the new message and free the old one.
+ *
+ * **Async Cancel Safety: AC-Unsafe lock heap**
+ * This function is not safe to call from threads that may be asynchronously
+ * cancelled, due to the use of a lock that could be left locked as well as
+ * memory management functions.
+ *
+ * @since release v2.1.0
+ *
+ * @param entry The entry to modify.
+ *
+ * @param message The new message to set on the entry. If this is NULL, then it
+ * will be blank in the entry (no characters). This must be a valid UTF-16 string
+ * in shortest form.
+ *
+ * @return The modified entry if no error is encountered. If an error is
+ * encountered, then NULL is returned and an error code is set appropriately.
+ */
+STUMPLESS_PUBLIC_FUNCTION
+struct stumpless_entry *
+stumpless_set_entry_message_str_w( struct stumpless_entry *entry,
+                                   const wchar_t *message );
+
 /**
  * Puts the param in the element at the given index of an entry.
  *

src/entry.c

@@ -29,6 +29,7 @@
 #include "private/config.h"
 #include "private/config/locale/wrapper.h"
 #include "private/config/wrapper/format_string.h"
+#include "private/config/wrapper/wstring.h"
 #include "private/config/wrapper/gethostname.h"
 #include "private/config/wrapper/getpid.h"
 #include "private/config/wrapper/thread_safety.h"
@@ -868,6 +869,38 @@
   return entry;
 }
 
+
+struct stumpless_entry *
+stumpless_set_entry_message_str_w( struct stumpless_entry *entry,
+                                   const wchar_t *message ) {
+  char *new_message;
+  size_t new_message_length;
+  const char *old_message;
+
+  VALIDATE_ARG_NOT_NULL( entry );
+
+  if( message ) {
+    new_message = config_copy_wstring_to_cstring( message, &new_message_length );
+    if( !new_message ) {
+      return NULL;
+    }
+  } else {
+    new_message = NULL;
+    new_message_length = 0;
+  }
+
+  lock_entry( entry );
+  old_message = entry->message;
+  entry->message = new_message;
+  entry->message_length = new_message_length;
+  unlock_entry( entry );
+
+  free_mem( old_message );
+  clear_error(  );
+
+  return entry;
+}
+
 struct stumpless_entry *
 stumpless_set_entry_param_by_index( struct stumpless_entry *entry,
                                     size_t element_index,

test/function/entry.cpp

@@ -2395,6 +2395,164 @@ namespace {
     stumpless_free_all(  );
   }
 
+
+
+
+
+
+
+
+  // TEST( SetMessageWideStrTest, AsciiMessage ) {
+  //   struct stumpless_entry *entry;
+  //   const char *ascii_message;
+  //   const struct stumpless_entry *result;
+  //   const char *new_message;
+
+  //   entry = create_empty_entry(  );
+  //   ASSERT_NOT_NULL( entry );
+
+  //   ascii_message = load_corpus( "cstring/ascii" );
+  //   ASSERT_NOT_NULL( ascii_message );
+
+  //   result = stumpless_set_entry_message_str_w( entry, ascii_message );
+  //   EXPECT_EQ( entry, result );
+  //   EXPECT_NO_ERROR;
+
+  //   new_message = stumpless_get_entry_message( entry );
+  //   EXPECT_NOT_NULL( new_message );
+  //   EXPECT_NO_ERROR;
+  //   EXPECT_STREQ( ascii_message, new_message );
+
+  //   delete[] ascii_message;
+  //   free( ( void * ) new_message );
+  //   stumpless_destroy_entry_and_contents( entry );
+  //   stumpless_free_all(  );
+  // }
+
+  // TEST( SetMessageWideStrTest, LongAsciiMessage ) {
+  //   struct stumpless_entry *entry;
+  //   const char *long_message;
+  //   const struct stumpless_entry *result;
+  //   const char *new_message;
+
+  //   entry = create_empty_entry(  );
+  //   ASSERT_NOT_NULL( entry );
+
+  //   long_message = load_corpus( "cstring/lorem" );
+  //   ASSERT_NOT_NULL( long_message );
+
+  //   result = stumpless_set_entry_message_str_w( entry, long_message );
+  //   EXPECT_EQ( entry, result );
+  //   EXPECT_NO_ERROR;
+
+  //   new_message = stumpless_get_entry_message( entry );
+  //   EXPECT_NOT_NULL( new_message );
+  //   EXPECT_NO_ERROR;
+  //   EXPECT_STREQ( long_message, new_message );
+
+  //   delete[] long_message;
+  //   free( ( void * ) new_message );
+  //   stumpless_destroy_entry_and_contents( entry );
+  //   stumpless_free_all(  );
+  // }
+
+  TEST( SetMessageWideStrTest, MallocFailureOnMessage ) {
+    void * (*set_malloc_result)(size_t);
+    struct stumpless_entry *entry;
+    const wchar_t *new_message = L"nice and long to make sure it beats the first";
+    const struct stumpless_entry *result;
+    const struct stumpless_error *error;
+
+    entry = create_empty_entry(  );
+    ASSERT_NOT_NULL( entry );
+
+    set_malloc_result = stumpless_set_malloc( MALLOC_FAIL_ON_SIZE( 46 ) );
+    ASSERT_NOT_NULL( set_malloc_result );
+
+    result = stumpless_set_entry_message_str_w( entry, new_message );
+    EXPECT_ERROR_ID_EQ( STUMPLESS_MEMORY_ALLOCATION_FAILURE );
+    EXPECT_NULL( result );
+
+    set_malloc_result = stumpless_set_malloc( malloc );
+    EXPECT_TRUE( set_malloc_result == malloc );
+
+    stumpless_destroy_entry_and_contents( entry );
+    stumpless_free_all(  );
+  }
+
+  TEST( SetMessageWideStrTest, NullEntry ) {
+    const struct stumpless_entry *result;
+    const struct stumpless_error *error;
+
+    result = stumpless_set_entry_message_str_w( NULL, L"test-message" );
+    EXPECT_ERROR_ID_EQ( STUMPLESS_ARGUMENT_EMPTY );
+    EXPECT_NULL( result );
+
+    stumpless_free_all(  );
+  }
+
+  TEST( SetMessageWideStrTest, NullMessage ) {
+    struct stumpless_entry *entry;
+    const struct stumpless_entry *result;
+
+    entry = create_empty_entry(  );
+    EXPECT_NO_ERROR;
+    EXPECT_NOT_NULL( entry );
+
+    result = stumpless_set_entry_message_str_w( entry, NULL );
+    EXPECT_NO_ERROR;
+    EXPECT_EQ( entry, result );
+
+    EXPECT_NULL( entry->message );
+    EXPECT_EQ( 0, entry->message_length );
+
+    stumpless_destroy_entry_and_contents( entry );
+
+    stumpless_free_all(  );
+  }
+
+  // TEST( SetMessageWideStrTest, Utf16Message ) {
+  //   struct stumpless_entry *entry;
+  //   const char *utf16_message;
+  //   const struct stumpless_entry *result;
+  //   const char *new_message;
+
+  //   entry = create_empty_entry(  );
+  //   ASSERT_NOT_NULL( entry );
+
+  //   utf16_message = load_corpus( "cstring/zh-cn" );
+  //   ASSERT_NOT_NULL( utf16_message );
+
+  //   result = stumpless_set_entry_message_str_w( entry, utf16_message );
+  //   EXPECT_EQ( entry, result );
+  //   EXPECT_NO_ERROR;
+
+  //   new_message = stumpless_get_entry_message( entry );
+  //   EXPECT_NOT_NULL( new_message );
+  //   EXPECT_NO_ERROR;
+  //   EXPECT_STREQ( utf16_message, new_message );
+
+  //   delete[] utf16_message;
+  //   free( ( void * ) new_message );
+  //   stumpless_destroy_entry_and_contents( entry );
+  //   stumpless_free_all(  );
+  // }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
   TEST( SetParam, NullEntry ) {
     struct stumpless_param *param;
     const struct stumpless_entry *result;

tools/check_headers/stumpless.yml

@@ -628,3 +628,4 @@
 "stumpless_get_target_type_string" : "stumpless/target.h"
 "STUMPLESS_FOREACH_TARGET_TYPE" : "stumpless/target.h"
 "STUMPLESS_FOREACH_SEVERITY" : "stumpless/severity.h"
+"stumpless_set_entry_message_str_w" : "stumpless/entry.h"