From: Pietro Cerutti <gahr@gahr.ch>
Date: Tue, 27 Aug 2019 11:12:58 +0000 (+0000)
Subject: Kill mutt_buffer_from
X-Git-Tag: 2019-10-25~64^2~3
X-Git-Url: https://granicus.if.org/sourcecode?a=commitdiff_plain;h=bfed48e7e0dc1f5e5fe2f071be8b96753bda54ba;p=neomutt

Kill mutt_buffer_from
---

diff --git a/icommands.c b/icommands.c
index 6c1818419..acaacb2be 100644
--- 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 001f3e764..29fc293b8 100644
--- 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 12cd89064..d00bc6992 100644
--- 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 c35a8df63..43c5ae131 100644
--- 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 dcecbbe60..f8bbeacb3 100644
--- 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 aecf4d6b3..810d11bdf 100644
--- 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 1249a7fd6..a79909c73 100644
--- 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 58b8fe6ae..e50569c33 100644
--- 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 4d09b201b..528da0a70 100644
--- 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 afa0a3149..0eb1da501 100644
--- 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 cb0eea420..26a4a35a0 100644
--- 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 d29030fea..a4872942f 100644
--- 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 59d04e578..8277a0ab8 100644
--- 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 2e8f6c387..04be31be3 100644
--- 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 c7dcdb8a7..96caf7fe9 100644
--- 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 b09bf90ef..32c42adfd 100644
--- 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 d0989c858..23ec13ad6 100644
--- 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 9f85e4d5a..c4b09cd03 100644
--- 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 f78d37f5e..e0bc316a9 100644
--- 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 8320da2a6..34ca98e5a 100644
--- 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);
   }