Kill mutt_buffer_from

diff --git a/icommands.c b/icommands.c
index 6c18184195903c9b82a0f92ee3a61a66432f16b2..acaacb2beb944e57a76e00699a58d6e397ebb118 100644 (file)
--- a/icommands.c
+++ b/icommands.c
@@ -79,21 +79,22 @@ enum CommandResult mutt_parse_icommand(/* const */ char *line, struct Buffer *er
   enum CommandResult rc = MUTT_CMD_ERROR;
 
   struct Buffer *token = mutt_buffer_pool_get();
-  struct Buffer *expn = mutt_buffer_from(line);
-  expn->dptr = expn->data;
+  struct Buffer expn = { 0 };
+  mutt_buffer_addstr(&expn, line);
+  expn.dptr = expn.data;
 
   mutt_buffer_reset(err);
 
-  SKIPWS(expn->dptr);
-  while (*expn->dptr != '\0')
+  SKIPWS(expn.dptr);
+  while (*expn.dptr != '\0')
   {
-    mutt_extract_token(token, expn, MUTT_TOKEN_NO_FLAGS);
+    mutt_extract_token(token, &expn, MUTT_TOKEN_NO_FLAGS);
     for (size_t i = 0; ICommandList[i].name; i++)
     {
       if (mutt_str_strcmp(token->data, ICommandList[i].name) != 0)
         continue;
 
-      rc = ICommandList[i].func(token, expn, ICommandList[i].data, err);
+      rc = ICommandList[i].func(token, &expn, ICommandList[i].data, err);
       if (rc != 0)
         goto finish;
 
@@ -103,7 +104,7 @@ enum CommandResult mutt_parse_icommand(/* const */ char *line, struct Buffer *er
 
 finish:
   mutt_buffer_pool_release(&token);
-  mutt_buffer_free(&expn);
+  mutt_buffer_dealloc(&expn);
   return rc;
 }
 

diff --git a/index.c b/index.c
index 001f3e764c4d6cacfd0ca0ad7279ed9948f9a8a5..29fc293b89da8507dfb2a303805bdf4924c39bd6 100644 (file)
--- a/index.c
+++ b/index.c
@@ -2214,7 +2214,8 @@ int mutt_index_menu(void)
       {
         bool cont = false; /* Set if we want to continue instead of break */
 
-        struct Buffer *folderbuf = mutt_buffer_alloc(mutt_buffer_pool_get(), PATH_MAX);
+        struct Buffer *folderbuf = mutt_buffer_pool_get();
+        mutt_buffer_alloc(folderbuf, PATH_MAX);
         struct Mailbox *m = NULL;
         char *cp = NULL;
 #ifdef USE_NNTP

diff --git a/init.c b/init.c
index 12cd89064fdf0b916a3ae4f824c34e4ade04dab4..d00bc6992cfbef401ebdf5b0e65ffad928b25850 100644 (file)
--- a/init.c
+++ b/init.c
@@ -3221,27 +3221,28 @@ enum CommandResult mutt_parse_rc_line(/* const */ char *line,
   int i;
   enum CommandResult rc = MUTT_CMD_SUCCESS;
 
-  struct Buffer *expn = mutt_buffer_from(line);
-  expn->dptr = expn->data;
+  struct Buffer expn = { 0 };
+  mutt_buffer_addstr(&expn, line);
+  expn.dptr = expn.data;
 
   *err->data = 0;
 
-  SKIPWS(expn->dptr);
-  while (*expn->dptr != '\0')
+  SKIPWS(expn.dptr);
+  while (*expn.dptr != '\0')
   {
-    if (*expn->dptr == '#')
+    if (*expn.dptr == '#')
       break; /* rest of line is a comment */
-    if (*expn->dptr == ';')
+    if (*expn.dptr == ';')
     {
-      expn->dptr++;
+      expn.dptr++;
       continue;
     }
-    mutt_extract_token(token, expn, MUTT_TOKEN_NO_FLAGS);
+    mutt_extract_token(token, &expn, MUTT_TOKEN_NO_FLAGS);
     for (i = 0; Commands[i].name; i++)
     {
       if (mutt_str_strcmp(token->data, Commands[i].name) == 0)
       {
-        rc = Commands[i].func(token, expn, Commands[i].data, err);
+        rc = Commands[i].func(token, &expn, Commands[i].data, err);
         if (rc != MUTT_CMD_SUCCESS)
         {              /* -1 Error, +1 Finish */
           goto finish; /* Propagate return code */
@@ -3257,7 +3258,7 @@ enum CommandResult mutt_parse_rc_line(/* const */ char *line,
     }
   }
 finish:
-  mutt_buffer_free(&expn);
+  mutt_buffer_dealloc(&expn);
   return rc;
 }
 

diff --git a/mutt/buffer.c b/mutt/buffer.c
index c35a8df63b0d36cf3193c40aca34fdbd596c138d..43c5ae131bb325b49ef20a35331b696e5d11d8b2 100644 (file)
--- a/mutt/buffer.c
+++ b/mutt/buffer.c
@@ -81,26 +81,6 @@ void mutt_buffer_reset(struct Buffer *buf)
   buf->dptr = buf->data;
 }
 
-/**
- * mutt_buffer_from - Create Buffer from an existing string
- * @param seed String to put in the Buffer
- * @retval ptr  New Buffer
- * @retval NULL Error
- *
- * @note The write pointer is positioned at the end of the string
- */
-struct Buffer *mutt_buffer_from(const char *seed)
-{
-  if (!seed)
-    return NULL;
-
-  struct Buffer *b = mutt_buffer_new();
-  b->data = mutt_str_strdup(seed);
-  b->dsize = mutt_str_strlen(seed);
-  b->dptr = b->data + b->dsize;
-  return b;
-}
-
 /**
  * mutt_buffer_addstr_n - Add a string to a Buffer, expanding it if necessary
  * @param buf Buffer to add to
@@ -292,29 +272,29 @@ bool mutt_buffer_is_empty(const struct Buffer *buf)
  * mutt_buffer_alloc - Make sure a buffer can store at least new_size bytes
  * @param buf      Buffer to change
  * @param new_size New size
- * @retval buf The buf argument, useful in
- *     struct Buffer *buf = mutt_buffer_alloc(mutt_buffer_new(), 1024);
  */
-struct Buffer *mutt_buffer_alloc(struct Buffer *buf, size_t new_size)
+void mutt_buffer_alloc(struct Buffer *buf, size_t new_size)
 {
-  if (buf)
+  if (!buf)
   {
-    if (!buf->dptr)
-      buf->dptr = buf->data;
-
-    if (new_size > buf->dsize)
-    {
-      size_t offset = (buf->dptr && buf->data) ? buf->dptr - buf->data : 0;
-
-      buf->dsize = new_size;
-      mutt_mem_realloc(&buf->data, buf->dsize);
-      buf->dptr = buf->data + offset;
-      /* This ensures an initially NULL buf->data is now properly terminated. */
-      *buf->dptr = '\0';
-    }
+    return;
   }
 
-  return buf;
+  if (!buf->dptr)
+  {
+    buf->dptr = buf->data;
+  }
+
+  if (new_size > buf->dsize)
+  {
+    size_t offset = (buf->dptr && buf->data) ? buf->dptr - buf->data : 0;
+
+    buf->dsize = new_size;
+    mutt_mem_realloc(&buf->data, buf->dsize);
+    buf->dptr = buf->data + offset;
+    /* This ensures an initially NULL buf->data is now properly terminated. */
+    *buf->dptr = '\0';
+  }
 }
 
 /**

diff --git a/mutt/buffer.h b/mutt/buffer.h
index dcecbbe6043371d4b9f8318a726e6522236bfce2..f8bbeacb3de66f3d47bab43b28d05b18f5e59018 100644 (file)
--- a/mutt/buffer.h
+++ b/mutt/buffer.h
@@ -42,11 +42,10 @@ struct Buffer
 
 #define MoreArgs(buf) (*(buf)->dptr && (*(buf)->dptr != ';') && (*(buf)->dptr != '#'))
 
-struct Buffer *mutt_buffer_alloc        (struct Buffer *buf, size_t size);
+void           mutt_buffer_alloc        (struct Buffer *buf, size_t size);
 void           mutt_buffer_dealloc      (struct Buffer *buf);
 void           mutt_buffer_fix_dptr     (struct Buffer *buf);
 void           mutt_buffer_free         (struct Buffer **p);
-struct Buffer *mutt_buffer_from         (const char *seed);
 struct Buffer *mutt_buffer_init         (struct Buffer *buf);
 bool           mutt_buffer_is_empty     (const struct Buffer *buf);
 size_t         mutt_buffer_len          (const struct Buffer *buf);

diff --git a/mutt/pool.c b/mutt/pool.c
index aecf4d6b386fdc12922f70f720bc47aafc327426..810d11bdf0df983da6c292203495fce46e29b07c 100644 (file)
--- a/mutt/pool.c
+++ b/mutt/pool.c
@@ -49,8 +49,8 @@ static void increase_buffer_pool(void)
   mutt_mem_realloc(&BufferPool, BufferPoolLen * sizeof(struct Buffer *));
   while (BufferPoolCount < BufferPoolIncrement)
   {
-    struct Buffer *newbuf =
-        mutt_buffer_alloc(mutt_buffer_new(), BufferPoolInitialBufferSize);
+    struct Buffer *newbuf = mutt_buffer_new();
+    mutt_buffer_alloc(newbuf, BufferPoolInitialBufferSize);
     BufferPool[BufferPoolCount++] = newbuf;
   }
 }

diff --git a/test/buffer/mutt_buffer_add_printf.c b/test/buffer/mutt_buffer_add_printf.c
index 1249a7fd6df13e6a4694620d8def6a1ea9080264..a79909c732614455bed7e1099e1b35f4cfaad916 100644 (file)
--- a/test/buffer/mutt_buffer_add_printf.c
+++ b/test/buffer/mutt_buffer_add_printf.c
@@ -84,20 +84,22 @@ void test_mutt_buffer_add_printf(void)
   {
     TEST_CASE("Empty");
     const char *str = "test";
-    struct Buffer *buf = mutt_buffer_from(str);
-    TEST_CHECK(mutt_buffer_add_printf(buf, "") == 0);
-    TEST_CHECK(strcmp(mutt_b2s(buf), str) == 0);
-    mutt_buffer_free(&buf);
+    struct Buffer buf = { 0 };
+    mutt_buffer_addstr(&buf, str);
+    TEST_CHECK(mutt_buffer_add_printf(&buf, "") == 0);
+    TEST_CHECK(strcmp(mutt_b2s(&buf), str) == 0);
+    mutt_buffer_dealloc(&buf);
   }
 
   {
     TEST_CASE("Static");
     const char *str = "apple";
     const char *result = "testapple";
-    struct Buffer *buf = mutt_buffer_from("test");
-    TEST_CHECK(mutt_buffer_add_printf(buf, str) == 5);
-    TEST_CHECK(strcmp(mutt_b2s(buf), result) == 0);
-    mutt_buffer_free(&buf);
+    struct Buffer buf = { 0 };
+    mutt_buffer_addstr(&buf, "test");
+    TEST_CHECK(mutt_buffer_add_printf(&buf, str) == 5);
+    TEST_CHECK(strcmp(mutt_b2s(&buf), result) == 0);
+    mutt_buffer_dealloc(&buf);
   }
 
   {
@@ -110,19 +112,21 @@ void test_mutt_buffer_add_printf(void)
         "testapple banana cherry damson elderberry fig guava hawthorn ilama "
         "jackfruit kumquat lemon mango nectarine olive papaya quince raspberry "
         "strawberry tangerine ugli vanilla wolfberry xigua yew ziziphus";
-    struct Buffer *buf = mutt_buffer_from("test");
-    TEST_CHECK(mutt_buffer_add_printf(buf, str) == 195);
-    TEST_CHECK(strcmp(mutt_b2s(buf), result) == 0);
-    mutt_buffer_free(&buf);
+    struct Buffer buf = { 0 };
+    mutt_buffer_addstr(&buf, "test");
+    TEST_CHECK(mutt_buffer_add_printf(&buf, str) == 195);
+    TEST_CHECK(strcmp(mutt_b2s(&buf), result) == 0);
+    mutt_buffer_dealloc(&buf);
   }
 
   {
     TEST_CASE("Varargs");
     const char *str = "apple";
     const char *result = "testapp 1234567 3.1416";
-    struct Buffer *buf = mutt_buffer_from("test");
-    TEST_CHECK(mutt_buffer_add_printf(buf, "%.3s %ld %3.4f", str, 1234567, 3.141592654) == 18);
-    TEST_CHECK(strcmp(mutt_b2s(buf), result) == 0);
-    mutt_buffer_free(&buf);
+    struct Buffer buf = { 0 };
+    mutt_buffer_addstr(&buf, "test");
+    TEST_CHECK(mutt_buffer_add_printf(&buf, "%.3s %ld %3.4f", str, 1234567, 3.141592654) == 18);
+    TEST_CHECK(strcmp(mutt_b2s(&buf), result) == 0);
+    mutt_buffer_dealloc(&buf);
   }
 }

diff --git a/test/buffer/mutt_buffer_addch.c b/test/buffer/mutt_buffer_addch.c
index 58b8fe6ae48a3d50c2a4edee3ab9f7673f190f50..e50569c3301ca00b6a19492cfa5c7603921bd99e 100644 (file)
--- a/test/buffer/mutt_buffer_addch.c
+++ b/test/buffer/mutt_buffer_addch.c
@@ -41,9 +41,10 @@ void test_mutt_buffer_addch(void)
   }
 
   {
-    struct Buffer *buf = mutt_buffer_from("test");
-    TEST_CHECK(mutt_buffer_addch(buf, 'a') == 1);
-    TEST_CHECK(strcmp(mutt_b2s(buf), "testa") == 0);
-    mutt_buffer_free(&buf);
+    struct Buffer buf = { 0 };
+    mutt_buffer_addstr(&buf, "test");
+    TEST_CHECK(mutt_buffer_addch(&buf, 'a') == 1);
+    TEST_CHECK(strcmp(mutt_b2s(&buf), "testa") == 0);
+    mutt_buffer_dealloc(&buf);
   }
 }

diff --git a/test/buffer/mutt_buffer_addstr.c b/test/buffer/mutt_buffer_addstr.c
index 4d09b201b5ca40b19b394684449f47153817076b..528da0a70ab4a58856720dc42061f9906ed1fa84 100644 (file)
--- a/test/buffer/mutt_buffer_addstr.c
+++ b/test/buffer/mutt_buffer_addstr.c
@@ -46,9 +46,10 @@ void test_mutt_buffer_addstr(void)
   }
 
   {
-    struct Buffer *buf = mutt_buffer_from("test");
-    TEST_CHECK(mutt_buffer_addstr(buf, "apple") == 5);
-    TEST_CHECK(strcmp(mutt_b2s(buf), "testapple") == 0);
-    mutt_buffer_free(&buf);
+    struct Buffer buf = { 0 };
+    mutt_buffer_addstr(&buf, "test");
+    TEST_CHECK(mutt_buffer_addstr(&buf, "apple") == 5);
+    TEST_CHECK(strcmp(mutt_b2s(&buf), "testapple") == 0);
+    mutt_buffer_dealloc(&buf);
   }
 }

diff --git a/test/buffer/mutt_buffer_addstr_n.c b/test/buffer/mutt_buffer_addstr_n.c
index afa0a3149c21ac0022bde0ac4f96685132d0af5c..0eb1da50144c4b43bc606cf4f998f3c3bc2132e0 100644 (file)
--- a/test/buffer/mutt_buffer_addstr_n.c
+++ b/test/buffer/mutt_buffer_addstr_n.c
@@ -69,11 +69,12 @@ void test_mutt_buffer_addstr_n(void)
     for (size_t i = 0; i < mutt_array_size(sizes); i++)
     {
       TEST_CASE_("%ld", sizes[i]);
-      struct Buffer *buf = mutt_buffer_from(base);
-      TEST_CHECK(mutt_buffer_addstr_n(buf, str, sizes[i]) == sizes[i]);
-      TEST_CHECK(strlen(mutt_b2s(buf)) == (base_len + MIN(len, sizes[i])));
-      TEST_CHECK(strncmp(mutt_b2s(buf), combined, base_len + sizes[i]) == 0);
-      mutt_buffer_free(&buf);
+      struct Buffer buf = { 0 };
+      mutt_buffer_addstr(&buf, base);
+      TEST_CHECK(mutt_buffer_addstr_n(&buf, str, sizes[i]) == sizes[i]);
+      TEST_CHECK(strlen(mutt_b2s(&buf)) == (base_len + MIN(len, sizes[i])));
+      TEST_CHECK(strncmp(mutt_b2s(&buf), combined, base_len + sizes[i]) == 0);
+      mutt_buffer_dealloc(&buf);
     }
   }
 }

diff --git a/test/buffer/mutt_buffer_concat_path.c b/test/buffer/mutt_buffer_concat_path.c
index cb0eea4205fca172a2b9626154918c862d5cb3b6..26a4a35a0667d5b9c8c08505fed5a82d482ff1f6 100644 (file)
--- a/test/buffer/mutt_buffer_concat_path.c
+++ b/test/buffer/mutt_buffer_concat_path.c
@@ -77,17 +77,18 @@ void test_mutt_buffer_concat_path(void)
 
       {
         const char *str = "test";
-        struct Buffer *buf = mutt_buffer_from(str);
-        mutt_buffer_concat_path(buf, concat_test[i][0], concat_test[i][1]);
+        struct Buffer buf = { 0 };
+        mutt_buffer_addstr(&buf, str);
+        mutt_buffer_concat_path(&buf, concat_test[i][0], concat_test[i][1]);
         if (concat_test[i][2])
         {
-          TEST_CHECK(strcmp(mutt_b2s(buf), concat_test[i][2]) == 0);
+          TEST_CHECK(strcmp(mutt_b2s(&buf), concat_test[i][2]) == 0);
         }
         else
         {
-          TEST_CHECK(strcmp(mutt_b2s(buf), str) == 0);
+          TEST_CHECK(strcmp(mutt_b2s(&buf), str) == 0);
         }
-        mutt_buffer_free(&buf);
+        mutt_buffer_dealloc(&buf);
       }
     }
   }

diff --git a/test/buffer/mutt_buffer_fix_dptr.c b/test/buffer/mutt_buffer_fix_dptr.c
index d29030fea85b80cfed6c7b0ce0626910f06c0bf8..a4872942f073528ab04bd7bf958420008a16a656 100644 (file)
--- a/test/buffer/mutt_buffer_fix_dptr.c
+++ b/test/buffer/mutt_buffer_fix_dptr.c
@@ -42,9 +42,10 @@ void test_mutt_buffer_fix_dptr(void)
 
   {
     const char *str = "a quick brown fox";
-    struct Buffer *buf = mutt_buffer_from(str);
-    mutt_buffer_fix_dptr(buf);
-    TEST_CHECK(mutt_buffer_len(buf) == (strlen(str) - 1));
-    mutt_buffer_free(&buf);
+    struct Buffer buf ={ 0 };
+    mutt_buffer_addstr(&buf, str);
+    mutt_buffer_fix_dptr(&buf);
+    TEST_CHECK(mutt_buffer_len(&buf) == (strlen(str)));
+    mutt_buffer_dealloc(&buf);
   }
 }

diff --git a/test/buffer/mutt_buffer_free.c b/test/buffer/mutt_buffer_free.c
index 59d04e578ea903355a2b029431cd5ad1ec964906..8277a0ab86f7af7e5222df98eebaaa1f3f0a0e32 100644 (file)
--- a/test/buffer/mutt_buffer_free.c
+++ b/test/buffer/mutt_buffer_free.c
@@ -47,11 +47,4 @@ void test_mutt_buffer_free(void)
     TEST_CHECK_(1, "mutt_buffer_free(&buf)");
     TEST_CHECK(buf == NULL);
   }
-
-  {
-    struct Buffer *buf = mutt_buffer_from("test");
-    mutt_buffer_free(&buf);
-    TEST_CHECK_(1, "mutt_buffer_free(&buf)");
-    TEST_CHECK(buf == NULL);
-  }
 }

diff --git a/test/buffer/mutt_buffer_is_empty.c b/test/buffer/mutt_buffer_is_empty.c
index 2e8f6c3875a97eee3d77a6836b9e15cbc13dd087..04be31be3661aca7a18e33245e5b0758eaa963e7 100644 (file)
--- a/test/buffer/mutt_buffer_is_empty.c
+++ b/test/buffer/mutt_buffer_is_empty.c
@@ -39,8 +39,9 @@ void test_mutt_buffer_is_empty(void)
   }
 
   {
-    struct Buffer *buf = mutt_buffer_from("test");
-    TEST_CHECK(!mutt_buffer_is_empty(buf));
-    mutt_buffer_free(&buf);
+    struct Buffer buf = { 0 };
+    mutt_buffer_addstr(&buf, "test");
+    TEST_CHECK(!mutt_buffer_is_empty(&buf));
+    mutt_buffer_dealloc(&buf);
   }
 }

diff --git a/test/buffer/mutt_buffer_len.c b/test/buffer/mutt_buffer_len.c
index c7dcdb8a76268f078a38f53d5f8e14cbf247ee56..96caf7fe9eb36dc83b1c05c44373918522996f1e 100644 (file)
--- a/test/buffer/mutt_buffer_len.c
+++ b/test/buffer/mutt_buffer_len.c
@@ -39,8 +39,9 @@ void test_mutt_buffer_len(void)
   }
 
   {
-    struct Buffer *buf = mutt_buffer_from("test");
-    TEST_CHECK(mutt_buffer_len(buf) != 0);
-    mutt_buffer_free(&buf);
+    struct Buffer buf = { 0 };
+    mutt_buffer_addstr(&buf, "test");
+    TEST_CHECK(mutt_buffer_len(&buf) != 0);
+    mutt_buffer_dealloc(&buf);
   }
 }

diff --git a/test/buffer/mutt_buffer_printf.c b/test/buffer/mutt_buffer_printf.c
index b09bf90ef9df8d51cdf5dab061fb6aefcaf033df..32c42adfd7bb6ce7a477a1605a3794ee59ab1b35 100644 (file)
--- a/test/buffer/mutt_buffer_printf.c
+++ b/test/buffer/mutt_buffer_printf.c
@@ -72,19 +72,21 @@ void test_mutt_buffer_printf(void)
   {
     TEST_CASE("Empty");
     const char *str = "test";
-    struct Buffer *buf = mutt_buffer_from(str);
-    TEST_CHECK(mutt_buffer_printf(buf, "") == 0);
-    TEST_CHECK(strcmp(mutt_b2s(buf), "") == 0);
-    mutt_buffer_free(&buf);
+    struct Buffer buf = { 0 };
+    mutt_buffer_addstr(&buf, str);
+    TEST_CHECK(mutt_buffer_printf(&buf, "") == 0);
+    TEST_CHECK(strcmp(mutt_b2s(&buf), "") == 0);
+    mutt_buffer_dealloc(&buf);
   }
 
   {
     TEST_CASE("Static");
     const char *str = "apple";
-    struct Buffer *buf = mutt_buffer_from("test");
-    TEST_CHECK(mutt_buffer_printf(buf, str) == 5);
-    TEST_CHECK(strcmp(mutt_b2s(buf), str) == 0);
-    mutt_buffer_free(&buf);
+    struct Buffer buf = { 0 };
+    mutt_buffer_addstr(&buf, "test");
+    TEST_CHECK(mutt_buffer_printf(&buf, str) == 5);
+    TEST_CHECK(strcmp(mutt_b2s(&buf), str) == 0);
+    mutt_buffer_dealloc(&buf);
   }
 
   {
@@ -93,19 +95,21 @@ void test_mutt_buffer_printf(void)
         "apple banana cherry damson elderberry fig guava hawthorn ilama "
         "jackfruit kumquat lemon mango nectarine olive papaya quince raspberry "
         "strawberry tangerine ugli vanilla wolfberry xigua yew ziziphus";
-    struct Buffer *buf = mutt_buffer_from("test");
-    TEST_CHECK(mutt_buffer_printf(buf, str) == 195);
-    TEST_CHECK(strcmp(mutt_b2s(buf), str) == 0);
-    mutt_buffer_free(&buf);
+    struct Buffer buf = { 0 };
+    mutt_buffer_addstr(&buf, "test");
+    TEST_CHECK(mutt_buffer_printf(&buf, str) == 195);
+    TEST_CHECK(strcmp(mutt_b2s(&buf), str) == 0);
+    mutt_buffer_dealloc(&buf);
   }
 
   {
     TEST_CASE("Varargs");
     const char *str = "apple";
     const char *result = "app 1234567 3.1416";
-    struct Buffer *buf = mutt_buffer_from("test");
-    TEST_CHECK(mutt_buffer_printf(buf, "%.3s %ld %3.4f", str, 1234567, 3.141592654) == 18);
-    TEST_CHECK(strcmp(mutt_b2s(buf), result) == 0);
-    mutt_buffer_free(&buf);
+    struct Buffer buf = { 0 };
+    mutt_buffer_addstr(&buf, "test");
+    TEST_CHECK(mutt_buffer_printf(&buf, "%.3s %ld %3.4f", str, 1234567, 3.141592654) == 18);
+    TEST_CHECK(strcmp(mutt_b2s(&buf), result) == 0);
+    mutt_buffer_dealloc(&buf);
   }
 }

diff --git a/test/buffer/mutt_buffer_reset.c b/test/buffer/mutt_buffer_reset.c
index d0989c85817d9b86a5d6cca2213593ecf5131d14..23ec13ad6c119813acc8a465e48be69050906c61 100644 (file)
--- a/test/buffer/mutt_buffer_reset.c
+++ b/test/buffer/mutt_buffer_reset.c
@@ -41,9 +41,10 @@ void test_mutt_buffer_reset(void)
   }
 
   {
-    struct Buffer *buf = mutt_buffer_from("test");
-    mutt_buffer_reset(buf);
+    struct Buffer buf = { 0 };
+    mutt_buffer_addstr(&buf, "test");
+    mutt_buffer_reset(&buf);
     TEST_CHECK_(1, "mutt_buffer_reset(buf)");
-    mutt_buffer_free(&buf);
+    mutt_buffer_dealloc(&buf);
   }
 }

diff --git a/test/buffer/mutt_buffer_strcpy.c b/test/buffer/mutt_buffer_strcpy.c
index 9f85e4d5a478bea788dad9d92ea31384ce148bc6..c4b09cd035af7ac5ed1d8e889a695dca64fef8ef 100644 (file)
--- a/test/buffer/mutt_buffer_strcpy.c
+++ b/test/buffer/mutt_buffer_strcpy.c
@@ -63,18 +63,20 @@ void test_mutt_buffer_strcpy(void)
 
   {
     TEST_CASE("Empty");
-    struct Buffer *buf = mutt_buffer_from("test");
-    mutt_buffer_strcpy(buf, "");
-    TEST_CHECK(strcmp(mutt_b2s(buf), "") == 0);
-    mutt_buffer_free(&buf);
+    struct Buffer buf = { 0 };
+    mutt_buffer_addstr(&buf, "test");
+    mutt_buffer_strcpy(&buf, "");
+    TEST_CHECK(strcmp(mutt_b2s(&buf), "") == 0);
+    mutt_buffer_dealloc(&buf);
   }
 
   {
     TEST_CASE("String");
     const char *str = "apple";
-    struct Buffer *buf = mutt_buffer_from("test");
-    mutt_buffer_strcpy(buf, str);
-    TEST_CHECK(strcmp(mutt_b2s(buf), str) == 0);
-    mutt_buffer_free(&buf);
+    struct Buffer buf = { 0 };
+    mutt_buffer_addstr(&buf, "test");
+    mutt_buffer_strcpy(&buf, str);
+    TEST_CHECK(strcmp(mutt_b2s(&buf), str) == 0);
+    mutt_buffer_dealloc(&buf);
   }
 }

diff --git a/test/buffer/mutt_buffer_strcpy_n.c b/test/buffer/mutt_buffer_strcpy_n.c
index f78d37f5ea888526399f8ecb981712c359224949..e0bc316a9bb6f135672073e140983102a8927b1c 100644 (file)
--- a/test/buffer/mutt_buffer_strcpy_n.c
+++ b/test/buffer/mutt_buffer_strcpy_n.c
@@ -69,11 +69,12 @@ void test_mutt_buffer_strcpy_n(void)
     for (size_t i = 0; i < mutt_array_size(sizes); i++)
     {
       TEST_CASE_("%ld", sizes[i]);
-      struct Buffer *buf = mutt_buffer_from(base);
-      mutt_buffer_strcpy_n(buf, str, sizes[i]);
-      TEST_CHECK(strlen(mutt_b2s(buf)) == MIN(len, sizes[i]));
-      TEST_CHECK(strncmp(mutt_b2s(buf), str, sizes[i]) == 0);
-      mutt_buffer_free(&buf);
+      struct Buffer buf = { 0 };
+      mutt_buffer_addstr(&buf, base);
+      mutt_buffer_strcpy_n(&buf, str, sizes[i]);
+      TEST_CHECK(strlen(mutt_b2s(&buf)) == MIN(len, sizes[i]));
+      TEST_CHECK(strncmp(mutt_b2s(&buf), str, sizes[i]) == 0);
+      mutt_buffer_dealloc(&buf);
     }
   }
 }

diff --git a/test/config/dump.c b/test/config/dump.c
index 8320da2a611ee55b9bd8b50ff7f72deeb0e28cf6..34ca98e5ad96aa1575504c18c13a39c3849e977e 100644 (file)
--- a/test/config/dump.c
+++ b/test/config/dump.c
@@ -238,8 +238,10 @@ bool test_dump_config_neo(void)
 
     struct HashElem *he = cs_get_elem(cs, "Banana");
 
-    struct Buffer *buf_val = mutt_buffer_from("yes");
-    struct Buffer *buf_init = mutt_buffer_from("yes");
+    struct Buffer buf_val = { 0 };
+    mutt_buffer_addstr(&buf_val, "yes");
+    struct Buffer buf_init = { 0 };
+    mutt_buffer_addstr(&buf_init, "yes");
 
     FILE *fp = fopen("/dev/null", "w");
     if (!fp)
@@ -247,48 +249,48 @@ bool test_dump_config_neo(void)
 
     // Degenerate tests
 
-    dump_config_neo(NULL, he, buf_val, buf_init, CS_DUMP_NO_FLAGS, fp);
+    dump_config_neo(NULL, he, &buf_val, &buf_init, CS_DUMP_NO_FLAGS, fp);
     TEST_CHECK_(
         1,
-        "dump_config_neo(NULL, he, buf_val, buf_init, CS_DUMP_NO_FLAGS, fp)");
-    dump_config_neo(cs, NULL, buf_val, buf_init, CS_DUMP_NO_FLAGS, fp);
+        "dump_config_neo(NULL, he, &buf_val, &buf_init, CS_DUMP_NO_FLAGS, fp)");
+    dump_config_neo(cs, NULL, &buf_val, &buf_init, CS_DUMP_NO_FLAGS, fp);
     TEST_CHECK_(
         1,
-        "dump_config_neo(cs, NULL, buf_val, buf_init, CS_DUMP_NO_FLAGS, fp)");
-    dump_config_neo(cs, he, NULL, buf_init, CS_DUMP_NO_FLAGS, fp);
+        "dump_config_neo(cs, NULL, &buf_val, &buf_init, CS_DUMP_NO_FLAGS, fp)");
+    dump_config_neo(cs, he, NULL, &buf_init, CS_DUMP_NO_FLAGS, fp);
     TEST_CHECK_(
-        1, "dump_config_neo(cs, he, NULL, buf_init, CS_DUMP_NO_FLAGS, fp)");
-    dump_config_neo(cs, he, buf_val, NULL, CS_DUMP_NO_FLAGS, fp);
+        1, "dump_config_neo(cs, he, NULL, &buf_init, CS_DUMP_NO_FLAGS, fp)");
+    dump_config_neo(cs, he, &buf_val, NULL, CS_DUMP_NO_FLAGS, fp);
     TEST_CHECK_(1,
-                "dump_config_neo(cs, he, buf_val, NULL, CS_DUMP_NO_FLAGS, fp)");
-    dump_config_neo(cs, he, buf_val, buf_init, CS_DUMP_NO_FLAGS, NULL);
+                "dump_config_neo(cs, he, &buf_val, NULL, CS_DUMP_NO_FLAGS, fp)");
+    dump_config_neo(cs, he, &buf_val, &buf_init, CS_DUMP_NO_FLAGS, NULL);
     TEST_CHECK_(
         1,
-        "dump_config_neo(cs, he, buf_val, buf_init, CS_DUMP_NO_FLAGS, NULL)");
+        "dump_config_neo(cs, he, &buf_val, &buf_init, CS_DUMP_NO_FLAGS, NULL)");
 
     // Normal tests
 
-    dump_config_neo(cs, he, buf_val, buf_init, CS_DUMP_NO_FLAGS, fp);
+    dump_config_neo(cs, he, &buf_val, &buf_init, CS_DUMP_NO_FLAGS, fp);
     TEST_CHECK_(
-        1, "dump_config_neo(cs, he, buf_val, buf_init, CS_DUMP_NO_FLAGS, fp)");
+        1, "dump_config_neo(cs, he, &buf_val, &buf_init, CS_DUMP_NO_FLAGS, fp)");
 
-    dump_config_neo(cs, he, buf_val, buf_init, CS_DUMP_ONLY_CHANGED, fp);
+    dump_config_neo(cs, he, &buf_val, &buf_init, CS_DUMP_ONLY_CHANGED, fp);
     TEST_CHECK_(
         1,
-        "dump_config_neo(cs, he, buf_val, buf_init, CS_DUMP_ONLY_CHANGED, fp)");
+        "dump_config_neo(cs, he, &buf_val, &buf_init, CS_DUMP_ONLY_CHANGED, fp)");
 
-    dump_config_neo(cs, he, buf_val, buf_init, CS_DUMP_SHOW_DEFAULTS, fp);
-    TEST_CHECK_(1, "dump_config_neo(cs, he, buf_val, buf_init, "
+    dump_config_neo(cs, he, &buf_val, &buf_init, CS_DUMP_SHOW_DEFAULTS, fp);
+    TEST_CHECK_(1, "dump_config_neo(cs, he, &buf_val, &buf_init, "
                    "CS_DUMP_SHOW_DEFAULTS, fp)");
 
     he = mutt_hash_find_elem(cs->hash, "Damson");
-    dump_config_neo(cs, he, buf_val, buf_init, CS_DUMP_NO_FLAGS, fp);
+    dump_config_neo(cs, he, &buf_val, &buf_init, CS_DUMP_NO_FLAGS, fp);
     TEST_CHECK_(
-        1, "dump_config_neo(cs, he, buf_val, buf_init, CS_DUMP_NO_FLAGS, fp)");
+        1, "dump_config_neo(cs, he, &buf_val, &buf_init, CS_DUMP_NO_FLAGS, fp)");
 
     fclose(fp);
-    mutt_buffer_free(&buf_val);
-    mutt_buffer_free(&buf_init);
+    mutt_buffer_dealloc(&buf_val);
+    mutt_buffer_dealloc(&buf_init);
     cs_free(&cs);
   }