Re: obstack_printf

[Eric Blake]

-----BEGIN PGP SIGNED MESSAGE-----
Hash: SHA1

According to Bruno Haible on 6/14/2008 1:33 AM:
|
| 5) What do you mean by this comment in tests/test-obstack-printf.c ?
|   /* In general, don't invoke obstack_* functions inside ASSERT, as
|      not all compilers can avoid multiple side effects.  */
|
| The ASSERT macro is ours, not the system's one. What can go wrong regarding
| "multiple side effects"?

I've been bitten in the past by side effects occurring multiple times when
using obstack_* functions.  But you are correct; ASSERT does not evaluate
its argument multiple times, so calling obstack_* in ASSERT is fine.

So I'm committing this cleanup.  It also improves test coverage, as
previously nothing tested the case of calling vasnprintf pointed directly
into the obstack but having so much output as to spill into an allocated
string.

- --
Don't work too hard, make some time for fun as well!

Eric Blake             address@hidden
-----BEGIN PGP SIGNATURE-----
Version: GnuPG v1.4.9 (Cygwin)
Comment: Public key at home.comcast.net/~ericblake/eblake.gpg
Comment: Using GnuPG with Mozilla - http://enigmail.mozdev.org

iEYEARECAAYFAkhTyX0ACgkQ84KuGfSFAYA6mgCcCR5fDFBVYSdq17IwTAXXI+HP
R8UAni9LaeT+rtUVU5zn2Svbid1MxgTH
=ReKu
-----END PGP SIGNATURE-----

>From b63678879f8846581597d2065641bebd04feda92 Mon Sep 17 00:00:00 2001
From: Eric Blake <address@hidden>
Date: Sat, 14 Jun 2008 07:36:03 -0600
Subject: [PATCH] Improve obstack-printf test code.

* tests/test-obstack-printf.c (test_function): Fix comment, and
simplify usage of obstack_* in macros.  Add a test for coverage.
Reported by Bruno Haible.

Signed-off-by: Eric Blake <address@hidden>
---
 ChangeLog                   |    7 +++++++
 tests/test-obstack-printf.c |   35 +++++++++++++++++++++++++----------
 2 files changed, 32 insertions(+), 10 deletions(-)

diff --git a/ChangeLog b/ChangeLog
index f82c944..c2f2a81 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,10 @@
+2008-06-14  Eric Blake  <address@hidden>
+
+       Improve obstack-printf test code.
+       * tests/test-obstack-printf.c (test_function): Fix comment, and
+       simplify usage of obstack_* in macros.  Add a test for coverage.
+       Reported by Bruno Haible.
+
 2008-06-14  Bruno Haible  <address@hidden>
 
        * lib/obstack_printf.c (obstack_vprintf): Define the stack-allocated
diff --git a/tests/test-obstack-printf.c b/tests/test-obstack-printf.c
index fba7887..9c2761a 100644
--- a/tests/test-obstack-printf.c
+++ b/tests/test-obstack-printf.c
@@ -47,23 +47,22 @@ test_function (int (*my_obstack_printf) (struct obstack *, 
const char *, ...))
 {
   struct obstack obs;
   obstack_init (&obs);
-  /* In general, don't invoke obstack_* functions inside ASSERT, as
-     not all compilers can avoid multiple side effects.  */
+  /* In general, be careful that arguments to obstack_* don't have
+     side effects, as not all compilers evaluate macro arguments only
+     once.  */
 
-  /* Grow the obstack to near its boundary, then check that output
-     longer than the obstack free space grows the obstack.  */
+  /* Grow the obstack to near its boundary, then check that short
+     output longer than the obstack free space grows the obstack.  */
   {
     char *base = obstack_base (&obs);
     char *new_base;
     int result;
-    int size;
     int room = obstack_room (&obs) - 4;
 
     obstack_blank_fast (&obs, room);
     result = my_obstack_printf (&obs, "%d %s", 123, "456");
     ASSERT (result == 7);
-    size = obstack_object_size (&obs);
-    ASSERT (result + room == size);
+    ASSERT (result + room == obstack_object_size (&obs));
     obstack_1grow (&obs, 0);
     new_base = obstack_finish (&obs);
     ASSERT (base != new_base);
@@ -76,17 +75,33 @@ test_function (int (*my_obstack_printf) (struct obstack *, 
const char *, ...))
     char *base = obstack_base (&obs);
     char *new_base;
     int result;
-    int size;
     int room = obstack_room (&obs);
 
     ASSERT (8 < room);
     result = my_obstack_printf (&obs, "%d %s", 123, "456");
     ASSERT (result == 7);
-    size = obstack_object_size (&obs);
-    ASSERT (result == size);
+    ASSERT (result == obstack_object_size (&obs));
     new_base = obstack_base (&obs);
     ASSERT (base == new_base);
     ASSERT (strncmp (base, "123 456", result) == 0);
+    obstack_finish (&obs);
+  }
+
+  /* Check for generating much more output than a chunk size.  */
+  {
+    char *base = obstack_base (&obs);
+    char *new_base;
+    int result;
+    int i;
+
+    ASSERT (obstack_chunk_size (&obs) < 10000);
+    result = my_obstack_printf (&obs, "%010000d", 0);
+    ASSERT (result == 10000);
+    ASSERT (result == obstack_object_size (&obs));
+    new_base = obstack_base (&obs);
+    ASSERT (base != new_base);
+    for (i = 0; i < 10000; i++)
+      ASSERT (new_base[i] == '0');
   }
 
   obstack_free (&obs, NULL);
-- 
1.5.5.1