sin/samba-mirror
1
0
Fork 0
mirror of https://github.com/samba-team/samba.git synced 2025-02-09 09:57:48 +03:00
Code
samba-mirror/source4/lib/talloc/testsuite.c

840 lines
17 KiB
C
Raw Normal View History

r2709: finally solved the talloc reference problem. The problem was that the simple "uint_t ref_count;" in a talloc chunk did not give enough information. It told us that a pointer was referenced more than once, but it didn't say who it was referenced by. This means that when the pointer was freed we had no sane way to clean up the reference. I have now replaced ref_count with a "refs" list, which means that references point to the pointer, and the pointer has a linked list of references. So now we can cleanup from either direction without losing track of anything. I've also added a LOCAL-TALLOC smbtorture test that tests talloc behaviour for some common uses. (This used to be commit 911a8d590cb184bcb892810729955c2c4cf02550)
2004-09-28 05:42:02 +00:00
/*
Unix SMB/CIFS implementation.
local testing of talloc routines.
Copyright (C) Andrew Tridgell 2004
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
r4466: rather than defining "STANDALONE" for building tdb, ldb and talloc outside the tree, instead defined _SAMBA_BUILD_ inside the Samba build. This makes it easier to pull code out of Samba for external use. (This used to be commit 09e98c8745cca7ccb1ad7134c0c09b8e4c0f4f06)
2005-01-01 05:06:22 +00:00
#ifdef _SAMBA_BUILD_
#include "includes.h"
#else
r2791: got rid of talloc_unreference() and instead created talloc_unlink(), which is much clearer and simpler to use. It removes a specific parent from a pointer, no matter whether that parent is a "reference" or a direct parent. This gives complete control over the free process. (This used to be commit 6c563887f1b9b8c842309a523e88b6f2a32db10f)
2004-10-03 00:04:30 +00:00
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdarg.h>
#include <sys/time.h>
#include <time.h>
#include "talloc.h"
#endif
/* the test suite can be built standalone, or as part of Samba */
r4466: rather than defining "STANDALONE" for building tdb, ldb and talloc outside the tree, instead defined _SAMBA_BUILD_ inside the Samba build. This makes it easier to pull code out of Samba for external use. (This used to be commit 09e98c8745cca7ccb1ad7134c0c09b8e4c0f4f06)
2005-01-01 05:06:22 +00:00
#ifndef _SAMBA_BUILD_
r2791: got rid of talloc_unreference() and instead created talloc_unlink(), which is much clearer and simpler to use. It removes a specific parent from a pointer, no matter whether that parent is a "reference" or a direct parent. This gives complete control over the free process. (This used to be commit 6c563887f1b9b8c842309a523e88b6f2a32db10f)
2004-10-03 00:04:30 +00:00
typedef enum {False=0,True=1} BOOL;
r4473: - moved talloc into its own lib/talloc/ area - added gcov flags to Makefile.talloc - expanded talloc testsuite to add a test for realloc with a child ptr - fixed a bug in talloc_realloc() with realloc of a ptr that has child ptrs (This used to be commit 98b5f73c1ba34d7576c5995069b485c1c5ede324)
2005-01-02 07:47:34 +00:00
static struct timeval timeval_current(void)
r2791: got rid of talloc_unreference() and instead created talloc_unlink(), which is much clearer and simpler to use. It removes a specific parent from a pointer, no matter whether that parent is a "reference" or a direct parent. This gives complete control over the free process. (This used to be commit 6c563887f1b9b8c842309a523e88b6f2a32db10f)
2004-10-03 00:04:30 +00:00
{
r3507: - added deferred replies on sharing violation in pvfs open. The deferred reply is short-circuited immediately when the file is closed by another user, allowing it to be opened by the waiting user. - added a sane set of timeval manipulation routines - converted all the events code and code that uses it to use struct timeval instead of time_t, which allows for microsecond resolution instead of 1 second resolution. This was needed for doing the pvfs deferred open code, and is why the patch is so big. (This used to be commit 0d51511d408d91eb5f68a35e980e0875299b1831)
2004-11-03 10:09:48 +00:00
struct timeval tv;
r4473: - moved talloc into its own lib/talloc/ area - added gcov flags to Makefile.talloc - expanded talloc testsuite to add a test for realloc with a child ptr - fixed a bug in talloc_realloc() with realloc of a ptr that has child ptrs (This used to be commit 98b5f73c1ba34d7576c5995069b485c1c5ede324)
2005-01-02 07:47:34 +00:00
gettimeofday(&tv, NULL);
r3507: - added deferred replies on sharing violation in pvfs open. The deferred reply is short-circuited immediately when the file is closed by another user, allowing it to be opened by the waiting user. - added a sane set of timeval manipulation routines - converted all the events code and code that uses it to use struct timeval instead of time_t, which allows for microsecond resolution instead of 1 second resolution. This was needed for doing the pvfs deferred open code, and is why the patch is so big. (This used to be commit 0d51511d408d91eb5f68a35e980e0875299b1831)
2004-11-03 10:09:48 +00:00
return tv;
r2791: got rid of talloc_unreference() and instead created talloc_unlink(), which is much clearer and simpler to use. It removes a specific parent from a pointer, no matter whether that parent is a "reference" or a direct parent. This gives complete control over the free process. (This used to be commit 6c563887f1b9b8c842309a523e88b6f2a32db10f)
2004-10-03 00:04:30 +00:00
}
r4473: - moved talloc into its own lib/talloc/ area - added gcov flags to Makefile.talloc - expanded talloc testsuite to add a test for realloc with a child ptr - fixed a bug in talloc_realloc() with realloc of a ptr that has child ptrs (This used to be commit 98b5f73c1ba34d7576c5995069b485c1c5ede324)
2005-01-02 07:47:34 +00:00
static double timeval_elapsed(struct timeval *tv)
r2791: got rid of talloc_unreference() and instead created talloc_unlink(), which is much clearer and simpler to use. It removes a specific parent from a pointer, no matter whether that parent is a "reference" or a direct parent. This gives complete control over the free process. (This used to be commit 6c563887f1b9b8c842309a523e88b6f2a32db10f)
2004-10-03 00:04:30 +00:00
{
r4473: - moved talloc into its own lib/talloc/ area - added gcov flags to Makefile.talloc - expanded talloc testsuite to add a test for realloc with a child ptr - fixed a bug in talloc_realloc() with realloc of a ptr that has child ptrs (This used to be commit 98b5f73c1ba34d7576c5995069b485c1c5ede324)
2005-01-02 07:47:34 +00:00
struct timeval tv2 = timeval_current();
r3507: - added deferred replies on sharing violation in pvfs open. The deferred reply is short-circuited immediately when the file is closed by another user, allowing it to be opened by the waiting user. - added a sane set of timeval manipulation routines - converted all the events code and code that uses it to use struct timeval instead of time_t, which allows for microsecond resolution instead of 1 second resolution. This was needed for doing the pvfs deferred open code, and is why the patch is so big. (This used to be commit 0d51511d408d91eb5f68a35e980e0875299b1831)
2004-11-03 10:09:48 +00:00
return (tv2.tv_sec - tv->tv_sec) +
(tv2.tv_usec - tv->tv_usec)*1.0e-6;
r2791: got rid of talloc_unreference() and instead created talloc_unlink(), which is much clearer and simpler to use. It removes a specific parent from a pointer, no matter whether that parent is a "reference" or a direct parent. This gives complete control over the free process. (This used to be commit 6c563887f1b9b8c842309a523e88b6f2a32db10f)
2004-10-03 00:04:30 +00:00
}
r4466: rather than defining "STANDALONE" for building tdb, ldb and talloc outside the tree, instead defined _SAMBA_BUILD_ inside the Samba build. This makes it easier to pull code out of Samba for external use. (This used to be commit 09e98c8745cca7ccb1ad7134c0c09b8e4c0f4f06)
2005-01-01 05:06:22 +00:00
#endif /* _SAMBA_BUILD_ */
r2709: finally solved the talloc reference problem. The problem was that the simple "uint_t ref_count;" in a talloc chunk did not give enough information. It told us that a pointer was referenced more than once, but it didn't say who it was referenced by. This means that when the pointer was freed we had no sane way to clean up the reference. I have now replaced ref_count with a "refs" list, which means that references point to the pointer, and the pointer has a linked list of references. So now we can cleanup from either direction without losing track of anything. I've also added a LOCAL-TALLOC smbtorture test that tests talloc behaviour for some common uses. (This used to be commit 911a8d590cb184bcb892810729955c2c4cf02550)
2004-09-28 05:42:02 +00:00
r2742: - fixed a bug in talloc_unreference() - made the LOCAL-TALLOC smbtorture test much stricter, checking that block counts for every pointer are correct after every operation (This used to be commit 18d3e2647f0bedbba699d1ba2649c0cfe4526ef6)
2004-09-28 23:30:14 +00:00
r2744: ben elliston taught me about gcov today, which allows you to measure the % coverage in terms of lines of code of a test suite. I thought a good first place to start with gcov was the talloc test suite. When I started the test suite covered about 60% of all lines of code in talloc.c, and now it covers about 99%. The only lines not covered are talloc corruption errors, as that would cause smb_panic() to fire. It will be interesting to try gcov on the main Samba test suite for smbd. We won't achieve 100% coverage, but it would be nice to get to 90% or more. I also modified the talloc.c sources to be able to be build standalone, using: gcc -c -D_STANDALONE_ -Iinlcude lib/talloc.c that should make it much easier to re-use talloc in other projects (This used to be commit 8d4dc99b82efdf24b6811851c7bdd4af5a4c52c9)
2004-09-29 06:31:14 +00:00
#define CHECK_SIZE(ptr, tsize) do { \
if (talloc_total_size(ptr) != (tsize)) { \
printf(__location__ " failed: wrong '%s' tree size: got %u expected %u\n", \
#ptr, \
(unsigned)talloc_total_size(ptr), \
(unsigned)tsize); \
talloc_report_full(ptr, stdout); \
return False; \
} \
} while (0)
r2791: got rid of talloc_unreference() and instead created talloc_unlink(), which is much clearer and simpler to use. It removes a specific parent from a pointer, no matter whether that parent is a "reference" or a direct parent. This gives complete control over the free process. (This used to be commit 6c563887f1b9b8c842309a523e88b6f2a32db10f)
2004-10-03 00:04:30 +00:00
#define CHECK_BLOCKS(ptr, tblocks) do { \
if (talloc_total_blocks(ptr) != (tblocks)) { \
printf(__location__ " failed: wrong '%s' tree blocks: got %u expected %u\n", \
#ptr, \
(unsigned)talloc_total_blocks(ptr), \
(unsigned)tblocks); \
talloc_report_full(ptr, stdout); \
return False; \
} \
} while (0)
r2709: finally solved the talloc reference problem. The problem was that the simple "uint_t ref_count;" in a talloc chunk did not give enough information. It told us that a pointer was referenced more than once, but it didn't say who it was referenced by. This means that when the pointer was freed we had no sane way to clean up the reference. I have now replaced ref_count with a "refs" list, which means that references point to the pointer, and the pointer has a linked list of references. So now we can cleanup from either direction without losing track of anything. I've also added a LOCAL-TALLOC smbtorture test that tests talloc behaviour for some common uses. (This used to be commit 911a8d590cb184bcb892810729955c2c4cf02550)
2004-09-28 05:42:02 +00:00
/*
test references
*/
static BOOL test_ref1(void)
{
r2742: - fixed a bug in talloc_unreference() - made the LOCAL-TALLOC smbtorture test much stricter, checking that block counts for every pointer are correct after every operation (This used to be commit 18d3e2647f0bedbba699d1ba2649c0cfe4526ef6)
2004-09-28 23:30:14 +00:00
void *root, *p1, *p2, *ref, *r1;
r2709: finally solved the talloc reference problem. The problem was that the simple "uint_t ref_count;" in a talloc chunk did not give enough information. It told us that a pointer was referenced more than once, but it didn't say who it was referenced by. This means that when the pointer was freed we had no sane way to clean up the reference. I have now replaced ref_count with a "refs" list, which means that references point to the pointer, and the pointer has a linked list of references. So now we can cleanup from either direction without losing track of anything. I've also added a LOCAL-TALLOC smbtorture test that tests talloc behaviour for some common uses. (This used to be commit 911a8d590cb184bcb892810729955c2c4cf02550)
2004-09-28 05:42:02 +00:00
printf("TESTING SINGLE REFERENCE FREE\n");
r2742: - fixed a bug in talloc_unreference() - made the LOCAL-TALLOC smbtorture test much stricter, checking that block counts for every pointer are correct after every operation (This used to be commit 18d3e2647f0bedbba699d1ba2649c0cfe4526ef6)
2004-09-28 23:30:14 +00:00
root = talloc_named_const(NULL, 0, "root");
p1 = talloc_named_const(root, 1, "p1");
r2709: finally solved the talloc reference problem. The problem was that the simple "uint_t ref_count;" in a talloc chunk did not give enough information. It told us that a pointer was referenced more than once, but it didn't say who it was referenced by. This means that when the pointer was freed we had no sane way to clean up the reference. I have now replaced ref_count with a "refs" list, which means that references point to the pointer, and the pointer has a linked list of references. So now we can cleanup from either direction without losing track of anything. I've also added a LOCAL-TALLOC smbtorture test that tests talloc behaviour for some common uses. (This used to be commit 911a8d590cb184bcb892810729955c2c4cf02550)
2004-09-28 05:42:02 +00:00
p2 = talloc_named_const(p1, 1, "p2");
talloc_named_const(p1, 1, "x1");
r2742: - fixed a bug in talloc_unreference() - made the LOCAL-TALLOC smbtorture test much stricter, checking that block counts for every pointer are correct after every operation (This used to be commit 18d3e2647f0bedbba699d1ba2649c0cfe4526ef6)
2004-09-28 23:30:14 +00:00
talloc_named_const(p1, 2, "x2");
talloc_named_const(p1, 3, "x3");
r2709: finally solved the talloc reference problem. The problem was that the simple "uint_t ref_count;" in a talloc chunk did not give enough information. It told us that a pointer was referenced more than once, but it didn't say who it was referenced by. This means that when the pointer was freed we had no sane way to clean up the reference. I have now replaced ref_count with a "refs" list, which means that references point to the pointer, and the pointer has a linked list of references. So now we can cleanup from either direction without losing track of anything. I've also added a LOCAL-TALLOC smbtorture test that tests talloc behaviour for some common uses. (This used to be commit 911a8d590cb184bcb892810729955c2c4cf02550)
2004-09-28 05:42:02 +00:00
r2742: - fixed a bug in talloc_unreference() - made the LOCAL-TALLOC smbtorture test much stricter, checking that block counts for every pointer are correct after every operation (This used to be commit 18d3e2647f0bedbba699d1ba2649c0cfe4526ef6)
2004-09-28 23:30:14 +00:00
r1 = talloc_named_const(root, 1, "r1");
r2709: finally solved the talloc reference problem. The problem was that the simple "uint_t ref_count;" in a talloc chunk did not give enough information. It told us that a pointer was referenced more than once, but it didn't say who it was referenced by. This means that when the pointer was freed we had no sane way to clean up the reference. I have now replaced ref_count with a "refs" list, which means that references point to the pointer, and the pointer has a linked list of references. So now we can cleanup from either direction without losing track of anything. I've also added a LOCAL-TALLOC smbtorture test that tests talloc behaviour for some common uses. (This used to be commit 911a8d590cb184bcb892810729955c2c4cf02550)
2004-09-28 05:42:02 +00:00
ref = talloc_reference(r1, p2);
r2742: - fixed a bug in talloc_unreference() - made the LOCAL-TALLOC smbtorture test much stricter, checking that block counts for every pointer are correct after every operation (This used to be commit 18d3e2647f0bedbba699d1ba2649c0cfe4526ef6)
2004-09-28 23:30:14 +00:00
talloc_report_full(root, stdout);
CHECK_BLOCKS(p1, 5);
CHECK_BLOCKS(p2, 1);
CHECK_BLOCKS(r1, 2);
r2709: finally solved the talloc reference problem. The problem was that the simple "uint_t ref_count;" in a talloc chunk did not give enough information. It told us that a pointer was referenced more than once, but it didn't say who it was referenced by. This means that when the pointer was freed we had no sane way to clean up the reference. I have now replaced ref_count with a "refs" list, which means that references point to the pointer, and the pointer has a linked list of references. So now we can cleanup from either direction without losing track of anything. I've also added a LOCAL-TALLOC smbtorture test that tests talloc behaviour for some common uses. (This used to be commit 911a8d590cb184bcb892810729955c2c4cf02550)
2004-09-28 05:42:02 +00:00
printf("Freeing p2\n");
talloc_free(p2);
r2742: - fixed a bug in talloc_unreference() - made the LOCAL-TALLOC smbtorture test much stricter, checking that block counts for every pointer are correct after every operation (This used to be commit 18d3e2647f0bedbba699d1ba2649c0cfe4526ef6)
2004-09-28 23:30:14 +00:00
talloc_report_full(root, stdout);
CHECK_BLOCKS(p1, 5);
CHECK_BLOCKS(p2, 1);
CHECK_BLOCKS(r1, 1);
r2709: finally solved the talloc reference problem. The problem was that the simple "uint_t ref_count;" in a talloc chunk did not give enough information. It told us that a pointer was referenced more than once, but it didn't say who it was referenced by. This means that when the pointer was freed we had no sane way to clean up the reference. I have now replaced ref_count with a "refs" list, which means that references point to the pointer, and the pointer has a linked list of references. So now we can cleanup from either direction without losing track of anything. I've also added a LOCAL-TALLOC smbtorture test that tests talloc behaviour for some common uses. (This used to be commit 911a8d590cb184bcb892810729955c2c4cf02550)
2004-09-28 05:42:02 +00:00
printf("Freeing p1\n");
talloc_free(p1);
r2742: - fixed a bug in talloc_unreference() - made the LOCAL-TALLOC smbtorture test much stricter, checking that block counts for every pointer are correct after every operation (This used to be commit 18d3e2647f0bedbba699d1ba2649c0cfe4526ef6)
2004-09-28 23:30:14 +00:00
talloc_report_full(root, stdout);
CHECK_BLOCKS(r1, 1);
r2709: finally solved the talloc reference problem. The problem was that the simple "uint_t ref_count;" in a talloc chunk did not give enough information. It told us that a pointer was referenced more than once, but it didn't say who it was referenced by. This means that when the pointer was freed we had no sane way to clean up the reference. I have now replaced ref_count with a "refs" list, which means that references point to the pointer, and the pointer has a linked list of references. So now we can cleanup from either direction without losing track of anything. I've also added a LOCAL-TALLOC smbtorture test that tests talloc behaviour for some common uses. (This used to be commit 911a8d590cb184bcb892810729955c2c4cf02550)
2004-09-28 05:42:02 +00:00
printf("Freeing r1\n");
talloc_free(r1);
talloc_report_full(NULL, stdout);
r3553: Allow talloc_reference to take a NULL pointer for the "ptr" argument. This allows potentially NULL pointers to be referenced, without an if () for every use. (previously, it would segfault). Update doco, and allow talloc_unlink to match. Andrew Bartlett (This used to be commit 59757c7f9d0e08e3acacfb3116f6205057d5b119)
2004-11-05 12:20:27 +00:00
printf("Testing NULL\n");
if (talloc_reference(root, NULL)) {
return False;
}
r2742: - fixed a bug in talloc_unreference() - made the LOCAL-TALLOC smbtorture test much stricter, checking that block counts for every pointer are correct after every operation (This used to be commit 18d3e2647f0bedbba699d1ba2649c0cfe4526ef6)
2004-09-28 23:30:14 +00:00
CHECK_BLOCKS(root, 1);
r2744: ben elliston taught me about gcov today, which allows you to measure the % coverage in terms of lines of code of a test suite. I thought a good first place to start with gcov was the talloc test suite. When I started the test suite covered about 60% of all lines of code in talloc.c, and now it covers about 99%. The only lines not covered are talloc corruption errors, as that would cause smb_panic() to fire. It will be interesting to try gcov on the main Samba test suite for smbd. We won't achieve 100% coverage, but it would be nice to get to 90% or more. I also modified the talloc.c sources to be able to be build standalone, using: gcc -c -D_STANDALONE_ -Iinlcude lib/talloc.c that should make it much easier to re-use talloc in other projects (This used to be commit 8d4dc99b82efdf24b6811851c7bdd4af5a4c52c9)
2004-09-29 06:31:14 +00:00
CHECK_SIZE(root, 0);
r2709: finally solved the talloc reference problem. The problem was that the simple "uint_t ref_count;" in a talloc chunk did not give enough information. It told us that a pointer was referenced more than once, but it didn't say who it was referenced by. This means that when the pointer was freed we had no sane way to clean up the reference. I have now replaced ref_count with a "refs" list, which means that references point to the pointer, and the pointer has a linked list of references. So now we can cleanup from either direction without losing track of anything. I've also added a LOCAL-TALLOC smbtorture test that tests talloc behaviour for some common uses. (This used to be commit 911a8d590cb184bcb892810729955c2c4cf02550)
2004-09-28 05:42:02 +00:00
r2742: - fixed a bug in talloc_unreference() - made the LOCAL-TALLOC smbtorture test much stricter, checking that block counts for every pointer are correct after every operation (This used to be commit 18d3e2647f0bedbba699d1ba2649c0cfe4526ef6)
2004-09-28 23:30:14 +00:00
talloc_free(root);
r2709: finally solved the talloc reference problem. The problem was that the simple "uint_t ref_count;" in a talloc chunk did not give enough information. It told us that a pointer was referenced more than once, but it didn't say who it was referenced by. This means that when the pointer was freed we had no sane way to clean up the reference. I have now replaced ref_count with a "refs" list, which means that references point to the pointer, and the pointer has a linked list of references. So now we can cleanup from either direction without losing track of anything. I've also added a LOCAL-TALLOC smbtorture test that tests talloc behaviour for some common uses. (This used to be commit 911a8d590cb184bcb892810729955c2c4cf02550)
2004-09-28 05:42:02 +00:00
return True;
}
/*
test references
*/
static BOOL test_ref2(void)
{
r2742: - fixed a bug in talloc_unreference() - made the LOCAL-TALLOC smbtorture test much stricter, checking that block counts for every pointer are correct after every operation (This used to be commit 18d3e2647f0bedbba699d1ba2649c0cfe4526ef6)
2004-09-28 23:30:14 +00:00
void *root, *p1, *p2, *ref, *r1;
r2709: finally solved the talloc reference problem. The problem was that the simple "uint_t ref_count;" in a talloc chunk did not give enough information. It told us that a pointer was referenced more than once, but it didn't say who it was referenced by. This means that when the pointer was freed we had no sane way to clean up the reference. I have now replaced ref_count with a "refs" list, which means that references point to the pointer, and the pointer has a linked list of references. So now we can cleanup from either direction without losing track of anything. I've also added a LOCAL-TALLOC smbtorture test that tests talloc behaviour for some common uses. (This used to be commit 911a8d590cb184bcb892810729955c2c4cf02550)
2004-09-28 05:42:02 +00:00
printf("TESTING DOUBLE REFERENCE FREE\n");
r2742: - fixed a bug in talloc_unreference() - made the LOCAL-TALLOC smbtorture test much stricter, checking that block counts for every pointer are correct after every operation (This used to be commit 18d3e2647f0bedbba699d1ba2649c0cfe4526ef6)
2004-09-28 23:30:14 +00:00
root = talloc_named_const(NULL, 0, "root");
p1 = talloc_named_const(root, 1, "p1");
r2709: finally solved the talloc reference problem. The problem was that the simple "uint_t ref_count;" in a talloc chunk did not give enough information. It told us that a pointer was referenced more than once, but it didn't say who it was referenced by. This means that when the pointer was freed we had no sane way to clean up the reference. I have now replaced ref_count with a "refs" list, which means that references point to the pointer, and the pointer has a linked list of references. So now we can cleanup from either direction without losing track of anything. I've also added a LOCAL-TALLOC smbtorture test that tests talloc behaviour for some common uses. (This used to be commit 911a8d590cb184bcb892810729955c2c4cf02550)
2004-09-28 05:42:02 +00:00
talloc_named_const(p1, 1, "x1");
talloc_named_const(p1, 1, "x2");
talloc_named_const(p1, 1, "x3");
p2 = talloc_named_const(p1, 1, "p2");
r2742: - fixed a bug in talloc_unreference() - made the LOCAL-TALLOC smbtorture test much stricter, checking that block counts for every pointer are correct after every operation (This used to be commit 18d3e2647f0bedbba699d1ba2649c0cfe4526ef6)
2004-09-28 23:30:14 +00:00
r1 = talloc_named_const(root, 1, "r1");
r2709: finally solved the talloc reference problem. The problem was that the simple "uint_t ref_count;" in a talloc chunk did not give enough information. It told us that a pointer was referenced more than once, but it didn't say who it was referenced by. This means that when the pointer was freed we had no sane way to clean up the reference. I have now replaced ref_count with a "refs" list, which means that references point to the pointer, and the pointer has a linked list of references. So now we can cleanup from either direction without losing track of anything. I've also added a LOCAL-TALLOC smbtorture test that tests talloc behaviour for some common uses. (This used to be commit 911a8d590cb184bcb892810729955c2c4cf02550)
2004-09-28 05:42:02 +00:00
ref = talloc_reference(r1, p2);
r2742: - fixed a bug in talloc_unreference() - made the LOCAL-TALLOC smbtorture test much stricter, checking that block counts for every pointer are correct after every operation (This used to be commit 18d3e2647f0bedbba699d1ba2649c0cfe4526ef6)
2004-09-28 23:30:14 +00:00
talloc_report_full(root, stdout);
CHECK_BLOCKS(p1, 5);
CHECK_BLOCKS(p2, 1);
CHECK_BLOCKS(r1, 2);
r2718: - added a talloc_unreference() function as requested by metze. - added documentation for talloc_unreference() - made the abandoned child logic in talloc_free() clearer and more consistent (This used to be commit a87584c8e3fb06cd3ff29a918f681b5c6c32b9ff)
2004-09-28 11:54:17 +00:00
r2709: finally solved the talloc reference problem. The problem was that the simple "uint_t ref_count;" in a talloc chunk did not give enough information. It told us that a pointer was referenced more than once, but it didn't say who it was referenced by. This means that when the pointer was freed we had no sane way to clean up the reference. I have now replaced ref_count with a "refs" list, which means that references point to the pointer, and the pointer has a linked list of references. So now we can cleanup from either direction without losing track of anything. I've also added a LOCAL-TALLOC smbtorture test that tests talloc behaviour for some common uses. (This used to be commit 911a8d590cb184bcb892810729955c2c4cf02550)
2004-09-28 05:42:02 +00:00
printf("Freeing ref\n");
talloc_free(ref);
r2742: - fixed a bug in talloc_unreference() - made the LOCAL-TALLOC smbtorture test much stricter, checking that block counts for every pointer are correct after every operation (This used to be commit 18d3e2647f0bedbba699d1ba2649c0cfe4526ef6)
2004-09-28 23:30:14 +00:00
talloc_report_full(root, stdout);
CHECK_BLOCKS(p1, 5);
CHECK_BLOCKS(p2, 1);
CHECK_BLOCKS(r1, 1);
r2718: - added a talloc_unreference() function as requested by metze. - added documentation for talloc_unreference() - made the abandoned child logic in talloc_free() clearer and more consistent (This used to be commit a87584c8e3fb06cd3ff29a918f681b5c6c32b9ff)
2004-09-28 11:54:17 +00:00
r2709: finally solved the talloc reference problem. The problem was that the simple "uint_t ref_count;" in a talloc chunk did not give enough information. It told us that a pointer was referenced more than once, but it didn't say who it was referenced by. This means that when the pointer was freed we had no sane way to clean up the reference. I have now replaced ref_count with a "refs" list, which means that references point to the pointer, and the pointer has a linked list of references. So now we can cleanup from either direction without losing track of anything. I've also added a LOCAL-TALLOC smbtorture test that tests talloc behaviour for some common uses. (This used to be commit 911a8d590cb184bcb892810729955c2c4cf02550)
2004-09-28 05:42:02 +00:00
printf("Freeing p2\n");
talloc_free(p2);
r2742: - fixed a bug in talloc_unreference() - made the LOCAL-TALLOC smbtorture test much stricter, checking that block counts for every pointer are correct after every operation (This used to be commit 18d3e2647f0bedbba699d1ba2649c0cfe4526ef6)
2004-09-28 23:30:14 +00:00
talloc_report_full(root, stdout);
CHECK_BLOCKS(p1, 4);
CHECK_BLOCKS(r1, 1);
r2718: - added a talloc_unreference() function as requested by metze. - added documentation for talloc_unreference() - made the abandoned child logic in talloc_free() clearer and more consistent (This used to be commit a87584c8e3fb06cd3ff29a918f681b5c6c32b9ff)
2004-09-28 11:54:17 +00:00
r2709: finally solved the talloc reference problem. The problem was that the simple "uint_t ref_count;" in a talloc chunk did not give enough information. It told us that a pointer was referenced more than once, but it didn't say who it was referenced by. This means that when the pointer was freed we had no sane way to clean up the reference. I have now replaced ref_count with a "refs" list, which means that references point to the pointer, and the pointer has a linked list of references. So now we can cleanup from either direction without losing track of anything. I've also added a LOCAL-TALLOC smbtorture test that tests talloc behaviour for some common uses. (This used to be commit 911a8d590cb184bcb892810729955c2c4cf02550)
2004-09-28 05:42:02 +00:00
printf("Freeing p1\n");
talloc_free(p1);
r2742: - fixed a bug in talloc_unreference() - made the LOCAL-TALLOC smbtorture test much stricter, checking that block counts for every pointer are correct after every operation (This used to be commit 18d3e2647f0bedbba699d1ba2649c0cfe4526ef6)
2004-09-28 23:30:14 +00:00
talloc_report_full(root, stdout);
CHECK_BLOCKS(r1, 1);
r2718: - added a talloc_unreference() function as requested by metze. - added documentation for talloc_unreference() - made the abandoned child logic in talloc_free() clearer and more consistent (This used to be commit a87584c8e3fb06cd3ff29a918f681b5c6c32b9ff)
2004-09-28 11:54:17 +00:00
r2709: finally solved the talloc reference problem. The problem was that the simple "uint_t ref_count;" in a talloc chunk did not give enough information. It told us that a pointer was referenced more than once, but it didn't say who it was referenced by. This means that when the pointer was freed we had no sane way to clean up the reference. I have now replaced ref_count with a "refs" list, which means that references point to the pointer, and the pointer has a linked list of references. So now we can cleanup from either direction without losing track of anything. I've also added a LOCAL-TALLOC smbtorture test that tests talloc behaviour for some common uses. (This used to be commit 911a8d590cb184bcb892810729955c2c4cf02550)
2004-09-28 05:42:02 +00:00
printf("Freeing r1\n");
talloc_free(r1);
r2742: - fixed a bug in talloc_unreference() - made the LOCAL-TALLOC smbtorture test much stricter, checking that block counts for every pointer are correct after every operation (This used to be commit 18d3e2647f0bedbba699d1ba2649c0cfe4526ef6)
2004-09-28 23:30:14 +00:00
talloc_report_full(root, stdout);
r2709: finally solved the talloc reference problem. The problem was that the simple "uint_t ref_count;" in a talloc chunk did not give enough information. It told us that a pointer was referenced more than once, but it didn't say who it was referenced by. This means that when the pointer was freed we had no sane way to clean up the reference. I have now replaced ref_count with a "refs" list, which means that references point to the pointer, and the pointer has a linked list of references. So now we can cleanup from either direction without losing track of anything. I've also added a LOCAL-TALLOC smbtorture test that tests talloc behaviour for some common uses. (This used to be commit 911a8d590cb184bcb892810729955c2c4cf02550)
2004-09-28 05:42:02 +00:00
r2744: ben elliston taught me about gcov today, which allows you to measure the % coverage in terms of lines of code of a test suite. I thought a good first place to start with gcov was the talloc test suite. When I started the test suite covered about 60% of all lines of code in talloc.c, and now it covers about 99%. The only lines not covered are talloc corruption errors, as that would cause smb_panic() to fire. It will be interesting to try gcov on the main Samba test suite for smbd. We won't achieve 100% coverage, but it would be nice to get to 90% or more. I also modified the talloc.c sources to be able to be build standalone, using: gcc -c -D_STANDALONE_ -Iinlcude lib/talloc.c that should make it much easier to re-use talloc in other projects (This used to be commit 8d4dc99b82efdf24b6811851c7bdd4af5a4c52c9)
2004-09-29 06:31:14 +00:00
CHECK_SIZE(root, 0);
r2718: - added a talloc_unreference() function as requested by metze. - added documentation for talloc_unreference() - made the abandoned child logic in talloc_free() clearer and more consistent (This used to be commit a87584c8e3fb06cd3ff29a918f681b5c6c32b9ff)
2004-09-28 11:54:17 +00:00
r2742: - fixed a bug in talloc_unreference() - made the LOCAL-TALLOC smbtorture test much stricter, checking that block counts for every pointer are correct after every operation (This used to be commit 18d3e2647f0bedbba699d1ba2649c0cfe4526ef6)
2004-09-28 23:30:14 +00:00
talloc_free(root);
r2718: - added a talloc_unreference() function as requested by metze. - added documentation for talloc_unreference() - made the abandoned child logic in talloc_free() clearer and more consistent (This used to be commit a87584c8e3fb06cd3ff29a918f681b5c6c32b9ff)
2004-09-28 11:54:17 +00:00
return True;
}
/*
test references
*/
static BOOL test_ref3(void)
{
r2742: - fixed a bug in talloc_unreference() - made the LOCAL-TALLOC smbtorture test much stricter, checking that block counts for every pointer are correct after every operation (This used to be commit 18d3e2647f0bedbba699d1ba2649c0cfe4526ef6)
2004-09-28 23:30:14 +00:00
void *root, *p1, *p2, *ref, *r1;
r2718: - added a talloc_unreference() function as requested by metze. - added documentation for talloc_unreference() - made the abandoned child logic in talloc_free() clearer and more consistent (This used to be commit a87584c8e3fb06cd3ff29a918f681b5c6c32b9ff)
2004-09-28 11:54:17 +00:00
printf("TESTING PARENT REFERENCE FREE\n");
r2742: - fixed a bug in talloc_unreference() - made the LOCAL-TALLOC smbtorture test much stricter, checking that block counts for every pointer are correct after every operation (This used to be commit 18d3e2647f0bedbba699d1ba2649c0cfe4526ef6)
2004-09-28 23:30:14 +00:00
root = talloc_named_const(NULL, 0, "root");
p1 = talloc_named_const(root, 1, "p1");
p2 = talloc_named_const(root, 1, "p2");
r2718: - added a talloc_unreference() function as requested by metze. - added documentation for talloc_unreference() - made the abandoned child logic in talloc_free() clearer and more consistent (This used to be commit a87584c8e3fb06cd3ff29a918f681b5c6c32b9ff)
2004-09-28 11:54:17 +00:00
r1 = talloc_named_const(p1, 1, "r1");
ref = talloc_reference(p2, r1);
r2742: - fixed a bug in talloc_unreference() - made the LOCAL-TALLOC smbtorture test much stricter, checking that block counts for every pointer are correct after every operation (This used to be commit 18d3e2647f0bedbba699d1ba2649c0cfe4526ef6)
2004-09-28 23:30:14 +00:00
talloc_report_full(root, stdout);
r2718: - added a talloc_unreference() function as requested by metze. - added documentation for talloc_unreference() - made the abandoned child logic in talloc_free() clearer and more consistent (This used to be commit a87584c8e3fb06cd3ff29a918f681b5c6c32b9ff)
2004-09-28 11:54:17 +00:00
r2742: - fixed a bug in talloc_unreference() - made the LOCAL-TALLOC smbtorture test much stricter, checking that block counts for every pointer are correct after every operation (This used to be commit 18d3e2647f0bedbba699d1ba2649c0cfe4526ef6)
2004-09-28 23:30:14 +00:00
CHECK_BLOCKS(p1, 2);
CHECK_BLOCKS(p2, 2);
CHECK_BLOCKS(r1, 1);
r2718: - added a talloc_unreference() function as requested by metze. - added documentation for talloc_unreference() - made the abandoned child logic in talloc_free() clearer and more consistent (This used to be commit a87584c8e3fb06cd3ff29a918f681b5c6c32b9ff)
2004-09-28 11:54:17 +00:00
printf("Freeing p1\n");
talloc_free(p1);
r2742: - fixed a bug in talloc_unreference() - made the LOCAL-TALLOC smbtorture test much stricter, checking that block counts for every pointer are correct after every operation (This used to be commit 18d3e2647f0bedbba699d1ba2649c0cfe4526ef6)
2004-09-28 23:30:14 +00:00
talloc_report_full(root, stdout);
CHECK_BLOCKS(p2, 2);
CHECK_BLOCKS(r1, 1);
r2718: - added a talloc_unreference() function as requested by metze. - added documentation for talloc_unreference() - made the abandoned child logic in talloc_free() clearer and more consistent (This used to be commit a87584c8e3fb06cd3ff29a918f681b5c6c32b9ff)
2004-09-28 11:54:17 +00:00
printf("Freeing p2\n");
talloc_free(p2);
r2742: - fixed a bug in talloc_unreference() - made the LOCAL-TALLOC smbtorture test much stricter, checking that block counts for every pointer are correct after every operation (This used to be commit 18d3e2647f0bedbba699d1ba2649c0cfe4526ef6)
2004-09-28 23:30:14 +00:00
talloc_report_full(root, stdout);
r2718: - added a talloc_unreference() function as requested by metze. - added documentation for talloc_unreference() - made the abandoned child logic in talloc_free() clearer and more consistent (This used to be commit a87584c8e3fb06cd3ff29a918f681b5c6c32b9ff)
2004-09-28 11:54:17 +00:00
r2744: ben elliston taught me about gcov today, which allows you to measure the % coverage in terms of lines of code of a test suite. I thought a good first place to start with gcov was the talloc test suite. When I started the test suite covered about 60% of all lines of code in talloc.c, and now it covers about 99%. The only lines not covered are talloc corruption errors, as that would cause smb_panic() to fire. It will be interesting to try gcov on the main Samba test suite for smbd. We won't achieve 100% coverage, but it would be nice to get to 90% or more. I also modified the talloc.c sources to be able to be build standalone, using: gcc -c -D_STANDALONE_ -Iinlcude lib/talloc.c that should make it much easier to re-use talloc in other projects (This used to be commit 8d4dc99b82efdf24b6811851c7bdd4af5a4c52c9)
2004-09-29 06:31:14 +00:00
CHECK_SIZE(root, 0);
r2718: - added a talloc_unreference() function as requested by metze. - added documentation for talloc_unreference() - made the abandoned child logic in talloc_free() clearer and more consistent (This used to be commit a87584c8e3fb06cd3ff29a918f681b5c6c32b9ff)
2004-09-28 11:54:17 +00:00
r2742: - fixed a bug in talloc_unreference() - made the LOCAL-TALLOC smbtorture test much stricter, checking that block counts for every pointer are correct after every operation (This used to be commit 18d3e2647f0bedbba699d1ba2649c0cfe4526ef6)
2004-09-28 23:30:14 +00:00
talloc_free(root);
r2718: - added a talloc_unreference() function as requested by metze. - added documentation for talloc_unreference() - made the abandoned child logic in talloc_free() clearer and more consistent (This used to be commit a87584c8e3fb06cd3ff29a918f681b5c6c32b9ff)
2004-09-28 11:54:17 +00:00
return True;
}
/*
test references
*/
static BOOL test_ref4(void)
{
r2742: - fixed a bug in talloc_unreference() - made the LOCAL-TALLOC smbtorture test much stricter, checking that block counts for every pointer are correct after every operation (This used to be commit 18d3e2647f0bedbba699d1ba2649c0cfe4526ef6)
2004-09-28 23:30:14 +00:00
void *root, *p1, *p2, *ref, *r1;
r2718: - added a talloc_unreference() function as requested by metze. - added documentation for talloc_unreference() - made the abandoned child logic in talloc_free() clearer and more consistent (This used to be commit a87584c8e3fb06cd3ff29a918f681b5c6c32b9ff)
2004-09-28 11:54:17 +00:00
printf("TESTING REFERRER REFERENCE FREE\n");
r2742: - fixed a bug in talloc_unreference() - made the LOCAL-TALLOC smbtorture test much stricter, checking that block counts for every pointer are correct after every operation (This used to be commit 18d3e2647f0bedbba699d1ba2649c0cfe4526ef6)
2004-09-28 23:30:14 +00:00
root = talloc_named_const(NULL, 0, "root");
p1 = talloc_named_const(root, 1, "p1");
r2718: - added a talloc_unreference() function as requested by metze. - added documentation for talloc_unreference() - made the abandoned child logic in talloc_free() clearer and more consistent (This used to be commit a87584c8e3fb06cd3ff29a918f681b5c6c32b9ff)
2004-09-28 11:54:17 +00:00
talloc_named_const(p1, 1, "x1");
talloc_named_const(p1, 1, "x2");
talloc_named_const(p1, 1, "x3");
p2 = talloc_named_const(p1, 1, "p2");
r2742: - fixed a bug in talloc_unreference() - made the LOCAL-TALLOC smbtorture test much stricter, checking that block counts for every pointer are correct after every operation (This used to be commit 18d3e2647f0bedbba699d1ba2649c0cfe4526ef6)
2004-09-28 23:30:14 +00:00
r1 = talloc_named_const(root, 1, "r1");
r2718: - added a talloc_unreference() function as requested by metze. - added documentation for talloc_unreference() - made the abandoned child logic in talloc_free() clearer and more consistent (This used to be commit a87584c8e3fb06cd3ff29a918f681b5c6c32b9ff)
2004-09-28 11:54:17 +00:00
ref = talloc_reference(r1, p2);
r2742: - fixed a bug in talloc_unreference() - made the LOCAL-TALLOC smbtorture test much stricter, checking that block counts for every pointer are correct after every operation (This used to be commit 18d3e2647f0bedbba699d1ba2649c0cfe4526ef6)
2004-09-28 23:30:14 +00:00
talloc_report_full(root, stdout);
CHECK_BLOCKS(p1, 5);
CHECK_BLOCKS(p2, 1);
CHECK_BLOCKS(r1, 2);
r2718: - added a talloc_unreference() function as requested by metze. - added documentation for talloc_unreference() - made the abandoned child logic in talloc_free() clearer and more consistent (This used to be commit a87584c8e3fb06cd3ff29a918f681b5c6c32b9ff)
2004-09-28 11:54:17 +00:00
printf("Freeing r1\n");
talloc_free(r1);
r2742: - fixed a bug in talloc_unreference() - made the LOCAL-TALLOC smbtorture test much stricter, checking that block counts for every pointer are correct after every operation (This used to be commit 18d3e2647f0bedbba699d1ba2649c0cfe4526ef6)
2004-09-28 23:30:14 +00:00
talloc_report_full(root, stdout);
CHECK_BLOCKS(p1, 5);
CHECK_BLOCKS(p2, 1);
r2718: - added a talloc_unreference() function as requested by metze. - added documentation for talloc_unreference() - made the abandoned child logic in talloc_free() clearer and more consistent (This used to be commit a87584c8e3fb06cd3ff29a918f681b5c6c32b9ff)
2004-09-28 11:54:17 +00:00
printf("Freeing p2\n");
talloc_free(p2);
r2742: - fixed a bug in talloc_unreference() - made the LOCAL-TALLOC smbtorture test much stricter, checking that block counts for every pointer are correct after every operation (This used to be commit 18d3e2647f0bedbba699d1ba2649c0cfe4526ef6)
2004-09-28 23:30:14 +00:00
talloc_report_full(root, stdout);
CHECK_BLOCKS(p1, 4);
r2718: - added a talloc_unreference() function as requested by metze. - added documentation for talloc_unreference() - made the abandoned child logic in talloc_free() clearer and more consistent (This used to be commit a87584c8e3fb06cd3ff29a918f681b5c6c32b9ff)
2004-09-28 11:54:17 +00:00
printf("Freeing p1\n");
talloc_free(p1);
r2742: - fixed a bug in talloc_unreference() - made the LOCAL-TALLOC smbtorture test much stricter, checking that block counts for every pointer are correct after every operation (This used to be commit 18d3e2647f0bedbba699d1ba2649c0cfe4526ef6)
2004-09-28 23:30:14 +00:00
talloc_report_full(root, stdout);
r2718: - added a talloc_unreference() function as requested by metze. - added documentation for talloc_unreference() - made the abandoned child logic in talloc_free() clearer and more consistent (This used to be commit a87584c8e3fb06cd3ff29a918f681b5c6c32b9ff)
2004-09-28 11:54:17 +00:00
r2744: ben elliston taught me about gcov today, which allows you to measure the % coverage in terms of lines of code of a test suite. I thought a good first place to start with gcov was the talloc test suite. When I started the test suite covered about 60% of all lines of code in talloc.c, and now it covers about 99%. The only lines not covered are talloc corruption errors, as that would cause smb_panic() to fire. It will be interesting to try gcov on the main Samba test suite for smbd. We won't achieve 100% coverage, but it would be nice to get to 90% or more. I also modified the talloc.c sources to be able to be build standalone, using: gcc -c -D_STANDALONE_ -Iinlcude lib/talloc.c that should make it much easier to re-use talloc in other projects (This used to be commit 8d4dc99b82efdf24b6811851c7bdd4af5a4c52c9)
2004-09-29 06:31:14 +00:00
CHECK_SIZE(root, 0);
r2718: - added a talloc_unreference() function as requested by metze. - added documentation for talloc_unreference() - made the abandoned child logic in talloc_free() clearer and more consistent (This used to be commit a87584c8e3fb06cd3ff29a918f681b5c6c32b9ff)
2004-09-28 11:54:17 +00:00
r2742: - fixed a bug in talloc_unreference() - made the LOCAL-TALLOC smbtorture test much stricter, checking that block counts for every pointer are correct after every operation (This used to be commit 18d3e2647f0bedbba699d1ba2649c0cfe4526ef6)
2004-09-28 23:30:14 +00:00
talloc_free(root);
r2718: - added a talloc_unreference() function as requested by metze. - added documentation for talloc_unreference() - made the abandoned child logic in talloc_free() clearer and more consistent (This used to be commit a87584c8e3fb06cd3ff29a918f681b5c6c32b9ff)
2004-09-28 11:54:17 +00:00
return True;
}
/*
test references
*/
r2791: got rid of talloc_unreference() and instead created talloc_unlink(), which is much clearer and simpler to use. It removes a specific parent from a pointer, no matter whether that parent is a "reference" or a direct parent. This gives complete control over the free process. (This used to be commit 6c563887f1b9b8c842309a523e88b6f2a32db10f)
2004-10-03 00:04:30 +00:00
static BOOL test_unlink1(void)
r2718: - added a talloc_unreference() function as requested by metze. - added documentation for talloc_unreference() - made the abandoned child logic in talloc_free() clearer and more consistent (This used to be commit a87584c8e3fb06cd3ff29a918f681b5c6c32b9ff)
2004-09-28 11:54:17 +00:00
{
r2742: - fixed a bug in talloc_unreference() - made the LOCAL-TALLOC smbtorture test much stricter, checking that block counts for every pointer are correct after every operation (This used to be commit 18d3e2647f0bedbba699d1ba2649c0cfe4526ef6)
2004-09-28 23:30:14 +00:00
void *root, *p1, *p2, *ref, *r1;
r2718: - added a talloc_unreference() function as requested by metze. - added documentation for talloc_unreference() - made the abandoned child logic in talloc_free() clearer and more consistent (This used to be commit a87584c8e3fb06cd3ff29a918f681b5c6c32b9ff)
2004-09-28 11:54:17 +00:00
r2791: got rid of talloc_unreference() and instead created talloc_unlink(), which is much clearer and simpler to use. It removes a specific parent from a pointer, no matter whether that parent is a "reference" or a direct parent. This gives complete control over the free process. (This used to be commit 6c563887f1b9b8c842309a523e88b6f2a32db10f)
2004-10-03 00:04:30 +00:00
printf("TESTING UNLINK\n");
r2718: - added a talloc_unreference() function as requested by metze. - added documentation for talloc_unreference() - made the abandoned child logic in talloc_free() clearer and more consistent (This used to be commit a87584c8e3fb06cd3ff29a918f681b5c6c32b9ff)
2004-09-28 11:54:17 +00:00
r2742: - fixed a bug in talloc_unreference() - made the LOCAL-TALLOC smbtorture test much stricter, checking that block counts for every pointer are correct after every operation (This used to be commit 18d3e2647f0bedbba699d1ba2649c0cfe4526ef6)
2004-09-28 23:30:14 +00:00
root = talloc_named_const(NULL, 0, "root");
p1 = talloc_named_const(root, 1, "p1");
r2718: - added a talloc_unreference() function as requested by metze. - added documentation for talloc_unreference() - made the abandoned child logic in talloc_free() clearer and more consistent (This used to be commit a87584c8e3fb06cd3ff29a918f681b5c6c32b9ff)
2004-09-28 11:54:17 +00:00
talloc_named_const(p1, 1, "x1");
talloc_named_const(p1, 1, "x2");
talloc_named_const(p1, 1, "x3");
p2 = talloc_named_const(p1, 1, "p2");
r1 = talloc_named_const(p1, 1, "r1");
ref = talloc_reference(r1, p2);
r2742: - fixed a bug in talloc_unreference() - made the LOCAL-TALLOC smbtorture test much stricter, checking that block counts for every pointer are correct after every operation (This used to be commit 18d3e2647f0bedbba699d1ba2649c0cfe4526ef6)
2004-09-28 23:30:14 +00:00
talloc_report_full(root, stdout);
CHECK_BLOCKS(p1, 7);
CHECK_BLOCKS(p2, 1);
CHECK_BLOCKS(r1, 2);
r2718: - added a talloc_unreference() function as requested by metze. - added documentation for talloc_unreference() - made the abandoned child logic in talloc_free() clearer and more consistent (This used to be commit a87584c8e3fb06cd3ff29a918f681b5c6c32b9ff)
2004-09-28 11:54:17 +00:00
printf("Unreferencing r1\n");
r2791: got rid of talloc_unreference() and instead created talloc_unlink(), which is much clearer and simpler to use. It removes a specific parent from a pointer, no matter whether that parent is a "reference" or a direct parent. This gives complete control over the free process. (This used to be commit 6c563887f1b9b8c842309a523e88b6f2a32db10f)
2004-10-03 00:04:30 +00:00
talloc_unlink(r1, p2);
r2742: - fixed a bug in talloc_unreference() - made the LOCAL-TALLOC smbtorture test much stricter, checking that block counts for every pointer are correct after every operation (This used to be commit 18d3e2647f0bedbba699d1ba2649c0cfe4526ef6)
2004-09-28 23:30:14 +00:00
talloc_report_full(root, stdout);
CHECK_BLOCKS(p1, 6);
CHECK_BLOCKS(p2, 1);
CHECK_BLOCKS(r1, 1);
r2718: - added a talloc_unreference() function as requested by metze. - added documentation for talloc_unreference() - made the abandoned child logic in talloc_free() clearer and more consistent (This used to be commit a87584c8e3fb06cd3ff29a918f681b5c6c32b9ff)
2004-09-28 11:54:17 +00:00
printf("Freeing p1\n");
talloc_free(p1);
r2742: - fixed a bug in talloc_unreference() - made the LOCAL-TALLOC smbtorture test much stricter, checking that block counts for every pointer are correct after every operation (This used to be commit 18d3e2647f0bedbba699d1ba2649c0cfe4526ef6)
2004-09-28 23:30:14 +00:00
talloc_report_full(root, stdout);
r2718: - added a talloc_unreference() function as requested by metze. - added documentation for talloc_unreference() - made the abandoned child logic in talloc_free() clearer and more consistent (This used to be commit a87584c8e3fb06cd3ff29a918f681b5c6c32b9ff)
2004-09-28 11:54:17 +00:00
r2744: ben elliston taught me about gcov today, which allows you to measure the % coverage in terms of lines of code of a test suite. I thought a good first place to start with gcov was the talloc test suite. When I started the test suite covered about 60% of all lines of code in talloc.c, and now it covers about 99%. The only lines not covered are talloc corruption errors, as that would cause smb_panic() to fire. It will be interesting to try gcov on the main Samba test suite for smbd. We won't achieve 100% coverage, but it would be nice to get to 90% or more. I also modified the talloc.c sources to be able to be build standalone, using: gcc -c -D_STANDALONE_ -Iinlcude lib/talloc.c that should make it much easier to re-use talloc in other projects (This used to be commit 8d4dc99b82efdf24b6811851c7bdd4af5a4c52c9)
2004-09-29 06:31:14 +00:00
CHECK_SIZE(root, 0);
talloc_free(root);
return True;
}
static int fail_destructor(void *ptr)
{
return -1;
}
/*
miscellaneous tests to try to get a higher test coverage percentage
*/
static BOOL test_misc(void)
{
void *root, *p1;
char *p2;
double *d;
printf("TESTING MISCELLANEOUS\n");
r4547: - added talloc_new(ctx) macro that is a neater form of the common talloc(ctx, 0) call. - cleaned up some talloc usage in various files I'd like to get to the point that we have no calls to talloc(), at which point we will rename talloc_p() to talloc(), to encourage everyone to use the typesafe functions. (This used to be commit e6c81d7c9f8a6938947d3c1c8a971a0d6d50b67a)
2005-01-06 02:32:43 +00:00
root = talloc_new(NULL);
r2744: ben elliston taught me about gcov today, which allows you to measure the % coverage in terms of lines of code of a test suite. I thought a good first place to start with gcov was the talloc test suite. When I started the test suite covered about 60% of all lines of code in talloc.c, and now it covers about 99%. The only lines not covered are talloc corruption errors, as that would cause smb_panic() to fire. It will be interesting to try gcov on the main Samba test suite for smbd. We won't achieve 100% coverage, but it would be nice to get to 90% or more. I also modified the talloc.c sources to be able to be build standalone, using: gcc -c -D_STANDALONE_ -Iinlcude lib/talloc.c that should make it much easier to re-use talloc in other projects (This used to be commit 8d4dc99b82efdf24b6811851c7bdd4af5a4c52c9)
2004-09-29 06:31:14 +00:00
r4549: got rid of a lot more uses of plain talloc(), instead using talloc_size() or talloc_array_p() where appropriate. also fixed a memory leak in pvfs_copy_file() (failed to free a memory context) (This used to be commit 89b74b53546e1570b11b3702f40bee58aed8c503)
2005-01-06 03:06:58 +00:00
p1 = talloc_size(root, 0x7fffffff);
r2744: ben elliston taught me about gcov today, which allows you to measure the % coverage in terms of lines of code of a test suite. I thought a good first place to start with gcov was the talloc test suite. When I started the test suite covered about 60% of all lines of code in talloc.c, and now it covers about 99%. The only lines not covered are talloc corruption errors, as that would cause smb_panic() to fire. It will be interesting to try gcov on the main Samba test suite for smbd. We won't achieve 100% coverage, but it would be nice to get to 90% or more. I also modified the talloc.c sources to be able to be build standalone, using: gcc -c -D_STANDALONE_ -Iinlcude lib/talloc.c that should make it much easier to re-use talloc in other projects (This used to be commit 8d4dc99b82efdf24b6811851c7bdd4af5a4c52c9)
2004-09-29 06:31:14 +00:00
if (p1) {
printf("failed: large talloc allowed\n");
return False;
}
p1 = talloc_strdup(root, "foo");
talloc_increase_ref_count(p1);
talloc_increase_ref_count(p1);
talloc_increase_ref_count(p1);
CHECK_BLOCKS(p1, 1);
CHECK_BLOCKS(root, 2);
talloc_free(p1);
CHECK_BLOCKS(p1, 1);
CHECK_BLOCKS(root, 2);
r2791: got rid of talloc_unreference() and instead created talloc_unlink(), which is much clearer and simpler to use. It removes a specific parent from a pointer, no matter whether that parent is a "reference" or a direct parent. This gives complete control over the free process. (This used to be commit 6c563887f1b9b8c842309a523e88b6f2a32db10f)
2004-10-03 00:04:30 +00:00
talloc_unlink(NULL, p1);
r2744: ben elliston taught me about gcov today, which allows you to measure the % coverage in terms of lines of code of a test suite. I thought a good first place to start with gcov was the talloc test suite. When I started the test suite covered about 60% of all lines of code in talloc.c, and now it covers about 99%. The only lines not covered are talloc corruption errors, as that would cause smb_panic() to fire. It will be interesting to try gcov on the main Samba test suite for smbd. We won't achieve 100% coverage, but it would be nice to get to 90% or more. I also modified the talloc.c sources to be able to be build standalone, using: gcc -c -D_STANDALONE_ -Iinlcude lib/talloc.c that should make it much easier to re-use talloc in other projects (This used to be commit 8d4dc99b82efdf24b6811851c7bdd4af5a4c52c9)
2004-09-29 06:31:14 +00:00
CHECK_BLOCKS(p1, 1);
CHECK_BLOCKS(root, 2);
r2791: got rid of talloc_unreference() and instead created talloc_unlink(), which is much clearer and simpler to use. It removes a specific parent from a pointer, no matter whether that parent is a "reference" or a direct parent. This gives complete control over the free process. (This used to be commit 6c563887f1b9b8c842309a523e88b6f2a32db10f)
2004-10-03 00:04:30 +00:00
p2 = talloc_strdup(p1, "foo");
if (talloc_unlink(root, p2) != -1) {
printf("failed: talloc_unlink() of non-reference context should return -1\n");
return False;
}
if (talloc_unlink(p1, p2) != 0) {
printf("failed: talloc_unlink() of parent should succeed\n");
r2744: ben elliston taught me about gcov today, which allows you to measure the % coverage in terms of lines of code of a test suite. I thought a good first place to start with gcov was the talloc test suite. When I started the test suite covered about 60% of all lines of code in talloc.c, and now it covers about 99%. The only lines not covered are talloc corruption errors, as that would cause smb_panic() to fire. It will be interesting to try gcov on the main Samba test suite for smbd. We won't achieve 100% coverage, but it would be nice to get to 90% or more. I also modified the talloc.c sources to be able to be build standalone, using: gcc -c -D_STANDALONE_ -Iinlcude lib/talloc.c that should make it much easier to re-use talloc in other projects (This used to be commit 8d4dc99b82efdf24b6811851c7bdd4af5a4c52c9)
2004-09-29 06:31:14 +00:00
return False;
}
talloc_free(p1);
CHECK_BLOCKS(p1, 1);
CHECK_BLOCKS(root, 2);
talloc_set_name(p1, "my name is %s", "foo");
if (strcmp(talloc_get_name(p1), "my name is foo") != 0) {
printf("failed: wrong name after talloc_set_name\n");
return False;
}
CHECK_BLOCKS(p1, 2);
CHECK_BLOCKS(root, 3);
talloc_set_name_const(p1, NULL);
if (strcmp(talloc_get_name(p1), "UNNAMED") != 0) {
printf("failed: wrong name after talloc_set_name(NULL)\n");
return False;
}
CHECK_BLOCKS(p1, 2);
CHECK_BLOCKS(root, 3);
if (talloc_free(NULL) != -1) {
printf("talloc_free(NULL) should give -1\n");
return False;
}
talloc_set_destructor(p1, fail_destructor);
if (talloc_free(p1) != -1) {
printf("Failed destructor should cause talloc_free to fail\n");
return False;
}
talloc_set_destructor(p1, NULL);
talloc_report(root, stdout);
r4591: - converted the other _p talloc functions to not need _p - added #if TALLOC_DEPRECATED around the _p functions - fixes the code that broke from the above while doing this I fixed quite a number of places that were incorrectly using the non type-safe talloc functions to use the type safe ones. Some were even doing multiplies for array allocation, which is potentially unsafe. (This used to be commit 6e7754abd0c225527fb38363996a6e241b87b37e)
2005-01-07 04:39:16 +00:00
p2 = talloc_zero_size(p1, 20);
r2744: ben elliston taught me about gcov today, which allows you to measure the % coverage in terms of lines of code of a test suite. I thought a good first place to start with gcov was the talloc test suite. When I started the test suite covered about 60% of all lines of code in talloc.c, and now it covers about 99%. The only lines not covered are talloc corruption errors, as that would cause smb_panic() to fire. It will be interesting to try gcov on the main Samba test suite for smbd. We won't achieve 100% coverage, but it would be nice to get to 90% or more. I also modified the talloc.c sources to be able to be build standalone, using: gcc -c -D_STANDALONE_ -Iinlcude lib/talloc.c that should make it much easier to re-use talloc in other projects (This used to be commit 8d4dc99b82efdf24b6811851c7bdd4af5a4c52c9)
2004-09-29 06:31:14 +00:00
if (p2[19] != 0) {
printf("Failed to give zero memory\n");
return False;
}
talloc_free(p2);
if (talloc_strdup(root, NULL) != NULL) {
printf("failed: strdup on NULL should give NULL\n");
return False;
}
p2 = talloc_strndup(p1, "foo", 2);
if (strcmp("fo", p2) != 0) {
printf("failed: strndup doesn't work\n");
return False;
}
p2 = talloc_asprintf_append(p2, "o%c", 'd');
if (strcmp("food", p2) != 0) {
printf("failed: talloc_asprintf_append doesn't work\n");
return False;
}
CHECK_BLOCKS(p2, 1);
CHECK_BLOCKS(p1, 3);
p2 = talloc_asprintf_append(NULL, "hello %s", "world");
if (strcmp("hello world", p2) != 0) {
printf("failed: talloc_asprintf_append doesn't work\n");
return False;
}
CHECK_BLOCKS(p2, 1);
CHECK_BLOCKS(p1, 3);
talloc_free(p2);
r4593: don't use the _p function in the testsuite, as when built standalone it doesn't use TALLOC_DEPRECATED (This used to be commit 2fe0e2528f14627832942f6404a4b1be4b556c97)
2005-01-07 04:47:58 +00:00
d = talloc_array(p1, double, 0x20000000);
r2744: ben elliston taught me about gcov today, which allows you to measure the % coverage in terms of lines of code of a test suite. I thought a good first place to start with gcov was the talloc test suite. When I started the test suite covered about 60% of all lines of code in talloc.c, and now it covers about 99%. The only lines not covered are talloc corruption errors, as that would cause smb_panic() to fire. It will be interesting to try gcov on the main Samba test suite for smbd. We won't achieve 100% coverage, but it would be nice to get to 90% or more. I also modified the talloc.c sources to be able to be build standalone, using: gcc -c -D_STANDALONE_ -Iinlcude lib/talloc.c that should make it much easier to re-use talloc in other projects (This used to be commit 8d4dc99b82efdf24b6811851c7bdd4af5a4c52c9)
2004-09-29 06:31:14 +00:00
if (d) {
printf("failed: integer overflow not detected\n");
return False;
}
r4593: don't use the _p function in the testsuite, as when built standalone it doesn't use TALLOC_DEPRECATED (This used to be commit 2fe0e2528f14627832942f6404a4b1be4b556c97)
2005-01-07 04:47:58 +00:00
d = talloc_realloc(p1, d, double, 0x20000000);
r2744: ben elliston taught me about gcov today, which allows you to measure the % coverage in terms of lines of code of a test suite. I thought a good first place to start with gcov was the talloc test suite. When I started the test suite covered about 60% of all lines of code in talloc.c, and now it covers about 99%. The only lines not covered are talloc corruption errors, as that would cause smb_panic() to fire. It will be interesting to try gcov on the main Samba test suite for smbd. We won't achieve 100% coverage, but it would be nice to get to 90% or more. I also modified the talloc.c sources to be able to be build standalone, using: gcc -c -D_STANDALONE_ -Iinlcude lib/talloc.c that should make it much easier to re-use talloc in other projects (This used to be commit 8d4dc99b82efdf24b6811851c7bdd4af5a4c52c9)
2004-09-29 06:31:14 +00:00
if (d) {
printf("failed: integer overflow not detected\n");
return False;
}
talloc_free(p1);
CHECK_BLOCKS(root, 1);
r2791: got rid of talloc_unreference() and instead created talloc_unlink(), which is much clearer and simpler to use. It removes a specific parent from a pointer, no matter whether that parent is a "reference" or a direct parent. This gives complete control over the free process. (This used to be commit 6c563887f1b9b8c842309a523e88b6f2a32db10f)
2004-10-03 00:04:30 +00:00
p1 = talloc_named(root, 100, "%d bytes", 100);
CHECK_BLOCKS(p1, 2);
CHECK_BLOCKS(root, 3);
talloc_unlink(root, p1);
p1 = talloc_init("%d bytes", 200);
p2 = talloc_asprintf(p1, "my test '%s'", "string");
CHECK_BLOCKS(p1, 3);
CHECK_SIZE(p2, 17);
CHECK_BLOCKS(root, 1);
talloc_unlink(NULL, p1);
p1 = talloc_named_const(root, 10, "p1");
p2 = talloc_named_const(root, 20, "p2");
talloc_reference(p1, p2);
talloc_report_full(root, stdout);
talloc_unlink(root, p2);
talloc_report_full(root, stdout);
CHECK_BLOCKS(p2, 1);
CHECK_BLOCKS(p1, 2);
CHECK_BLOCKS(root, 3);
talloc_unlink(p1, p2);
talloc_unlink(root, p1);
p1 = talloc_named_const(root, 10, "p1");
p2 = talloc_named_const(root, 20, "p2");
talloc_reference(NULL, p2);
talloc_report_full(root, stdout);
talloc_unlink(root, p2);
talloc_report_full(root, stdout);
CHECK_BLOCKS(p2, 1);
CHECK_BLOCKS(p1, 1);
CHECK_BLOCKS(root, 2);
talloc_unlink(NULL, p2);
talloc_unlink(root, p1);
r3553: Allow talloc_reference to take a NULL pointer for the "ptr" argument. This allows potentially NULL pointers to be referenced, without an if () for every use. (previously, it would segfault). Update doco, and allow talloc_unlink to match. Andrew Bartlett (This used to be commit 59757c7f9d0e08e3acacfb3116f6205057d5b119)
2004-11-05 12:20:27 +00:00
/* Test that talloc_unlink is a no-op */
if (talloc_unlink(root, NULL) != -1) {
printf("failed: talloc_unlink(root, NULL) == -1\n");
return False;
}
r2791: got rid of talloc_unreference() and instead created talloc_unlink(), which is much clearer and simpler to use. It removes a specific parent from a pointer, no matter whether that parent is a "reference" or a direct parent. This gives complete control over the free process. (This used to be commit 6c563887f1b9b8c842309a523e88b6f2a32db10f)
2004-10-03 00:04:30 +00:00
r2744: ben elliston taught me about gcov today, which allows you to measure the % coverage in terms of lines of code of a test suite. I thought a good first place to start with gcov was the talloc test suite. When I started the test suite covered about 60% of all lines of code in talloc.c, and now it covers about 99%. The only lines not covered are talloc corruption errors, as that would cause smb_panic() to fire. It will be interesting to try gcov on the main Samba test suite for smbd. We won't achieve 100% coverage, but it would be nice to get to 90% or more. I also modified the talloc.c sources to be able to be build standalone, using: gcc -c -D_STANDALONE_ -Iinlcude lib/talloc.c that should make it much easier to re-use talloc in other projects (This used to be commit 8d4dc99b82efdf24b6811851c7bdd4af5a4c52c9)
2004-09-29 06:31:14 +00:00
talloc_report(root, stdout);
talloc_report(NULL, stdout);
CHECK_SIZE(root, 0);
talloc_free(root);
CHECK_SIZE(NULL, 0);
talloc_enable_leak_report();
talloc_enable_leak_report_full();
return True;
}
/*
test realloc
*/
static BOOL test_realloc(void)
{
void *root, *p1, *p2;
printf("TESTING REALLOC\n");
r4547: - added talloc_new(ctx) macro that is a neater form of the common talloc(ctx, 0) call. - cleaned up some talloc usage in various files I'd like to get to the point that we have no calls to talloc(), at which point we will rename talloc_p() to talloc(), to encourage everyone to use the typesafe functions. (This used to be commit e6c81d7c9f8a6938947d3c1c8a971a0d6d50b67a)
2005-01-06 02:32:43 +00:00
root = talloc_new(NULL);
r2744: ben elliston taught me about gcov today, which allows you to measure the % coverage in terms of lines of code of a test suite. I thought a good first place to start with gcov was the talloc test suite. When I started the test suite covered about 60% of all lines of code in talloc.c, and now it covers about 99%. The only lines not covered are talloc corruption errors, as that would cause smb_panic() to fire. It will be interesting to try gcov on the main Samba test suite for smbd. We won't achieve 100% coverage, but it would be nice to get to 90% or more. I also modified the talloc.c sources to be able to be build standalone, using: gcc -c -D_STANDALONE_ -Iinlcude lib/talloc.c that should make it much easier to re-use talloc in other projects (This used to be commit 8d4dc99b82efdf24b6811851c7bdd4af5a4c52c9)
2004-09-29 06:31:14 +00:00
r4549: got rid of a lot more uses of plain talloc(), instead using talloc_size() or talloc_array_p() where appropriate. also fixed a memory leak in pvfs_copy_file() (failed to free a memory context) (This used to be commit 89b74b53546e1570b11b3702f40bee58aed8c503)
2005-01-06 03:06:58 +00:00
p1 = talloc_size(root, 10);
r2744: ben elliston taught me about gcov today, which allows you to measure the % coverage in terms of lines of code of a test suite. I thought a good first place to start with gcov was the talloc test suite. When I started the test suite covered about 60% of all lines of code in talloc.c, and now it covers about 99%. The only lines not covered are talloc corruption errors, as that would cause smb_panic() to fire. It will be interesting to try gcov on the main Samba test suite for smbd. We won't achieve 100% coverage, but it would be nice to get to 90% or more. I also modified the talloc.c sources to be able to be build standalone, using: gcc -c -D_STANDALONE_ -Iinlcude lib/talloc.c that should make it much easier to re-use talloc in other projects (This used to be commit 8d4dc99b82efdf24b6811851c7bdd4af5a4c52c9)
2004-09-29 06:31:14 +00:00
CHECK_SIZE(p1, 10);
r4591: - converted the other _p talloc functions to not need _p - added #if TALLOC_DEPRECATED around the _p functions - fixes the code that broke from the above while doing this I fixed quite a number of places that were incorrectly using the non type-safe talloc functions to use the type safe ones. Some were even doing multiplies for array allocation, which is potentially unsafe. (This used to be commit 6e7754abd0c225527fb38363996a6e241b87b37e)
2005-01-07 04:39:16 +00:00
p1 = talloc_realloc_size(NULL, p1, 20);
r2744: ben elliston taught me about gcov today, which allows you to measure the % coverage in terms of lines of code of a test suite. I thought a good first place to start with gcov was the talloc test suite. When I started the test suite covered about 60% of all lines of code in talloc.c, and now it covers about 99%. The only lines not covered are talloc corruption errors, as that would cause smb_panic() to fire. It will be interesting to try gcov on the main Samba test suite for smbd. We won't achieve 100% coverage, but it would be nice to get to 90% or more. I also modified the talloc.c sources to be able to be build standalone, using: gcc -c -D_STANDALONE_ -Iinlcude lib/talloc.c that should make it much easier to re-use talloc in other projects (This used to be commit 8d4dc99b82efdf24b6811851c7bdd4af5a4c52c9)
2004-09-29 06:31:14 +00:00
CHECK_SIZE(p1, 20);
r4550: talloc() is now typesafe. It is exactly equivalent to the old talloc_p() macro. Use talloc_size() if you want the old behaviour. I have kept talloc_p() as an alias for now. Once we change all calls to be plain talloc() then we can remove it. (This used to be commit 2011bbeb841fd6bfccf3d44a49f79203f7f55baa)
2005-01-06 03:20:56 +00:00
talloc_new(p1);
r2744: ben elliston taught me about gcov today, which allows you to measure the % coverage in terms of lines of code of a test suite. I thought a good first place to start with gcov was the talloc test suite. When I started the test suite covered about 60% of all lines of code in talloc.c, and now it covers about 99%. The only lines not covered are talloc corruption errors, as that would cause smb_panic() to fire. It will be interesting to try gcov on the main Samba test suite for smbd. We won't achieve 100% coverage, but it would be nice to get to 90% or more. I also modified the talloc.c sources to be able to be build standalone, using: gcc -c -D_STANDALONE_ -Iinlcude lib/talloc.c that should make it much easier to re-use talloc in other projects (This used to be commit 8d4dc99b82efdf24b6811851c7bdd4af5a4c52c9)
2004-09-29 06:31:14 +00:00
r4591: - converted the other _p talloc functions to not need _p - added #if TALLOC_DEPRECATED around the _p functions - fixes the code that broke from the above while doing this I fixed quite a number of places that were incorrectly using the non type-safe talloc functions to use the type safe ones. Some were even doing multiplies for array allocation, which is potentially unsafe. (This used to be commit 6e7754abd0c225527fb38363996a6e241b87b37e)
2005-01-07 04:39:16 +00:00
p2 = talloc_realloc_size(p1, NULL, 30);
r2744: ben elliston taught me about gcov today, which allows you to measure the % coverage in terms of lines of code of a test suite. I thought a good first place to start with gcov was the talloc test suite. When I started the test suite covered about 60% of all lines of code in talloc.c, and now it covers about 99%. The only lines not covered are talloc corruption errors, as that would cause smb_panic() to fire. It will be interesting to try gcov on the main Samba test suite for smbd. We won't achieve 100% coverage, but it would be nice to get to 90% or more. I also modified the talloc.c sources to be able to be build standalone, using: gcc -c -D_STANDALONE_ -Iinlcude lib/talloc.c that should make it much easier to re-use talloc in other projects (This used to be commit 8d4dc99b82efdf24b6811851c7bdd4af5a4c52c9)
2004-09-29 06:31:14 +00:00
r4550: talloc() is now typesafe. It is exactly equivalent to the old talloc_p() macro. Use talloc_size() if you want the old behaviour. I have kept talloc_p() as an alias for now. Once we change all calls to be plain talloc() then we can remove it. (This used to be commit 2011bbeb841fd6bfccf3d44a49f79203f7f55baa)
2005-01-06 03:20:56 +00:00
talloc_new(p1);
r2744: ben elliston taught me about gcov today, which allows you to measure the % coverage in terms of lines of code of a test suite. I thought a good first place to start with gcov was the talloc test suite. When I started the test suite covered about 60% of all lines of code in talloc.c, and now it covers about 99%. The only lines not covered are talloc corruption errors, as that would cause smb_panic() to fire. It will be interesting to try gcov on the main Samba test suite for smbd. We won't achieve 100% coverage, but it would be nice to get to 90% or more. I also modified the talloc.c sources to be able to be build standalone, using: gcc -c -D_STANDALONE_ -Iinlcude lib/talloc.c that should make it much easier to re-use talloc in other projects (This used to be commit 8d4dc99b82efdf24b6811851c7bdd4af5a4c52c9)
2004-09-29 06:31:14 +00:00
r4591: - converted the other _p talloc functions to not need _p - added #if TALLOC_DEPRECATED around the _p functions - fixes the code that broke from the above while doing this I fixed quite a number of places that were incorrectly using the non type-safe talloc functions to use the type safe ones. Some were even doing multiplies for array allocation, which is potentially unsafe. (This used to be commit 6e7754abd0c225527fb38363996a6e241b87b37e)
2005-01-07 04:39:16 +00:00
p2 = talloc_realloc_size(p1, p2, 40);
r2744: ben elliston taught me about gcov today, which allows you to measure the % coverage in terms of lines of code of a test suite. I thought a good first place to start with gcov was the talloc test suite. When I started the test suite covered about 60% of all lines of code in talloc.c, and now it covers about 99%. The only lines not covered are talloc corruption errors, as that would cause smb_panic() to fire. It will be interesting to try gcov on the main Samba test suite for smbd. We won't achieve 100% coverage, but it would be nice to get to 90% or more. I also modified the talloc.c sources to be able to be build standalone, using: gcc -c -D_STANDALONE_ -Iinlcude lib/talloc.c that should make it much easier to re-use talloc in other projects (This used to be commit 8d4dc99b82efdf24b6811851c7bdd4af5a4c52c9)
2004-09-29 06:31:14 +00:00
CHECK_SIZE(p2, 40);
CHECK_SIZE(root, 60);
CHECK_BLOCKS(p1, 4);
r4591: - converted the other _p talloc functions to not need _p - added #if TALLOC_DEPRECATED around the _p functions - fixes the code that broke from the above while doing this I fixed quite a number of places that were incorrectly using the non type-safe talloc functions to use the type safe ones. Some were even doing multiplies for array allocation, which is potentially unsafe. (This used to be commit 6e7754abd0c225527fb38363996a6e241b87b37e)
2005-01-07 04:39:16 +00:00
p1 = talloc_realloc_size(NULL, p1, 20);
r2744: ben elliston taught me about gcov today, which allows you to measure the % coverage in terms of lines of code of a test suite. I thought a good first place to start with gcov was the talloc test suite. When I started the test suite covered about 60% of all lines of code in talloc.c, and now it covers about 99%. The only lines not covered are talloc corruption errors, as that would cause smb_panic() to fire. It will be interesting to try gcov on the main Samba test suite for smbd. We won't achieve 100% coverage, but it would be nice to get to 90% or more. I also modified the talloc.c sources to be able to be build standalone, using: gcc -c -D_STANDALONE_ -Iinlcude lib/talloc.c that should make it much easier to re-use talloc in other projects (This used to be commit 8d4dc99b82efdf24b6811851c7bdd4af5a4c52c9)
2004-09-29 06:31:14 +00:00
CHECK_SIZE(p1, 60);
talloc_increase_ref_count(p2);
r4591: - converted the other _p talloc functions to not need _p - added #if TALLOC_DEPRECATED around the _p functions - fixes the code that broke from the above while doing this I fixed quite a number of places that were incorrectly using the non type-safe talloc functions to use the type safe ones. Some were even doing multiplies for array allocation, which is potentially unsafe. (This used to be commit 6e7754abd0c225527fb38363996a6e241b87b37e)
2005-01-07 04:39:16 +00:00
if (talloc_realloc_size(NULL, p2, 5) != NULL) {
r2744: ben elliston taught me about gcov today, which allows you to measure the % coverage in terms of lines of code of a test suite. I thought a good first place to start with gcov was the talloc test suite. When I started the test suite covered about 60% of all lines of code in talloc.c, and now it covers about 99%. The only lines not covered are talloc corruption errors, as that would cause smb_panic() to fire. It will be interesting to try gcov on the main Samba test suite for smbd. We won't achieve 100% coverage, but it would be nice to get to 90% or more. I also modified the talloc.c sources to be able to be build standalone, using: gcc -c -D_STANDALONE_ -Iinlcude lib/talloc.c that should make it much easier to re-use talloc in other projects (This used to be commit 8d4dc99b82efdf24b6811851c7bdd4af5a4c52c9)
2004-09-29 06:31:14 +00:00
printf("failed: talloc_realloc() on a referenced pointer should fail\n");
r2709: finally solved the talloc reference problem. The problem was that the simple "uint_t ref_count;" in a talloc chunk did not give enough information. It told us that a pointer was referenced more than once, but it didn't say who it was referenced by. This means that when the pointer was freed we had no sane way to clean up the reference. I have now replaced ref_count with a "refs" list, which means that references point to the pointer, and the pointer has a linked list of references. So now we can cleanup from either direction without losing track of anything. I've also added a LOCAL-TALLOC smbtorture test that tests talloc behaviour for some common uses. (This used to be commit 911a8d590cb184bcb892810729955c2c4cf02550)
2004-09-28 05:42:02 +00:00
return False;
}
r2744: ben elliston taught me about gcov today, which allows you to measure the % coverage in terms of lines of code of a test suite. I thought a good first place to start with gcov was the talloc test suite. When I started the test suite covered about 60% of all lines of code in talloc.c, and now it covers about 99%. The only lines not covered are talloc corruption errors, as that would cause smb_panic() to fire. It will be interesting to try gcov on the main Samba test suite for smbd. We won't achieve 100% coverage, but it would be nice to get to 90% or more. I also modified the talloc.c sources to be able to be build standalone, using: gcc -c -D_STANDALONE_ -Iinlcude lib/talloc.c that should make it much easier to re-use talloc in other projects (This used to be commit 8d4dc99b82efdf24b6811851c7bdd4af5a4c52c9)
2004-09-29 06:31:14 +00:00
CHECK_BLOCKS(p1, 4);
r4591: - converted the other _p talloc functions to not need _p - added #if TALLOC_DEPRECATED around the _p functions - fixes the code that broke from the above while doing this I fixed quite a number of places that were incorrectly using the non type-safe talloc functions to use the type safe ones. Some were even doing multiplies for array allocation, which is potentially unsafe. (This used to be commit 6e7754abd0c225527fb38363996a6e241b87b37e)
2005-01-07 04:39:16 +00:00
talloc_realloc_size(NULL, p2, 0);
talloc_realloc_size(NULL, p2, 0);
r2744: ben elliston taught me about gcov today, which allows you to measure the % coverage in terms of lines of code of a test suite. I thought a good first place to start with gcov was the talloc test suite. When I started the test suite covered about 60% of all lines of code in talloc.c, and now it covers about 99%. The only lines not covered are talloc corruption errors, as that would cause smb_panic() to fire. It will be interesting to try gcov on the main Samba test suite for smbd. We won't achieve 100% coverage, but it would be nice to get to 90% or more. I also modified the talloc.c sources to be able to be build standalone, using: gcc -c -D_STANDALONE_ -Iinlcude lib/talloc.c that should make it much easier to re-use talloc in other projects (This used to be commit 8d4dc99b82efdf24b6811851c7bdd4af5a4c52c9)
2004-09-29 06:31:14 +00:00
CHECK_BLOCKS(p1, 3);
r4591: - converted the other _p talloc functions to not need _p - added #if TALLOC_DEPRECATED around the _p functions - fixes the code that broke from the above while doing this I fixed quite a number of places that were incorrectly using the non type-safe talloc functions to use the type safe ones. Some were even doing multiplies for array allocation, which is potentially unsafe. (This used to be commit 6e7754abd0c225527fb38363996a6e241b87b37e)
2005-01-07 04:39:16 +00:00
if (talloc_realloc_size(NULL, p1, 0x7fffffff) != NULL) {
r2744: ben elliston taught me about gcov today, which allows you to measure the % coverage in terms of lines of code of a test suite. I thought a good first place to start with gcov was the talloc test suite. When I started the test suite covered about 60% of all lines of code in talloc.c, and now it covers about 99%. The only lines not covered are talloc corruption errors, as that would cause smb_panic() to fire. It will be interesting to try gcov on the main Samba test suite for smbd. We won't achieve 100% coverage, but it would be nice to get to 90% or more. I also modified the talloc.c sources to be able to be build standalone, using: gcc -c -D_STANDALONE_ -Iinlcude lib/talloc.c that should make it much easier to re-use talloc in other projects (This used to be commit 8d4dc99b82efdf24b6811851c7bdd4af5a4c52c9)
2004-09-29 06:31:14 +00:00
printf("failed: oversize talloc should fail\n");
return False;
}
r4591: - converted the other _p talloc functions to not need _p - added #if TALLOC_DEPRECATED around the _p functions - fixes the code that broke from the above while doing this I fixed quite a number of places that were incorrectly using the non type-safe talloc functions to use the type safe ones. Some were even doing multiplies for array allocation, which is potentially unsafe. (This used to be commit 6e7754abd0c225527fb38363996a6e241b87b37e)
2005-01-07 04:39:16 +00:00
talloc_realloc_size(NULL, p1, 0);
r2744: ben elliston taught me about gcov today, which allows you to measure the % coverage in terms of lines of code of a test suite. I thought a good first place to start with gcov was the talloc test suite. When I started the test suite covered about 60% of all lines of code in talloc.c, and now it covers about 99%. The only lines not covered are talloc corruption errors, as that would cause smb_panic() to fire. It will be interesting to try gcov on the main Samba test suite for smbd. We won't achieve 100% coverage, but it would be nice to get to 90% or more. I also modified the talloc.c sources to be able to be build standalone, using: gcc -c -D_STANDALONE_ -Iinlcude lib/talloc.c that should make it much easier to re-use talloc in other projects (This used to be commit 8d4dc99b82efdf24b6811851c7bdd4af5a4c52c9)
2004-09-29 06:31:14 +00:00
CHECK_BLOCKS(root, 1);
CHECK_SIZE(root, 0);
r2709: finally solved the talloc reference problem. The problem was that the simple "uint_t ref_count;" in a talloc chunk did not give enough information. It told us that a pointer was referenced more than once, but it didn't say who it was referenced by. This means that when the pointer was freed we had no sane way to clean up the reference. I have now replaced ref_count with a "refs" list, which means that references point to the pointer, and the pointer has a linked list of references. So now we can cleanup from either direction without losing track of anything. I've also added a LOCAL-TALLOC smbtorture test that tests talloc behaviour for some common uses. (This used to be commit 911a8d590cb184bcb892810729955c2c4cf02550)
2004-09-28 05:42:02 +00:00
r2742: - fixed a bug in talloc_unreference() - made the LOCAL-TALLOC smbtorture test much stricter, checking that block counts for every pointer are correct after every operation (This used to be commit 18d3e2647f0bedbba699d1ba2649c0cfe4526ef6)
2004-09-28 23:30:14 +00:00
talloc_free(root);
r2709: finally solved the talloc reference problem. The problem was that the simple "uint_t ref_count;" in a talloc chunk did not give enough information. It told us that a pointer was referenced more than once, but it didn't say who it was referenced by. This means that when the pointer was freed we had no sane way to clean up the reference. I have now replaced ref_count with a "refs" list, which means that references point to the pointer, and the pointer has a linked list of references. So now we can cleanup from either direction without losing track of anything. I've also added a LOCAL-TALLOC smbtorture test that tests talloc behaviour for some common uses. (This used to be commit 911a8d590cb184bcb892810729955c2c4cf02550)
2004-09-28 05:42:02 +00:00
return True;
}
r4473: - moved talloc into its own lib/talloc/ area - added gcov flags to Makefile.talloc - expanded talloc testsuite to add a test for realloc with a child ptr - fixed a bug in talloc_realloc() with realloc of a ptr that has child ptrs (This used to be commit 98b5f73c1ba34d7576c5995069b485c1c5ede324)
2005-01-02 07:47:34 +00:00
/*
test realloc with a child
*/
static BOOL test_realloc_child(void)
{
void *root;
struct el1 {
int count;
struct el2 {
const char *name;
r4711: - deprecate talloc_destroy() - expanded the talloc_realloc() test a little (I was concerned about a possible bug, which turned out to be an illusion) - don't enable gcov by default in Makefile.talloc (This used to be commit 4ec47cc1083c4cdb780e548177631c5914bf677a)
2005-01-12 11:45:43 +00:00
} **list, **list2, **list3;
r4473: - moved talloc into its own lib/talloc/ area - added gcov flags to Makefile.talloc - expanded talloc testsuite to add a test for realloc with a child ptr - fixed a bug in talloc_realloc() with realloc of a ptr that has child ptrs (This used to be commit 98b5f73c1ba34d7576c5995069b485c1c5ede324)
2005-01-02 07:47:34 +00:00
} *el1;
struct el2 *el2;
printf("TESTING REALLOC WITH CHILD\n");
r4549: got rid of a lot more uses of plain talloc(), instead using talloc_size() or talloc_array_p() where appropriate. also fixed a memory leak in pvfs_copy_file() (failed to free a memory context) (This used to be commit 89b74b53546e1570b11b3702f40bee58aed8c503)
2005-01-06 03:06:58 +00:00
root = talloc_new(NULL);
r4473: - moved talloc into its own lib/talloc/ area - added gcov flags to Makefile.talloc - expanded talloc testsuite to add a test for realloc with a child ptr - fixed a bug in talloc_realloc() with realloc of a ptr that has child ptrs (This used to be commit 98b5f73c1ba34d7576c5995069b485c1c5ede324)
2005-01-02 07:47:34 +00:00
r4593: don't use the _p function in the testsuite, as when built standalone it doesn't use TALLOC_DEPRECATED (This used to be commit 2fe0e2528f14627832942f6404a4b1be4b556c97)
2005-01-07 04:47:58 +00:00
el1 = talloc(root, struct el1);
el1->list = talloc(el1, struct el2 *);
el1->list[0] = talloc(el1->list, struct el2);
r4473: - moved talloc into its own lib/talloc/ area - added gcov flags to Makefile.talloc - expanded talloc testsuite to add a test for realloc with a child ptr - fixed a bug in talloc_realloc() with realloc of a ptr that has child ptrs (This used to be commit 98b5f73c1ba34d7576c5995069b485c1c5ede324)
2005-01-02 07:47:34 +00:00
el1->list[0]->name = talloc_strdup(el1->list[0], "testing");
r4711: - deprecate talloc_destroy() - expanded the talloc_realloc() test a little (I was concerned about a possible bug, which turned out to be an illusion) - don't enable gcov by default in Makefile.talloc (This used to be commit 4ec47cc1083c4cdb780e548177631c5914bf677a)
2005-01-12 11:45:43 +00:00
el1->list2 = talloc(el1, struct el2 *);
el1->list2[0] = talloc(el1->list2, struct el2);
el1->list2[0]->name = talloc_strdup(el1->list2[0], "testing2");
el1->list3 = talloc(el1, struct el2 *);
el1->list3[0] = talloc(el1->list3, struct el2);
el1->list3[0]->name = talloc_strdup(el1->list3[0], "testing2");
r4473: - moved talloc into its own lib/talloc/ area - added gcov flags to Makefile.talloc - expanded talloc testsuite to add a test for realloc with a child ptr - fixed a bug in talloc_realloc() with realloc of a ptr that has child ptrs (This used to be commit 98b5f73c1ba34d7576c5995069b485c1c5ede324)
2005-01-02 07:47:34 +00:00
r4593: don't use the _p function in the testsuite, as when built standalone it doesn't use TALLOC_DEPRECATED (This used to be commit 2fe0e2528f14627832942f6404a4b1be4b556c97)
2005-01-07 04:47:58 +00:00
el2 = talloc(el1->list, struct el2);
r4711: - deprecate talloc_destroy() - expanded the talloc_realloc() test a little (I was concerned about a possible bug, which turned out to be an illusion) - don't enable gcov by default in Makefile.talloc (This used to be commit 4ec47cc1083c4cdb780e548177631c5914bf677a)
2005-01-12 11:45:43 +00:00
el2 = talloc(el1->list2, struct el2);
el2 = talloc(el1->list3, struct el2);
r4473: - moved talloc into its own lib/talloc/ area - added gcov flags to Makefile.talloc - expanded talloc testsuite to add a test for realloc with a child ptr - fixed a bug in talloc_realloc() with realloc of a ptr that has child ptrs (This used to be commit 98b5f73c1ba34d7576c5995069b485c1c5ede324)
2005-01-02 07:47:34 +00:00
r4711: - deprecate talloc_destroy() - expanded the talloc_realloc() test a little (I was concerned about a possible bug, which turned out to be an illusion) - don't enable gcov by default in Makefile.talloc (This used to be commit 4ec47cc1083c4cdb780e548177631c5914bf677a)
2005-01-12 11:45:43 +00:00
el1->list = talloc_realloc(el1, el1->list, struct el2 *, 100);
el1->list2 = talloc_realloc(el1, el1->list2, struct el2 *, 200);
el1->list3 = talloc_realloc(el1, el1->list3, struct el2 *, 300);
r4473: - moved talloc into its own lib/talloc/ area - added gcov flags to Makefile.talloc - expanded talloc testsuite to add a test for realloc with a child ptr - fixed a bug in talloc_realloc() with realloc of a ptr that has child ptrs (This used to be commit 98b5f73c1ba34d7576c5995069b485c1c5ede324)
2005-01-02 07:47:34 +00:00
talloc_free(root);
return True;
}
r4790: added type checking helper macros in talloc. These take advantage of the type names that talloc already keeps around for pointers, and allows the user to type check void* private pointers. It can also be used to implement polymorphism in C, as I'm sure someone would have pointed out to me sooner or later :-) (This used to be commit c283e1a3efac3a92e29a35856e20eb61ef4c221e)
2005-01-16 23:21:52 +00:00
/*
test type checking
*/
static BOOL test_type(void)
{
void *root;
struct el1 {
int count;
};
struct el2 {
int count;
};
struct el1 *el1;
printf("TESTING talloc type checking\n");
root = talloc_new(NULL);
el1 = talloc(root, struct el1);
el1->count = 1;
if (talloc_get_type(el1, struct el1) != el1) {
printf("type check failed on el1\n");
return False;
}
if (talloc_get_type(el1, struct el2) != NULL) {
printf("type check failed on el1 with el2\n");
return False;
}
talloc_set_type(el1, struct el2);
r5142: fix compiler warning metze (This used to be commit d8aeb69ea85cc0df89e213482c446eb8e793bc86)
2005-01-31 16:36:57 +00:00
if (talloc_get_type(el1, struct el2) != (struct el2 *)el1) {
r4790: added type checking helper macros in talloc. These take advantage of the type names that talloc already keeps around for pointers, and allows the user to type check void* private pointers. It can also be used to implement polymorphism in C, as I'm sure someone would have pointed out to me sooner or later :-) (This used to be commit c283e1a3efac3a92e29a35856e20eb61ef4c221e)
2005-01-16 23:21:52 +00:00
printf("type set failed on el1 with el2\n");
return False;
}
talloc_free(root);
return True;
}
r2744: ben elliston taught me about gcov today, which allows you to measure the % coverage in terms of lines of code of a test suite. I thought a good first place to start with gcov was the talloc test suite. When I started the test suite covered about 60% of all lines of code in talloc.c, and now it covers about 99%. The only lines not covered are talloc corruption errors, as that would cause smb_panic() to fire. It will be interesting to try gcov on the main Samba test suite for smbd. We won't achieve 100% coverage, but it would be nice to get to 90% or more. I also modified the talloc.c sources to be able to be build standalone, using: gcc -c -D_STANDALONE_ -Iinlcude lib/talloc.c that should make it much easier to re-use talloc in other projects (This used to be commit 8d4dc99b82efdf24b6811851c7bdd4af5a4c52c9)
2004-09-29 06:31:14 +00:00
/*
test steal
*/
static BOOL test_steal(void)
{
void *root, *p1, *p2;
printf("TESTING STEAL\n");
r4549: got rid of a lot more uses of plain talloc(), instead using talloc_size() or talloc_array_p() where appropriate. also fixed a memory leak in pvfs_copy_file() (failed to free a memory context) (This used to be commit 89b74b53546e1570b11b3702f40bee58aed8c503)
2005-01-06 03:06:58 +00:00
root = talloc_new(NULL);
r2744: ben elliston taught me about gcov today, which allows you to measure the % coverage in terms of lines of code of a test suite. I thought a good first place to start with gcov was the talloc test suite. When I started the test suite covered about 60% of all lines of code in talloc.c, and now it covers about 99%. The only lines not covered are talloc corruption errors, as that would cause smb_panic() to fire. It will be interesting to try gcov on the main Samba test suite for smbd. We won't achieve 100% coverage, but it would be nice to get to 90% or more. I also modified the talloc.c sources to be able to be build standalone, using: gcc -c -D_STANDALONE_ -Iinlcude lib/talloc.c that should make it much easier to re-use talloc in other projects (This used to be commit 8d4dc99b82efdf24b6811851c7bdd4af5a4c52c9)
2004-09-29 06:31:14 +00:00
r4593: don't use the _p function in the testsuite, as when built standalone it doesn't use TALLOC_DEPRECATED (This used to be commit 2fe0e2528f14627832942f6404a4b1be4b556c97)
2005-01-07 04:47:58 +00:00
p1 = talloc_array(root, char, 10);
r2744: ben elliston taught me about gcov today, which allows you to measure the % coverage in terms of lines of code of a test suite. I thought a good first place to start with gcov was the talloc test suite. When I started the test suite covered about 60% of all lines of code in talloc.c, and now it covers about 99%. The only lines not covered are talloc corruption errors, as that would cause smb_panic() to fire. It will be interesting to try gcov on the main Samba test suite for smbd. We won't achieve 100% coverage, but it would be nice to get to 90% or more. I also modified the talloc.c sources to be able to be build standalone, using: gcc -c -D_STANDALONE_ -Iinlcude lib/talloc.c that should make it much easier to re-use talloc in other projects (This used to be commit 8d4dc99b82efdf24b6811851c7bdd4af5a4c52c9)
2004-09-29 06:31:14 +00:00
CHECK_SIZE(p1, 10);
r4593: don't use the _p function in the testsuite, as when built standalone it doesn't use TALLOC_DEPRECATED (This used to be commit 2fe0e2528f14627832942f6404a4b1be4b556c97)
2005-01-07 04:47:58 +00:00
p2 = talloc_realloc(root, NULL, char, 20);
r2744: ben elliston taught me about gcov today, which allows you to measure the % coverage in terms of lines of code of a test suite. I thought a good first place to start with gcov was the talloc test suite. When I started the test suite covered about 60% of all lines of code in talloc.c, and now it covers about 99%. The only lines not covered are talloc corruption errors, as that would cause smb_panic() to fire. It will be interesting to try gcov on the main Samba test suite for smbd. We won't achieve 100% coverage, but it would be nice to get to 90% or more. I also modified the talloc.c sources to be able to be build standalone, using: gcc -c -D_STANDALONE_ -Iinlcude lib/talloc.c that should make it much easier to re-use talloc in other projects (This used to be commit 8d4dc99b82efdf24b6811851c7bdd4af5a4c52c9)
2004-09-29 06:31:14 +00:00
CHECK_SIZE(p1, 10);
CHECK_SIZE(root, 30);
if (talloc_steal(p1, NULL) != NULL) {
printf("failed: stealing NULL should give NULL\n");
return False;
}
if (talloc_steal(p1, p1) != p1) {
printf("failed: stealing to ourselves is a nop\n");
return False;
}
CHECK_BLOCKS(root, 3);
CHECK_SIZE(root, 30);
talloc_steal(NULL, p1);
talloc_steal(NULL, p2);
CHECK_BLOCKS(root, 1);
CHECK_SIZE(root, 0);
talloc_free(p1);
talloc_steal(root, p2);
CHECK_BLOCKS(root, 2);
CHECK_SIZE(root, 20);
talloc_free(p2);
CHECK_BLOCKS(root, 1);
CHECK_SIZE(root, 0);
talloc_free(root);
r4592: fixed typo from talloc testsuite fixup for the new syntax (This used to be commit 1177200dd9392c088f5b009f55390ad31c367e5f)
2005-01-07 04:45:11 +00:00
p1 = talloc_size(NULL, 3);
r2744: ben elliston taught me about gcov today, which allows you to measure the % coverage in terms of lines of code of a test suite. I thought a good first place to start with gcov was the talloc test suite. When I started the test suite covered about 60% of all lines of code in talloc.c, and now it covers about 99%. The only lines not covered are talloc corruption errors, as that would cause smb_panic() to fire. It will be interesting to try gcov on the main Samba test suite for smbd. We won't achieve 100% coverage, but it would be nice to get to 90% or more. I also modified the talloc.c sources to be able to be build standalone, using: gcc -c -D_STANDALONE_ -Iinlcude lib/talloc.c that should make it much easier to re-use talloc in other projects (This used to be commit 8d4dc99b82efdf24b6811851c7bdd4af5a4c52c9)
2004-09-29 06:31:14 +00:00
CHECK_SIZE(NULL, 3);
talloc_free(p1);
return True;
}
/*
r4790: added type checking helper macros in talloc. These take advantage of the type names that talloc already keeps around for pointers, and allows the user to type check void* private pointers. It can also be used to implement polymorphism in C, as I'm sure someone would have pointed out to me sooner or later :-) (This used to be commit c283e1a3efac3a92e29a35856e20eb61ef4c221e)
2005-01-16 23:21:52 +00:00
test talloc_realloc_fn
r2744: ben elliston taught me about gcov today, which allows you to measure the % coverage in terms of lines of code of a test suite. I thought a good first place to start with gcov was the talloc test suite. When I started the test suite covered about 60% of all lines of code in talloc.c, and now it covers about 99%. The only lines not covered are talloc corruption errors, as that would cause smb_panic() to fire. It will be interesting to try gcov on the main Samba test suite for smbd. We won't achieve 100% coverage, but it would be nice to get to 90% or more. I also modified the talloc.c sources to be able to be build standalone, using: gcc -c -D_STANDALONE_ -Iinlcude lib/talloc.c that should make it much easier to re-use talloc in other projects (This used to be commit 8d4dc99b82efdf24b6811851c7bdd4af5a4c52c9)
2004-09-29 06:31:14 +00:00
*/
r4790: added type checking helper macros in talloc. These take advantage of the type names that talloc already keeps around for pointers, and allows the user to type check void* private pointers. It can also be used to implement polymorphism in C, as I'm sure someone would have pointed out to me sooner or later :-) (This used to be commit c283e1a3efac3a92e29a35856e20eb61ef4c221e)
2005-01-16 23:21:52 +00:00
static BOOL test_realloc_fn(void)
r2744: ben elliston taught me about gcov today, which allows you to measure the % coverage in terms of lines of code of a test suite. I thought a good first place to start with gcov was the talloc test suite. When I started the test suite covered about 60% of all lines of code in talloc.c, and now it covers about 99%. The only lines not covered are talloc corruption errors, as that would cause smb_panic() to fire. It will be interesting to try gcov on the main Samba test suite for smbd. We won't achieve 100% coverage, but it would be nice to get to 90% or more. I also modified the talloc.c sources to be able to be build standalone, using: gcc -c -D_STANDALONE_ -Iinlcude lib/talloc.c that should make it much easier to re-use talloc in other projects (This used to be commit 8d4dc99b82efdf24b6811851c7bdd4af5a4c52c9)
2004-09-29 06:31:14 +00:00
{
void *root, *p1;
r4790: added type checking helper macros in talloc. These take advantage of the type names that talloc already keeps around for pointers, and allows the user to type check void* private pointers. It can also be used to implement polymorphism in C, as I'm sure someone would have pointed out to me sooner or later :-) (This used to be commit c283e1a3efac3a92e29a35856e20eb61ef4c221e)
2005-01-16 23:21:52 +00:00
printf("TESTING talloc_realloc_fn\n");
r2744: ben elliston taught me about gcov today, which allows you to measure the % coverage in terms of lines of code of a test suite. I thought a good first place to start with gcov was the talloc test suite. When I started the test suite covered about 60% of all lines of code in talloc.c, and now it covers about 99%. The only lines not covered are talloc corruption errors, as that would cause smb_panic() to fire. It will be interesting to try gcov on the main Samba test suite for smbd. We won't achieve 100% coverage, but it would be nice to get to 90% or more. I also modified the talloc.c sources to be able to be build standalone, using: gcc -c -D_STANDALONE_ -Iinlcude lib/talloc.c that should make it much easier to re-use talloc in other projects (This used to be commit 8d4dc99b82efdf24b6811851c7bdd4af5a4c52c9)
2004-09-29 06:31:14 +00:00
r4549: got rid of a lot more uses of plain talloc(), instead using talloc_size() or talloc_array_p() where appropriate. also fixed a memory leak in pvfs_copy_file() (failed to free a memory context) (This used to be commit 89b74b53546e1570b11b3702f40bee58aed8c503)
2005-01-06 03:06:58 +00:00
root = talloc_new(NULL);
r2744: ben elliston taught me about gcov today, which allows you to measure the % coverage in terms of lines of code of a test suite. I thought a good first place to start with gcov was the talloc test suite. When I started the test suite covered about 60% of all lines of code in talloc.c, and now it covers about 99%. The only lines not covered are talloc corruption errors, as that would cause smb_panic() to fire. It will be interesting to try gcov on the main Samba test suite for smbd. We won't achieve 100% coverage, but it would be nice to get to 90% or more. I also modified the talloc.c sources to be able to be build standalone, using: gcc -c -D_STANDALONE_ -Iinlcude lib/talloc.c that should make it much easier to re-use talloc in other projects (This used to be commit 8d4dc99b82efdf24b6811851c7bdd4af5a4c52c9)
2004-09-29 06:31:14 +00:00
r2799: removed one last occurance of torture_ldb_alloc() (This used to be commit 5045482b14dfcbb535eab3e5fa63ef1c3b46c40f)
2004-10-03 07:35:29 +00:00
p1 = talloc_realloc_fn(root, NULL, 10);
r2744: ben elliston taught me about gcov today, which allows you to measure the % coverage in terms of lines of code of a test suite. I thought a good first place to start with gcov was the talloc test suite. When I started the test suite covered about 60% of all lines of code in talloc.c, and now it covers about 99%. The only lines not covered are talloc corruption errors, as that would cause smb_panic() to fire. It will be interesting to try gcov on the main Samba test suite for smbd. We won't achieve 100% coverage, but it would be nice to get to 90% or more. I also modified the talloc.c sources to be able to be build standalone, using: gcc -c -D_STANDALONE_ -Iinlcude lib/talloc.c that should make it much easier to re-use talloc in other projects (This used to be commit 8d4dc99b82efdf24b6811851c7bdd4af5a4c52c9)
2004-09-29 06:31:14 +00:00
CHECK_BLOCKS(root, 2);
CHECK_SIZE(root, 10);
r2799: removed one last occurance of torture_ldb_alloc() (This used to be commit 5045482b14dfcbb535eab3e5fa63ef1c3b46c40f)
2004-10-03 07:35:29 +00:00
p1 = talloc_realloc_fn(root, p1, 20);
r2744: ben elliston taught me about gcov today, which allows you to measure the % coverage in terms of lines of code of a test suite. I thought a good first place to start with gcov was the talloc test suite. When I started the test suite covered about 60% of all lines of code in talloc.c, and now it covers about 99%. The only lines not covered are talloc corruption errors, as that would cause smb_panic() to fire. It will be interesting to try gcov on the main Samba test suite for smbd. We won't achieve 100% coverage, but it would be nice to get to 90% or more. I also modified the talloc.c sources to be able to be build standalone, using: gcc -c -D_STANDALONE_ -Iinlcude lib/talloc.c that should make it much easier to re-use talloc in other projects (This used to be commit 8d4dc99b82efdf24b6811851c7bdd4af5a4c52c9)
2004-09-29 06:31:14 +00:00
CHECK_BLOCKS(root, 2);
CHECK_SIZE(root, 20);
r2799: removed one last occurance of torture_ldb_alloc() (This used to be commit 5045482b14dfcbb535eab3e5fa63ef1c3b46c40f)
2004-10-03 07:35:29 +00:00
p1 = talloc_realloc_fn(root, p1, 0);
r2744: ben elliston taught me about gcov today, which allows you to measure the % coverage in terms of lines of code of a test suite. I thought a good first place to start with gcov was the talloc test suite. When I started the test suite covered about 60% of all lines of code in talloc.c, and now it covers about 99%. The only lines not covered are talloc corruption errors, as that would cause smb_panic() to fire. It will be interesting to try gcov on the main Samba test suite for smbd. We won't achieve 100% coverage, but it would be nice to get to 90% or more. I also modified the talloc.c sources to be able to be build standalone, using: gcc -c -D_STANDALONE_ -Iinlcude lib/talloc.c that should make it much easier to re-use talloc in other projects (This used to be commit 8d4dc99b82efdf24b6811851c7bdd4af5a4c52c9)
2004-09-29 06:31:14 +00:00
CHECK_BLOCKS(root, 1);
CHECK_SIZE(root, 0);
talloc_free(root);
return True;
}
r4473: - moved talloc into its own lib/talloc/ area - added gcov flags to Makefile.talloc - expanded talloc testsuite to add a test for realloc with a child ptr - fixed a bug in talloc_realloc() with realloc of a ptr that has child ptrs (This used to be commit 98b5f73c1ba34d7576c5995069b485c1c5ede324)
2005-01-02 07:47:34 +00:00
static BOOL test_unref_reparent(void)
{
void *root, *p1, *p2, *c1;
printf("TESTING UNREFERENCE AFTER PARENT FREED\n");
root = talloc_named_const(NULL, 0, "root");
p1 = talloc_named_const(root, 1, "orig parent");
p2 = talloc_named_const(root, 1, "parent by reference");
c1 = talloc_named_const(p1, 1, "child");
talloc_reference(p2, c1);
talloc_free(p1);
talloc_unlink(p2, c1);
CHECK_SIZE(root, 1);
talloc_free(p2);
talloc_free(root);
return True;
}
r2711: added a simple talloc speed tester. I get the following on my laptop: MEASURING TALLOC VS MALLOC SPEED talloc: 279154 ops/sec malloc: 318758 ops/sec which I think is an acceptable overhead for the increased functionality (This used to be commit 91669ea830c16db2730c5e43a7cad26d9db5c585)
2004-09-28 06:12:07 +00:00
/*
measure the speed of talloc versus malloc
*/
static BOOL test_speed(void)
{
r4549: got rid of a lot more uses of plain talloc(), instead using talloc_size() or talloc_array_p() where appropriate. also fixed a memory leak in pvfs_copy_file() (failed to free a memory context) (This used to be commit 89b74b53546e1570b11b3702f40bee58aed8c503)
2005-01-06 03:06:58 +00:00
void *ctx = talloc_new(NULL);
r2791: got rid of talloc_unreference() and instead created talloc_unlink(), which is much clearer and simpler to use. It removes a specific parent from a pointer, no matter whether that parent is a "reference" or a direct parent. This gives complete control over the free process. (This used to be commit 6c563887f1b9b8c842309a523e88b6f2a32db10f)
2004-10-03 00:04:30 +00:00
unsigned count;
r3507: - added deferred replies on sharing violation in pvfs open. The deferred reply is short-circuited immediately when the file is closed by another user, allowing it to be opened by the waiting user. - added a sane set of timeval manipulation routines - converted all the events code and code that uses it to use struct timeval instead of time_t, which allows for microsecond resolution instead of 1 second resolution. This was needed for doing the pvfs deferred open code, and is why the patch is so big. (This used to be commit 0d51511d408d91eb5f68a35e980e0875299b1831)
2004-11-03 10:09:48 +00:00
struct timeval tv;
r2711: added a simple talloc speed tester. I get the following on my laptop: MEASURING TALLOC VS MALLOC SPEED talloc: 279154 ops/sec malloc: 318758 ops/sec which I think is an acceptable overhead for the increased functionality (This used to be commit 91669ea830c16db2730c5e43a7cad26d9db5c585)
2004-09-28 06:12:07 +00:00
printf("MEASURING TALLOC VS MALLOC SPEED\n");
r3507: - added deferred replies on sharing violation in pvfs open. The deferred reply is short-circuited immediately when the file is closed by another user, allowing it to be opened by the waiting user. - added a sane set of timeval manipulation routines - converted all the events code and code that uses it to use struct timeval instead of time_t, which allows for microsecond resolution instead of 1 second resolution. This was needed for doing the pvfs deferred open code, and is why the patch is so big. (This used to be commit 0d51511d408d91eb5f68a35e980e0875299b1831)
2004-11-03 10:09:48 +00:00
tv = timeval_current();
r2711: added a simple talloc speed tester. I get the following on my laptop: MEASURING TALLOC VS MALLOC SPEED talloc: 279154 ops/sec malloc: 318758 ops/sec which I think is an acceptable overhead for the increased functionality (This used to be commit 91669ea830c16db2730c5e43a7cad26d9db5c585)
2004-09-28 06:12:07 +00:00
count = 0;
do {
void *p1, *p2, *p3;
r4549: got rid of a lot more uses of plain talloc(), instead using talloc_size() or talloc_array_p() where appropriate. also fixed a memory leak in pvfs_copy_file() (failed to free a memory context) (This used to be commit 89b74b53546e1570b11b3702f40bee58aed8c503)
2005-01-06 03:06:58 +00:00
p1 = talloc_size(ctx, count);
r2711: added a simple talloc speed tester. I get the following on my laptop: MEASURING TALLOC VS MALLOC SPEED talloc: 279154 ops/sec malloc: 318758 ops/sec which I think is an acceptable overhead for the increased functionality (This used to be commit 91669ea830c16db2730c5e43a7cad26d9db5c585)
2004-09-28 06:12:07 +00:00
p2 = talloc_strdup(p1, "foo bar");
r4549: got rid of a lot more uses of plain talloc(), instead using talloc_size() or talloc_array_p() where appropriate. also fixed a memory leak in pvfs_copy_file() (failed to free a memory context) (This used to be commit 89b74b53546e1570b11b3702f40bee58aed8c503)
2005-01-06 03:06:58 +00:00
p3 = talloc_size(p1, 300);
r2711: added a simple talloc speed tester. I get the following on my laptop: MEASURING TALLOC VS MALLOC SPEED talloc: 279154 ops/sec malloc: 318758 ops/sec which I think is an acceptable overhead for the increased functionality (This used to be commit 91669ea830c16db2730c5e43a7cad26d9db5c585)
2004-09-28 06:12:07 +00:00
talloc_free(p1);
count += 3;
r3507: - added deferred replies on sharing violation in pvfs open. The deferred reply is short-circuited immediately when the file is closed by another user, allowing it to be opened by the waiting user. - added a sane set of timeval manipulation routines - converted all the events code and code that uses it to use struct timeval instead of time_t, which allows for microsecond resolution instead of 1 second resolution. This was needed for doing the pvfs deferred open code, and is why the patch is so big. (This used to be commit 0d51511d408d91eb5f68a35e980e0875299b1831)
2004-11-03 10:09:48 +00:00
} while (timeval_elapsed(&tv) < 5.0);
r2711: added a simple talloc speed tester. I get the following on my laptop: MEASURING TALLOC VS MALLOC SPEED talloc: 279154 ops/sec malloc: 318758 ops/sec which I think is an acceptable overhead for the increased functionality (This used to be commit 91669ea830c16db2730c5e43a7cad26d9db5c585)
2004-09-28 06:12:07 +00:00
r3507: - added deferred replies on sharing violation in pvfs open. The deferred reply is short-circuited immediately when the file is closed by another user, allowing it to be opened by the waiting user. - added a sane set of timeval manipulation routines - converted all the events code and code that uses it to use struct timeval instead of time_t, which allows for microsecond resolution instead of 1 second resolution. This was needed for doing the pvfs deferred open code, and is why the patch is so big. (This used to be commit 0d51511d408d91eb5f68a35e980e0875299b1831)
2004-11-03 10:09:48 +00:00
printf("talloc: %.0f ops/sec\n", count/timeval_elapsed(&tv));
r2711: added a simple talloc speed tester. I get the following on my laptop: MEASURING TALLOC VS MALLOC SPEED talloc: 279154 ops/sec malloc: 318758 ops/sec which I think is an acceptable overhead for the increased functionality (This used to be commit 91669ea830c16db2730c5e43a7cad26d9db5c585)
2004-09-28 06:12:07 +00:00
r2718: - added a talloc_unreference() function as requested by metze. - added documentation for talloc_unreference() - made the abandoned child logic in talloc_free() clearer and more consistent (This used to be commit a87584c8e3fb06cd3ff29a918f681b5c6c32b9ff)
2004-09-28 11:54:17 +00:00
talloc_free(ctx);
r3507: - added deferred replies on sharing violation in pvfs open. The deferred reply is short-circuited immediately when the file is closed by another user, allowing it to be opened by the waiting user. - added a sane set of timeval manipulation routines - converted all the events code and code that uses it to use struct timeval instead of time_t, which allows for microsecond resolution instead of 1 second resolution. This was needed for doing the pvfs deferred open code, and is why the patch is so big. (This used to be commit 0d51511d408d91eb5f68a35e980e0875299b1831)
2004-11-03 10:09:48 +00:00
tv = timeval_current();
r2711: added a simple talloc speed tester. I get the following on my laptop: MEASURING TALLOC VS MALLOC SPEED talloc: 279154 ops/sec malloc: 318758 ops/sec which I think is an acceptable overhead for the increased functionality (This used to be commit 91669ea830c16db2730c5e43a7cad26d9db5c585)
2004-09-28 06:12:07 +00:00
count = 0;
do {
void *p1, *p2, *p3;
p1 = malloc(count);
p2 = strdup("foo bar");
p3 = malloc(300);
free(p1);
free(p2);
free(p3);
count += 3;
r3507: - added deferred replies on sharing violation in pvfs open. The deferred reply is short-circuited immediately when the file is closed by another user, allowing it to be opened by the waiting user. - added a sane set of timeval manipulation routines - converted all the events code and code that uses it to use struct timeval instead of time_t, which allows for microsecond resolution instead of 1 second resolution. This was needed for doing the pvfs deferred open code, and is why the patch is so big. (This used to be commit 0d51511d408d91eb5f68a35e980e0875299b1831)
2004-11-03 10:09:48 +00:00
} while (timeval_elapsed(&tv) < 5.0);
r2711: added a simple talloc speed tester. I get the following on my laptop: MEASURING TALLOC VS MALLOC SPEED talloc: 279154 ops/sec malloc: 318758 ops/sec which I think is an acceptable overhead for the increased functionality (This used to be commit 91669ea830c16db2730c5e43a7cad26d9db5c585)
2004-09-28 06:12:07 +00:00
r3507: - added deferred replies on sharing violation in pvfs open. The deferred reply is short-circuited immediately when the file is closed by another user, allowing it to be opened by the waiting user. - added a sane set of timeval manipulation routines - converted all the events code and code that uses it to use struct timeval instead of time_t, which allows for microsecond resolution instead of 1 second resolution. This was needed for doing the pvfs deferred open code, and is why the patch is so big. (This used to be commit 0d51511d408d91eb5f68a35e980e0875299b1831)
2004-11-03 10:09:48 +00:00
printf("malloc: %.0f ops/sec\n", count/timeval_elapsed(&tv));
r2711: added a simple talloc speed tester. I get the following on my laptop: MEASURING TALLOC VS MALLOC SPEED talloc: 279154 ops/sec malloc: 318758 ops/sec which I think is an acceptable overhead for the increased functionality (This used to be commit 91669ea830c16db2730c5e43a7cad26d9db5c585)
2004-09-28 06:12:07 +00:00
return True;
}
r2709: finally solved the talloc reference problem. The problem was that the simple "uint_t ref_count;" in a talloc chunk did not give enough information. It told us that a pointer was referenced more than once, but it didn't say who it was referenced by. This means that when the pointer was freed we had no sane way to clean up the reference. I have now replaced ref_count with a "refs" list, which means that references point to the pointer, and the pointer has a linked list of references. So now we can cleanup from either direction without losing track of anything. I've also added a LOCAL-TALLOC smbtorture test that tests talloc behaviour for some common uses. (This used to be commit 911a8d590cb184bcb892810729955c2c4cf02550)
2004-09-28 05:42:02 +00:00
r3324: made the smbtorture code completely warning free (This used to be commit 7067bb9b52223cafa28470f264f0b60646a07a01)
2004-10-28 13:40:50 +00:00
BOOL torture_local_talloc(void)
r2709: finally solved the talloc reference problem. The problem was that the simple "uint_t ref_count;" in a talloc chunk did not give enough information. It told us that a pointer was referenced more than once, but it didn't say who it was referenced by. This means that when the pointer was freed we had no sane way to clean up the reference. I have now replaced ref_count with a "refs" list, which means that references point to the pointer, and the pointer has a linked list of references. So now we can cleanup from either direction without losing track of anything. I've also added a LOCAL-TALLOC smbtorture test that tests talloc behaviour for some common uses. (This used to be commit 911a8d590cb184bcb892810729955c2c4cf02550)
2004-09-28 05:42:02 +00:00
{
BOOL ret = True;
ret &= test_ref1();
ret &= test_ref2();
r2718: - added a talloc_unreference() function as requested by metze. - added documentation for talloc_unreference() - made the abandoned child logic in talloc_free() clearer and more consistent (This used to be commit a87584c8e3fb06cd3ff29a918f681b5c6c32b9ff)
2004-09-28 11:54:17 +00:00
ret &= test_ref3();
ret &= test_ref4();
r2791: got rid of talloc_unreference() and instead created talloc_unlink(), which is much clearer and simpler to use. It removes a specific parent from a pointer, no matter whether that parent is a "reference" or a direct parent. This gives complete control over the free process. (This used to be commit 6c563887f1b9b8c842309a523e88b6f2a32db10f)
2004-10-03 00:04:30 +00:00
ret &= test_unlink1();
r2744: ben elliston taught me about gcov today, which allows you to measure the % coverage in terms of lines of code of a test suite. I thought a good first place to start with gcov was the talloc test suite. When I started the test suite covered about 60% of all lines of code in talloc.c, and now it covers about 99%. The only lines not covered are talloc corruption errors, as that would cause smb_panic() to fire. It will be interesting to try gcov on the main Samba test suite for smbd. We won't achieve 100% coverage, but it would be nice to get to 90% or more. I also modified the talloc.c sources to be able to be build standalone, using: gcc -c -D_STANDALONE_ -Iinlcude lib/talloc.c that should make it much easier to re-use talloc in other projects (This used to be commit 8d4dc99b82efdf24b6811851c7bdd4af5a4c52c9)
2004-09-29 06:31:14 +00:00
ret &= test_misc();
ret &= test_realloc();
r4473: - moved talloc into its own lib/talloc/ area - added gcov flags to Makefile.talloc - expanded talloc testsuite to add a test for realloc with a child ptr - fixed a bug in talloc_realloc() with realloc of a ptr that has child ptrs (This used to be commit 98b5f73c1ba34d7576c5995069b485c1c5ede324)
2005-01-02 07:47:34 +00:00
ret &= test_realloc_child();
r2744: ben elliston taught me about gcov today, which allows you to measure the % coverage in terms of lines of code of a test suite. I thought a good first place to start with gcov was the talloc test suite. When I started the test suite covered about 60% of all lines of code in talloc.c, and now it covers about 99%. The only lines not covered are talloc corruption errors, as that would cause smb_panic() to fire. It will be interesting to try gcov on the main Samba test suite for smbd. We won't achieve 100% coverage, but it would be nice to get to 90% or more. I also modified the talloc.c sources to be able to be build standalone, using: gcc -c -D_STANDALONE_ -Iinlcude lib/talloc.c that should make it much easier to re-use talloc in other projects (This used to be commit 8d4dc99b82efdf24b6811851c7bdd4af5a4c52c9)
2004-09-29 06:31:14 +00:00
ret &= test_steal();
r4473: - moved talloc into its own lib/talloc/ area - added gcov flags to Makefile.talloc - expanded talloc testsuite to add a test for realloc with a child ptr - fixed a bug in talloc_realloc() with realloc of a ptr that has child ptrs (This used to be commit 98b5f73c1ba34d7576c5995069b485c1c5ede324)
2005-01-02 07:47:34 +00:00
ret &= test_unref_reparent();
r4790: added type checking helper macros in talloc. These take advantage of the type names that talloc already keeps around for pointers, and allows the user to type check void* private pointers. It can also be used to implement polymorphism in C, as I'm sure someone would have pointed out to me sooner or later :-) (This used to be commit c283e1a3efac3a92e29a35856e20eb61ef4c221e)
2005-01-16 23:21:52 +00:00
ret &= test_realloc_fn();
ret &= test_type();
r2791: got rid of talloc_unreference() and instead created talloc_unlink(), which is much clearer and simpler to use. It removes a specific parent from a pointer, no matter whether that parent is a "reference" or a direct parent. This gives complete control over the free process. (This used to be commit 6c563887f1b9b8c842309a523e88b6f2a32db10f)
2004-10-03 00:04:30 +00:00
if (ret) {
ret &= test_speed();
}
r2709: finally solved the talloc reference problem. The problem was that the simple "uint_t ref_count;" in a talloc chunk did not give enough information. It told us that a pointer was referenced more than once, but it didn't say who it was referenced by. This means that when the pointer was freed we had no sane way to clean up the reference. I have now replaced ref_count with a "refs" list, which means that references point to the pointer, and the pointer has a linked list of references. So now we can cleanup from either direction without losing track of anything. I've also added a LOCAL-TALLOC smbtorture test that tests talloc behaviour for some common uses. (This used to be commit 911a8d590cb184bcb892810729955c2c4cf02550)
2004-09-28 05:42:02 +00:00
r2718: - added a talloc_unreference() function as requested by metze. - added documentation for talloc_unreference() - made the abandoned child logic in talloc_free() clearer and more consistent (This used to be commit a87584c8e3fb06cd3ff29a918f681b5c6c32b9ff)
2004-09-28 11:54:17 +00:00
return ret;
r2709: finally solved the talloc reference problem. The problem was that the simple "uint_t ref_count;" in a talloc chunk did not give enough information. It told us that a pointer was referenced more than once, but it didn't say who it was referenced by. This means that when the pointer was freed we had no sane way to clean up the reference. I have now replaced ref_count with a "refs" list, which means that references point to the pointer, and the pointer has a linked list of references. So now we can cleanup from either direction without losing track of anything. I've also added a LOCAL-TALLOC smbtorture test that tests talloc behaviour for some common uses. (This used to be commit 911a8d590cb184bcb892810729955c2c4cf02550)
2004-09-28 05:42:02 +00:00
}
r2791: got rid of talloc_unreference() and instead created talloc_unlink(), which is much clearer and simpler to use. It removes a specific parent from a pointer, no matter whether that parent is a "reference" or a direct parent. This gives complete control over the free process. (This used to be commit 6c563887f1b9b8c842309a523e88b6f2a32db10f)
2004-10-03 00:04:30 +00:00
r4466: rather than defining "STANDALONE" for building tdb, ldb and talloc outside the tree, instead defined _SAMBA_BUILD_ inside the Samba build. This makes it easier to pull code out of Samba for external use. (This used to be commit 09e98c8745cca7ccb1ad7134c0c09b8e4c0f4f06)
2005-01-01 05:06:22 +00:00
#ifndef _SAMBA_BUILD_
r4473: - moved talloc into its own lib/talloc/ area - added gcov flags to Makefile.talloc - expanded talloc testsuite to add a test for realloc with a child ptr - fixed a bug in talloc_realloc() with realloc of a ptr that has child ptrs (This used to be commit 98b5f73c1ba34d7576c5995069b485c1c5ede324)
2005-01-02 07:47:34 +00:00
int main(void)
r2791: got rid of talloc_unreference() and instead created talloc_unlink(), which is much clearer and simpler to use. It removes a specific parent from a pointer, no matter whether that parent is a "reference" or a direct parent. This gives complete control over the free process. (This used to be commit 6c563887f1b9b8c842309a523e88b6f2a32db10f)
2004-10-03 00:04:30 +00:00
{
r4473: - moved talloc into its own lib/talloc/ area - added gcov flags to Makefile.talloc - expanded talloc testsuite to add a test for realloc with a child ptr - fixed a bug in talloc_realloc() with realloc of a ptr that has child ptrs (This used to be commit 98b5f73c1ba34d7576c5995069b485c1c5ede324)
2005-01-02 07:47:34 +00:00
if (!torture_local_talloc()) {
r2791: got rid of talloc_unreference() and instead created talloc_unlink(), which is much clearer and simpler to use. It removes a specific parent from a pointer, no matter whether that parent is a "reference" or a direct parent. This gives complete control over the free process. (This used to be commit 6c563887f1b9b8c842309a523e88b6f2a32db10f)
2004-10-03 00:04:30 +00:00
printf("ERROR: TESTSUIE FAILED\n");
return -1;
}
return 0;
}
#endif
Copy Permalink