Add tests

Signed-off-by: Mattias Andrée <maandree@kth.se>

12 files changed, 345 insertions, 8 deletions

diff --git a/libsimple/memelem.h b/libsimple/memelem.h
index cd71c3d..bce3e0c 100644
--- a/libsimple/memelem.h
+++ b/libsimple/memelem.h
@@ -98,7 +98,7 @@ void *libsimple_memrelem(const void *, size_t, const void *, size_t);
  *                     returned pointer and such that `(r - haystack) % nneedle == 0`
  */
 _LIBSIMPLE_GCC_ONLY(__attribute__((__pure__, __returns_nonnull__, __warn_unused_result__)))
-void *libsimple_rawmemrelem(const void *, size_t, const void *, size_t); /* TODO man */
+void *libsimple_rawmemrelem(const void *, size_t, const void *, size_t);
 #ifndef rawmemrelem
 # define rawmemrelem libsimple_rawmemrelem
 #endif
diff --git a/memelem.c b/memelem.c
index fbd16d7..29d6ed9 100644
--- a/memelem.c
+++ b/memelem.c
@@ -92,6 +92,11 @@ main(void)
 	assert(!libsimple_memelem("bc123abc123a", 4, "123", 3));
 	assert(!libsimple_memelem("abc123abc123", 0, "123", 3));
 
+	assert(!strcmpnul(libsimple_memelem("-a-aa--a", 4, "a-", 2), "a--a"));
+	assert(!strcmpnul(libsimple_memelem("--a--aa----a", 4, "a--", 3), "a----a"));
+	assert(!strcmpnul(libsimple_memelem("---a---aa------a", 4, "a---", 4), "a------a"));
+	assert(!strcmpnul(libsimple_memelem("-------a-------aa--------------a", 4, "a-------", 8), "a--------------a"));
+
 	return 0;
 }
 
diff --git a/memelem_inv.c b/memelem_inv.c
index 6c1d432..e393c4e 100644
--- a/memelem_inv.c
+++ b/memelem_inv.c
@@ -4,7 +4,7 @@
 
 
 void *
-libsimple_memelem_inv(const void *hay_, size_t hayn, const void *sub_, size_t subn) /* TODO test, man */
+libsimple_memelem_inv(const void *hay_, size_t hayn, const void *sub_, size_t subn) /* TODO man */
 {
 	switch (subn) {
 	case 0:
@@ -62,6 +62,50 @@ libsimple_memelem_inv(const void *hay_, size_t hayn, const void *sub_, size_t su
 int
 main(void)
 {
+	assert(!strcmpnul(libsimple_memelem_inv("xxoxx", 5, "x", 0), NULL));
+	assert(!strcmpnul(libsimple_memelem_inv("xxXxx", 5, "x", 0), NULL));
+	assert(!strcmpnul(libsimple_memelem_inv("XXoxx", 5, "x", 0), NULL));
+	assert(!strcmpnul(libsimple_memelem_inv("zzzzz", 5, "z", 0), NULL));
+	assert(!strcmpnul(libsimple_memelem_inv("zzzzx", 4, "z", 0), NULL));
+
+	assert(!strcmpnul(libsimple_memelem_inv("xxoxx", 5, "x", 1), "oxx"));
+	assert(!strcmpnul(libsimple_memelem_inv("xxXxx", 5, "x", 1), "Xxx"));
+	assert(!strcmpnul(libsimple_memelem_inv("XXoxx", 5, "x", 1), "XXoxx"));
+	assert(!strcmpnul(libsimple_memelem_inv("zzzzz", 5, "z", 1), NULL));
+	assert(!strcmpnul(libsimple_memelem_inv("zzzzx", 4, "z", 1), NULL));
+
+	assert(!strcmpnul(libsimple_memelem_inv("-x-x-o-x-x", 5, "-x", 2), "-o-x-x"));
+	assert(!strcmpnul(libsimple_memelem_inv("-x-x-X-x-x", 5, "-x", 2), "-X-x-x"));
+	assert(!strcmpnul(libsimple_memelem_inv("-X-X-o-x-x", 5, "-x", 2), "-X-X-o-x-x"));
+	assert(!strcmpnul(libsimple_memelem_inv("-z-z-z-z-z", 5, "-z", 2), NULL));
+	assert(!strcmpnul(libsimple_memelem_inv("-z-z-z-z-x", 4, "-z", 2), NULL));
+	assert(!strcmpnul(libsimple_memelem_inv("---z-z-z-x", 5, "--", 2), "-z-z-z-x"));
+
+	assert(!strcmpnul(libsimple_memelem_inv("--x--x--o--x--x", 5, "--x", 3), "--o--x--x"));
+	assert(!strcmpnul(libsimple_memelem_inv("--x--x--X--x--x", 5, "--x", 3), "--X--x--x"));
+	assert(!strcmpnul(libsimple_memelem_inv("--X--X--o--x--x", 5, "--x", 3), "--X--X--o--x--x"));
+	assert(!strcmpnul(libsimple_memelem_inv("--z--z--z--z--z", 5, "--z", 3), NULL));
+	assert(!strcmpnul(libsimple_memelem_inv("--z--z--z--z--x", 4, "--z", 3), NULL));
+	assert(!strcmpnul(libsimple_memelem_inv("-----z--z--z--x", 5, "---", 3), "--z--z--z--x"));
+
+	assert(!strcmpnul(libsimple_memelem_inv("---x---x---o---x---x", 5, "---x", 4), "---o---x---x"));
+	assert(!strcmpnul(libsimple_memelem_inv("---x---x---X---x---x", 5, "---x", 4), "---X---x---x"));
+	assert(!strcmpnul(libsimple_memelem_inv("---X---X---o---x---x", 5, "---x", 4), "---X---X---o---x---x"));
+	assert(!strcmpnul(libsimple_memelem_inv("---z---z---z---z---z", 5, "---z", 4), NULL));
+	assert(!strcmpnul(libsimple_memelem_inv("---z---z---z---z---x", 4, "---z", 4), NULL));
+	assert(!strcmpnul(libsimple_memelem_inv("-------z---z---z---x", 5, "----", 4), "---z---z---z---x"));
+
+	assert(!strcmpnul(libsimple_memelem_inv("-------x-------x-------o-------x-------x", 5, "-------x", 8),
+	                  "-------o-------x-------x"));
+	assert(!strcmpnul(libsimple_memelem_inv("-------x-------x-------X-------x-------x", 5, "-------x", 8),
+	                  "-------X-------x-------x"));
+	assert(!strcmpnul(libsimple_memelem_inv("-------X-------X-------o-------x-------x", 5, "-------x", 8),
+	                  "-------X-------X-------o-------x-------x"));
+	assert(!strcmpnul(libsimple_memelem_inv("-------z-------z-------z-------z-------z", 5, "-------z", 8), NULL));
+	assert(!strcmpnul(libsimple_memelem_inv("-------z-------z-------z-------z-------x", 4, "-------z", 8), NULL));
+	assert(!strcmpnul(libsimple_memelem_inv("---------------z-------z-------z-------x", 5, "--------", 8),
+	                  "-------z-------z-------z-------x"));
+
 	return 0;
 }
 
diff --git a/memelemscan.c b/memelemscan.c
index 48e490b..e713d54 100644
--- a/memelemscan.c
+++ b/memelemscan.c
@@ -85,6 +85,11 @@ main(void)
 	assert(!strcmpnul(libsimple_memelemscan("bc123abc123az", 4, "123", 3), "z"));
 	assert(!strcmpnul(libsimple_memelemscan("abc123abc123z", 0, "123", 3), "abc123abc123z"));
 
+	assert(!strcmpnul(libsimple_memelemscan("-a-aa--a", 4, "a-", 2), "a--a"));
+	assert(!strcmpnul(libsimple_memelemscan("--a--aa----a", 4, "a--", 3), "a----a"));
+	assert(!strcmpnul(libsimple_memelemscan("---a---aa------a", 4, "a---", 4), "a------a"));
+	assert(!strcmpnul(libsimple_memelemscan("-------a-------aa--------------a", 4, "a-------", 8), "a--------------a"));
+
 	return 0;
 }
 
diff --git a/memelemscan_inv.c b/memelemscan_inv.c
index 778ef8b..6311229 100644
--- a/memelemscan_inv.c
+++ b/memelemscan_inv.c
@@ -4,7 +4,7 @@
 
 
 void *
-libsimple_memelemscan_inv(const void *hay_, size_t hayn, const void *sub_, size_t subn) /* TODO test, man */
+libsimple_memelemscan_inv(const void *hay_, size_t hayn, const void *sub_, size_t subn) /* TODO man */
 {
 	switch (subn) {
 	case 0:
@@ -54,6 +54,51 @@ libsimple_memelemscan_inv(const void *hay_, size_t hayn, const void *sub_, size_
 int
 main(void)
 {
+	assert(!strcmpnul(libsimple_memelemscan_inv("xxoxx", 5, "x", 0), "xxoxx"));
+	assert(!strcmpnul(libsimple_memelemscan_inv("xxXxx", 5, "x", 0), "xxXxx"));
+	assert(!strcmpnul(libsimple_memelemscan_inv("XXoxx", 5, "x", 0), "XXoxx"));
+	assert(!strcmpnul(libsimple_memelemscan_inv("zzzzz", 5, "z", 0), "zzzzz"));
+	assert(!strcmpnul(libsimple_memelemscan_inv("zzzzx", 3, "z", 0), "zzzzx"));
+
+	assert(!strcmpnul(libsimple_memelemscan_inv("xxoxx", 5, "x", 1), "oxx"));
+	assert(!strcmpnul(libsimple_memelemscan_inv("xxXxx", 5, "x", 1), "Xxx"));
+	assert(!strcmpnul(libsimple_memelemscan_inv("XXoxx", 5, "x", 1), "XXoxx"));
+	assert(!strcmpnul(libsimple_memelemscan_inv("zzzzz", 5, "z", 1), ""));
+	assert(!strcmpnul(libsimple_memelemscan_inv("zzzzx", 3, "z", 1), "zx"));
+
+	assert(!strcmpnul(libsimple_memelemscan_inv("-x-x-o-x-x", 5, "-x", 2), "-o-x-x"));
+	assert(!strcmpnul(libsimple_memelemscan_inv("-x-x-X-x-x", 5, "-x", 2), "-X-x-x"));
+	assert(!strcmpnul(libsimple_memelemscan_inv("-X-X-o-x-x", 5, "-x", 2), "-X-X-o-x-x"));
+	assert(!strcmpnul(libsimple_memelemscan_inv("-z-z-z-z-z", 5, "-z", 2), ""));
+	assert(!strcmpnul(libsimple_memelemscan_inv("-z-z-z-z-x", 3, "-z", 2), "-z-x"));
+	assert(!strcmpnul(libsimple_memelemscan_inv("---z-z-z-x", 5, "--", 2), "-z-z-z-x"));
+
+	assert(!strcmpnul(libsimple_memelemscan_inv("--x--x--o--x--x", 5, "--x", 3), "--o--x--x"));
+	assert(!strcmpnul(libsimple_memelemscan_inv("--x--x--X--x--x", 5, "--x", 3), "--X--x--x"));
+	assert(!strcmpnul(libsimple_memelemscan_inv("--X--X--o--x--x", 5, "--x", 3), "--X--X--o--x--x"));
+	assert(!strcmpnul(libsimple_memelemscan_inv("--z--z--z--z--z", 5, "--z", 3), ""));
+	assert(!strcmpnul(libsimple_memelemscan_inv("--z--z--z--z--x", 3, "--z", 3), "--z--x"));
+	assert(!strcmpnul(libsimple_memelemscan_inv("-----z--z--z--x", 5, "---", 3), "--z--z--z--x"));
+
+	assert(!strcmpnul(libsimple_memelemscan_inv("---x---x---o---x---x", 5, "---x", 4), "---o---x---x"));
+	assert(!strcmpnul(libsimple_memelemscan_inv("---x---x---X---x---x", 5, "---x", 4), "---X---x---x"));
+	assert(!strcmpnul(libsimple_memelemscan_inv("---X---X---o---x---x", 5, "---x", 4), "---X---X---o---x---x"));
+	assert(!strcmpnul(libsimple_memelemscan_inv("---z---z---z---z---z", 5, "---z", 4), ""));
+	assert(!strcmpnul(libsimple_memelemscan_inv("---z---z---z---z---x", 3, "---z", 4), "---z---x"));
+	assert(!strcmpnul(libsimple_memelemscan_inv("-------z---z---z---x", 5, "----", 4), "---z---z---z---x"));
+
+	assert(!strcmpnul(libsimple_memelemscan_inv("-------x-------x-------o-------x-------x", 5, "-------x", 8),
+	                  "-------o-------x-------x"));
+	assert(!strcmpnul(libsimple_memelemscan_inv("-------x-------x-------X-------x-------x", 5, "-------x", 8),
+	                  "-------X-------x-------x"));
+	assert(!strcmpnul(libsimple_memelemscan_inv("-------X-------X-------o-------x-------x", 5, "-------x", 8),
+	                  "-------X-------X-------o-------x-------x"));
+	assert(!strcmpnul(libsimple_memelemscan_inv("-------z-------z-------z-------z-------z", 5, "-------z", 8), ""));
+	assert(!strcmpnul(libsimple_memelemscan_inv("-------z-------z-------z-------z-------x", 3, "-------z", 8),
+	                  "-------z-------x"));
+	assert(!strcmpnul(libsimple_memelemscan_inv("---------------z-------z-------z-------x", 5, "--------", 8),
+	                  "-------z-------z-------z-------x"));
+
 	return 0;
 }
 
diff --git a/memrelem.c b/memrelem.c
index 8121423..ca45136 100644
--- a/memrelem.c
+++ b/memrelem.c
@@ -100,6 +100,11 @@ main(void)
 	assert(!libsimple_memrelem("bc123abc123a", 4, "123", 3));
 	assert(!libsimple_memrelem("abc123abc123", 0, "123", 3));
 
+	assert(!strcmpnul(libsimple_memrelem("-a-aa--a", 4, "a-", 2), "a--a"));
+	assert(!strcmpnul(libsimple_memrelem("--a--aa----a", 4, "a--", 3), "a----a"));
+	assert(!strcmpnul(libsimple_memrelem("---a---aa------a", 4, "a---", 4), "a------a"));
+	assert(!strcmpnul(libsimple_memrelem("-------a-------aa--------------a", 4, "a-------", 8), "a--------------a"));
+
 	return 0;
 }
 
diff --git a/memrelem_inv.c b/memrelem_inv.c
index 5cadab1..10ba8b8 100644
--- a/memrelem_inv.c
+++ b/memrelem_inv.c
@@ -4,7 +4,7 @@
 
 
 void *
-libsimple_memrelem_inv(const void *hay_, size_t hayn, const void *sub_, size_t subn) /* TODO test, man */
+libsimple_memrelem_inv(const void *hay_, size_t hayn, const void *sub_, size_t subn) /* TODO man */
 {
 	switch (subn) {
 	case 0:
@@ -70,6 +70,66 @@ libsimple_memrelem_inv(const void *hay_, size_t hayn, const void *sub_, size_t s
 int
 main(void)
 {
+	assert(!strcmpnul(libsimple_memrelem_inv("aabbaabb", 8, "b", 0), NULL));
+	assert(!strcmpnul(libsimple_memrelem_inv("aabbaabb", 8, "B", 0), NULL));
+	assert(!strcmpnul(libsimple_memrelem_inv("AABBAABB", 8, "b", 0), NULL));
+	assert(!strcmpnul(libsimple_memrelem_inv("AABBAABB", 8, "B", 0), NULL));
+	assert(!strcmpnul(libsimple_memrelem_inv("aabbaabb", 8, "a", 0), NULL));
+	assert(!strcmpnul(libsimple_memrelem_inv("aabbbb\0\0", 8, "\0", 0), NULL));
+	assert(!strcmpnul(libsimple_memrelem_inv("--------", 8, "-", 0), NULL));
+
+	assert(!strcmpnul(libsimple_memrelem_inv("aabbaabb", 8, "b", 1), "abb"));
+	assert(!strcmpnul(libsimple_memrelem_inv("aabbaabb", 8, "B", 1), "b"));
+	assert(!strcmpnul(libsimple_memrelem_inv("AABBAABB", 8, "b", 1), "B"));
+	assert(!strcmpnul(libsimple_memrelem_inv("AABBAABB", 8, "B", 1), "ABB"));
+	assert(!strcmpnul(libsimple_memrelem_inv("aabbaabb", 8, "a", 1), "b"));
+	assert(!strcmpnul(libsimple_memrelem_inv("aabbbb\0\0", 8, "\0", 1), "b"));
+	assert(!strcmpnul(libsimple_memrelem_inv("--------", 8, "-", 1), NULL));
+
+	assert(!strcmpnul(libsimple_memrelem_inv("-a-a-b-b-a-a-b-b", 8, "-b", 2), "-a-b-b"));
+	assert(!strcmpnul(libsimple_memrelem_inv("-a-a-b-b-a-a-b-b", 8, "-B", 2), "-b"));
+	assert(!strcmpnul(libsimple_memrelem_inv("-A-A-B-B-A-A-B-B", 8, "-b", 2), "-B"));
+	assert(!strcmpnul(libsimple_memrelem_inv("-A-A-B-B-A-A-B-B", 8, "-B", 2), "-A-B-B"));
+	assert(!strcmpnul(libsimple_memrelem_inv("-a-a-b-b-a-a-b-b", 8, "-a", 2), "-b"));
+	assert(!strcmpnul(libsimple_memrelem_inv("-a-a-b-b-b-b\0\0\0\0", 8, "\0\0", 2), "-b"));
+	assert(!strcmpnul(libsimple_memrelem_inv("-x-x-x-x-x-x-x-x", 8, "-x", 2), NULL));
+
+	assert(!strcmpnul(libsimple_memrelem_inv("--a--a--b--b--a--a--b--b", 8, "--b", 3), "--a--b--b"));
+	assert(!strcmpnul(libsimple_memrelem_inv("--a--a--b--b--a--a--b--b", 8, "--B", 3), "--b"));
+	assert(!strcmpnul(libsimple_memrelem_inv("--A--A--B--B--A--A--B--B", 8, "--b", 3), "--B"));
+	assert(!strcmpnul(libsimple_memrelem_inv("--A--A--B--B--A--A--B--B", 8, "--B", 3), "--A--B--B"));
+	assert(!strcmpnul(libsimple_memrelem_inv("--a--a--b--b--a--a--b--b", 8, "--a", 3), "--b"));
+	assert(!strcmpnul(libsimple_memrelem_inv("--a--a--b--b--b--b\0\0\0\0\0\0", 8, "\0\0\0", 3), "--b"));
+	assert(!strcmpnul(libsimple_memrelem_inv("--x--x--x--x--x--x--x--x", 8, "--x", 3), NULL));
+
+	assert(!strcmpnul(libsimple_memrelem_inv("---a---a---b---b---a---a---b---b", 8, "---b", 4), "---a---b---b"));
+	assert(!strcmpnul(libsimple_memrelem_inv("---a---a---b---b---a---a---b---b", 8, "---B", 4), "---b"));
+	assert(!strcmpnul(libsimple_memrelem_inv("---A---A---B---B---A---A---B---B", 8, "---b", 4), "---B"));
+	assert(!strcmpnul(libsimple_memrelem_inv("---A---A---B---B---A---A---B---B", 8, "---B", 4), "---A---B---B"));
+	assert(!strcmpnul(libsimple_memrelem_inv("---a---a---b---b---a---a---b---b", 8, "---a", 4), "---b"));
+	assert(!strcmpnul(libsimple_memrelem_inv("---a---a---b---b---b---b\0\0\0\0\0\0\0\0", 8, "\0\0\0\0", 4), "---b"));
+	assert(!strcmpnul(libsimple_memrelem_inv("---x---x---x---x---x---x---x---x", 8, "---x", 4), NULL));
+
+	assert(!strcmpnul(libsimple_memrelem_inv("-------a-------a-------b-------b-------a-------a-------b-------b", 8, "-------b", 8),
+	                  "-------a-------b-------b"));
+	assert(!strcmpnul(libsimple_memrelem_inv("-------a-------a-------b-------b-------a-------a-------b-------b", 8, "-------B", 8),
+	                  "-------b"));
+	assert(!strcmpnul(libsimple_memrelem_inv("-------A-------A-------B-------B-------A-------A-------B-------B", 8, "-------b", 8),
+	                  "-------B"));
+	assert(!strcmpnul(libsimple_memrelem_inv("-------A-------A-------B-------B-------A-------A-------B-------B", 8, "-------B", 8),
+	                  "-------A-------B-------B"));
+	assert(!strcmpnul(libsimple_memrelem_inv("-------a-------a-------b-------b-------a-------a-------b-------b", 8, "-------a", 8),
+	                  "-------b"));
+	assert(!strcmpnul(libsimple_memrelem_inv("-------a-------a-------b-------b-------b-------b\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0", 8,
+	                  "\0\0\0\0\0\0\0\0", 8), "-------b"));
+	assert(!strcmpnul(libsimple_memrelem_inv("-------x-------x-------x-------x-------x-------x-------x-------x", 8, "-------x", 8),
+	                  NULL));
+
+	assert(!strcmpnul(libsimple_memrelem_inv("aaaa-aaa", 4, "aa", 2), "-aaa"));
+	assert(!strcmpnul(libsimple_memrelem_inv("aaaaaa-aaaaa", 4, "aaa", 3), "-aaaaa"));
+	assert(!strcmpnul(libsimple_memrelem_inv("aaaaaaaa-aaaaaaa", 4, "aaaa", 4), "-aaaaaaa"));
+	assert(!strcmpnul(libsimple_memrelem_inv("aaaaaaaaaaaaaaaa-aaaaaaaaaaaaaaa", 4, "aaaaaaaa", 8), "-aaaaaaaaaaaaaaa"));
+
 	return 0;
 }
 
diff --git a/memreplaceelem.c b/memreplaceelem.c
index 1620d5c..fc4762d 100644
--- a/memreplaceelem.c
+++ b/memreplaceelem.c
@@ -4,7 +4,7 @@
 
 
 void *
-libsimple_memreplaceelem(void *restrict s_, const void *old_, const void *new_, size_t n, size_t width) /* TODO test, man */
+libsimple_memreplaceelem(void *restrict s_, const void *old_, const void *new_, size_t n, size_t width) /* TODO man */
 {
 	switch (width) {
 	case 0:
@@ -77,6 +77,95 @@ libsimple_memreplaceelem(void *restrict s_, const void *old_, const void *new_,
 int
 main(void)
 {
+	char buf[1024];
+
+	stpcpy(mempcpy(buf, "hello world", 12), "goodbye world");
+	assert(libsimple_memreplaceelem(buf, "o", "x", 46, 0) == &buf[0]);
+	assert(!memcmp(buf, "hello world\0goodbye world", 26));
+
+	stpcpy(mempcpy(buf, "hello world", 12), "goodbye world");
+	assert(libsimple_memreplaceelem(buf, "o", "x", 12, 0) == &buf[0]);
+	assert(!memcmp(buf, "hello world\0goodbye world", 26));
+
+
+	stpcpy(mempcpy(buf, "hello world", 12), "goodbye world");
+	assert(libsimple_memreplaceelem(buf, "o", "x", 46, 1) == &buf[46]);
+	assert(!memcmp(buf, "hellx wxrld\0gxxdbye wxrld", 26));
+
+	stpcpy(mempcpy(buf, "hello world", 12), "goodbye world");
+	assert(libsimple_memreplaceelem(buf, "o", "x", 12, 1) == &buf[12]);
+	assert(!memcmp(buf, "hellx wxrld\0goodbye world", 26));
+
+
+	stpcpy(mempcpy(buf, "-h-e-l-l-o- -w-o-r-l-d\0", 12 * 2), "-g-o-o-d-b-y-e- -w-o-r-l-d");
+	assert(libsimple_memreplaceelem(buf, "-o", "=x", 46, 2) == &buf[46 * 2]);
+	assert(!memcmp(buf, "-h-e-l-l=x- -w=x-r-l-d\0\0-g=x=x-d-b-y-e- -w=x-r-l-d", 25 * 2 + 1));
+
+	stpcpy(mempcpy(buf, "-h-e-l-l-o- -w-o-r-l-d\0", 12 * 2), "-g-o-o-d-b-y-e- -w-o-r-l-d");
+	assert(libsimple_memreplaceelem(buf, "-o", "=x", 12, 2) == &buf[12 * 2]);
+	assert(!memcmp(buf, "-h-e-l-l=x- -w=x-r-l-d\0\0-g-o-o-d-b-y-e- -w-o-r-l-d", 25 * 2 + 1));
+
+	stpcpy(mempcpy(buf, "-h-e-l-l-o- -w-o-r-l-d\0", 12 * 2), "-g-o-o-d-b-y-e- -w-o-r-l-d");
+	assert(libsimple_memreplaceelem(buf, "o-", "x=", 12, 2) == &buf[12 * 2]);
+	assert(!memcmp(buf, "-h-e-l-l-o- -w-o-r-l-d\0\0-g-o-o-d-b-y-e- -w-o-r-l-d", 25 * 2 + 1));
+
+
+	stpcpy(mempcpy(buf, "--h--e--l--l--o-- --w--o--r--l--d\0\0", 12 * 3), "--g--o--o--d--b--y--e-- --w--o--r--l--d");
+	assert(libsimple_memreplaceelem(buf, "--o", "==x", 46, 3) == &buf[46 * 3]);
+	assert(!memcmp(buf, "--h--e--l--l==x-- --w==x--r--l--d\0\0\0--g==x==x--d--b--y--e-- --w==x--r--l--d", 25 * 3 + 1));
+
+	stpcpy(mempcpy(buf, "--h--e--l--l--o-- --w--o--r--l--d\0\0", 12 * 3), "--g--o--o--d--b--y--e-- --w--o--r--l--d");
+	assert(libsimple_memreplaceelem(buf, "--o", "==x", 12, 3) == &buf[12 * 3]);
+	assert(!memcmp(buf, "--h--e--l--l==x-- --w==x--r--l--d\0\0\0--g--o--o--d--b--y--e-- --w--o--r--l--d", 25 * 3 + 1));
+
+	stpcpy(mempcpy(buf, "--h--e--l--l--o-- --w--o--r--l--d\0\0", 12 * 3), "--g--o--o--d--b--y--e-- --w--o--r--l--d");
+	assert(libsimple_memreplaceelem(buf, "o--", "x==", 12, 3) == &buf[12 * 3]);
+	assert(!memcmp(buf, "--h--e--l--l--o-- --w--o--r--l--d\0\0\0--g--o--o--d--b--y--e-- --w--o--r--l--d", 25 * 3 + 1));
+
+
+	stpcpy(mempcpy(buf, "---h---e---l---l---o--- ---w---o---r---l---d\0\0\0", 12 * 4),
+	       "---g---o---o---d---b---y---e--- ---w---o---r---l---d");
+	assert(libsimple_memreplaceelem(buf, "---o", "===x", 46, 4) == &buf[46 * 4]);
+	assert(!memcmp(buf, "---h---e---l---l===x--- ---w===x---r---l---d\0\0\0\0"
+	                    "---g===x===x---d---b---y---e--- ---w===x---r---l---d", 25 * 4 + 1));
+
+	stpcpy(mempcpy(buf, "---h---e---l---l---o--- ---w---o---r---l---d\0\0\0", 12 * 4),
+	       "---g---o---o---d---b---y---e--- ---w---o---r---l---d");
+	assert(libsimple_memreplaceelem(buf, "---o", "===x", 12, 4) == &buf[12 * 4]);
+	assert(!memcmp(buf, "---h---e---l---l===x--- ---w===x---r---l---d\0\0\0\0"
+	                    "---g---o---o---d---b---y---e--- ---w---o---r---l---d", 25 * 4 + 1));
+
+	stpcpy(mempcpy(buf, "---h---e---l---l---o--- ---w---o---r---l---d\0\0\0", 12 * 4),
+	       "---g---o---o---d---b---y---e--- ---w---o---r---l---d");
+	assert(libsimple_memreplaceelem(buf, "o---", "x===", 12, 4) == &buf[12 * 4]);
+	assert(!memcmp(buf, "---h---e---l---l---o--- ---w---o---r---l---d\0\0\0\0"
+	                    "---g---o---o---d---b---y---e--- ---w---o---r---l---d", 25 * 4 + 1));
+
+
+	stpcpy(mempcpy(buf, "-------h-------e-------l-------l-------o------- -------w-------o-------r-------l-------d\0\0\0\0\0\0\0",
+	               12 * 8),
+	       "-------g-------o-------o-------d-------b-------y-------e------- -------w-------o-------r-------l-------d");
+	assert(libsimple_memreplaceelem(buf, "-------o", "=======x", 46, 8) == &buf[46 * 8]);
+	assert(!memcmp(buf, "-------h-------e-------l-------l=======x------- -------w=======x-------r-------l-------d\0\0\0\0\0\0\0\0"
+	                    "-------g=======x=======x-------d-------b-------y-------e------- "
+	                    "-------w=======x-------r-------l-------d", 25 * 8 + 1));
+
+	stpcpy(mempcpy(buf, "-------h-------e-------l-------l-------o------- -------w-------o-------r-------l-------d\0\0\0\0\0\0\0",
+	               12 * 8),
+	       "-------g-------o-------o-------d-------b-------y-------e------- -------w-------o-------r-------l-------d");
+	assert(libsimple_memreplaceelem(buf, "-------o", "=======x", 12, 8) == &buf[12 * 8]);
+	assert(!memcmp(buf, "-------h-------e-------l-------l=======x------- -------w=======x-------r-------l-------d\0\0\0\0\0\0\0\0"
+	                    "-------g-------o-------o-------d-------b-------y-------e------- "
+	                    "-------w-------o-------r-------l-------d", 25 * 8 + 1));
+
+	stpcpy(mempcpy(buf, "-------h-------e-------l-------l-------o------- -------w-------o-------r-------l-------d\0\0\0\0\0\0\0",
+	               12 * 8),
+	       "-------g-------o-------o-------d-------b-------y-------e------- -------w-------o-------r-------l-------d");
+	assert(libsimple_memreplaceelem(buf, "o-------", "x=======", 12, 8) == &buf[12 * 8]);
+	assert(!memcmp(buf, "-------h-------e-------l-------l-------o------- -------w-------o-------r-------l-------d\0\0\0\0\0\0\0\0"
+	                    "-------g-------o-------o-------d-------b-------y-------e------- "
+	                    "-------w-------o-------r-------l-------d", 25 * 8 + 1));
+
 	return 0;
 }
 
diff --git a/rawmemelem.c b/rawmemelem.c
index ba21a32..d2d743a 100644
--- a/rawmemelem.c
+++ b/rawmemelem.c
@@ -62,6 +62,11 @@ main(void)
 	assert(!strcmpnul(libsimple_rawmemelem("abcd1234abcd1234", "1234", 4), "1234abcd1234"));
 	assert(!strcmpnul(libsimple_rawmemelem("abcdefgh12345678abcdefgh12345678", "12345678", 8), "12345678abcdefgh12345678"));
 	assert(!strcmpnul(libsimple_rawmemelem("abc123abc123", "123", 3), "123abc123"));
+
+	assert(!strcmpnul(libsimple_rawmemelem("-a-aa--a", "a-", 2), "a--a"));
+	assert(!strcmpnul(libsimple_rawmemelem("--a--aa----a", "a--", 3), "a----a"));
+	assert(!strcmpnul(libsimple_rawmemelem("---a---aa------a", "a---", 4), "a------a"));
+	assert(!strcmpnul(libsimple_rawmemelem("-------a-------aa--------------a", "a-------", 8), "a--------------a"));
 	return 0;
 }
 
diff --git a/rawmemelem_inv.c b/rawmemelem_inv.c
index aeb20d2..88fcc6d 100644
--- a/rawmemelem_inv.c
+++ b/rawmemelem_inv.c
@@ -4,7 +4,7 @@
 
 
 void *
-libsimple_rawmemelem_inv(const void *hay_, const void *sub_, size_t subn) /* TODO test, man */
+libsimple_rawmemelem_inv(const void *hay_, const void *sub_, size_t subn) /* TODO man */
 {
 	switch (subn) {
 	case 0:
@@ -52,6 +52,34 @@ libsimple_rawmemelem_inv(const void *hay_, const void *sub_, size_t subn) /* TOD
 int
 main(void)
 {
+	assert(!strcmpnul(libsimple_rawmemelem_inv("xxoxx", "x", 1), "oxx"));
+	assert(!strcmpnul(libsimple_rawmemelem_inv("xxXxx", "x", 1), "Xxx"));
+	assert(!strcmpnul(libsimple_rawmemelem_inv("XXoxx", "x", 1), "XXoxx"));
+
+	assert(!strcmpnul(libsimple_rawmemelem_inv("-x-x-o-x-x", "-x", 2), "-o-x-x"));
+	assert(!strcmpnul(libsimple_rawmemelem_inv("-x-x-X-x-x", "-x", 2), "-X-x-x"));
+	assert(!strcmpnul(libsimple_rawmemelem_inv("-X-X-o-x-x", "-x", 2), "-X-X-o-x-x"));
+	assert(!strcmpnul(libsimple_rawmemelem_inv("---X-o-x-x", "--", 2), "-X-o-x-x"));
+
+	assert(!strcmpnul(libsimple_rawmemelem_inv("--x--x--o--x--x", "--x", 3), "--o--x--x"));
+	assert(!strcmpnul(libsimple_rawmemelem_inv("--x--x--X--x--x", "--x", 3), "--X--x--x"));
+	assert(!strcmpnul(libsimple_rawmemelem_inv("--X--X--o--x--x", "--x", 3), "--X--X--o--x--x"));
+	assert(!strcmpnul(libsimple_rawmemelem_inv("-----X--o--x--x", "---", 3), "--X--o--x--x"));
+
+	assert(!strcmpnul(libsimple_rawmemelem_inv("---x---x---o---x---x", "---x", 4), "---o---x---x"));
+	assert(!strcmpnul(libsimple_rawmemelem_inv("---x---x---X---x---x", "---x", 4), "---X---x---x"));
+	assert(!strcmpnul(libsimple_rawmemelem_inv("---X---X---o---x---x", "---x", 4), "---X---X---o---x---x"));
+	assert(!strcmpnul(libsimple_rawmemelem_inv("-------X---o---x---x", "----", 4), "---X---o---x---x"));
+
+	assert(!strcmpnul(libsimple_rawmemelem_inv("-------x-------x-------o-------x-------x", "-------x", 8),
+	                  "-------o-------x-------x"));
+	assert(!strcmpnul(libsimple_rawmemelem_inv("-------x-------x-------X-------x-------x", "-------x", 8),
+	                  "-------X-------x-------x"));
+	assert(!strcmpnul(libsimple_rawmemelem_inv("-------X-------X-------o-------x-------x", "-------x", 8),
+	                  "-------X-------X-------o-------x-------x"));
+	assert(!strcmpnul(libsimple_rawmemelem_inv("---------------X-------o-------x-------x", "--------", 8),
+	                  "-------X-------o-------x-------x"));
+
 	return 0;
 }
 
diff --git a/rawmemrelem.c b/rawmemrelem.c
index 75a15a9..4e93b5c 100644
--- a/rawmemrelem.c
+++ b/rawmemrelem.c
@@ -4,7 +4,7 @@
 
 
 void *
-libsimple_rawmemrelem(const void *hay_, size_t hayn, const void *sub_, size_t subn)
+libsimple_rawmemrelem(const void *hay_, size_t hayn, const void *sub_, size_t subn) /* TODO man */
 {
 	switch (subn) {
 	case 0:
@@ -68,6 +68,11 @@ main(void)
 	assert(!strcmpnul(libsimple_rawmemrelem("abcd1234abcd1234", 4, "1234", 4), "1234"));
 	assert(!strcmpnul(libsimple_rawmemrelem("abcdefgh12345678abcdefgh12345678", 4, "12345678", 8), "12345678"));
 	assert(!strcmpnul(libsimple_rawmemrelem("abc123abc123", 4, "123", 3), "123"));
+
+	assert(!strcmpnul(libsimple_rawmemrelem("-aa--a-a", 4, "a-", 2), "a--a-a"));
+	assert(!strcmpnul(libsimple_rawmemrelem("--aa----a--a", 4, "a--", 3), "a----a--a"));
+	assert(!strcmpnul(libsimple_rawmemrelem("---aa------a---a", 4, "a---", 4), "a------a---a"));
+	assert(!strcmpnul(libsimple_rawmemrelem("-------aa--------------a-------a", 4, "a-------", 8), "a--------------a-------a"));
 	return 0;
 }
 
diff --git a/rawmemrelem_inv.c b/rawmemrelem_inv.c
index 6c714cf..c4141e5 100644
--- a/rawmemrelem_inv.c
+++ b/rawmemrelem_inv.c
@@ -4,7 +4,7 @@
 
 
 void *
-libsimple_rawmemrelem_inv(const void *hay_, size_t hayn, const void *sub_, size_t subn) /* TODO test, man */
+libsimple_rawmemrelem_inv(const void *hay_, size_t hayn, const void *sub_, size_t subn) /* TODO man */
 {
 	switch (subn) {
 	case 0:
@@ -59,6 +59,52 @@ libsimple_rawmemrelem_inv(const void *hay_, size_t hayn, const void *sub_, size_
 int
 main(void)
 {
+	assert(!strcmpnul(libsimple_rawmemrelem_inv("aabbaabb", 8, "b", 1), "abb"));
+	assert(!strcmpnul(libsimple_rawmemrelem_inv("aabbaabb", 8, "B", 1), "b"));
+	assert(!strcmpnul(libsimple_rawmemrelem_inv("AABBAABB", 8, "b", 1), "B"));
+	assert(!strcmpnul(libsimple_rawmemrelem_inv("AABBAABB", 8, "B", 1), "ABB"));
+	assert(!strcmpnul(libsimple_rawmemrelem_inv("aabbaabb", 8, "a", 1), "b"));
+	assert(!strcmpnul(libsimple_rawmemrelem_inv("aabbbb\0\0", 8, "\0", 1), "b"));
+
+	assert(!strcmpnul(libsimple_rawmemrelem_inv("-a-a-b-b-a-a-b-b", 8, "-b", 2), "-a-b-b"));
+	assert(!strcmpnul(libsimple_rawmemrelem_inv("-a-a-b-b-a-a-b-b", 8, "-B", 2), "-b"));
+	assert(!strcmpnul(libsimple_rawmemrelem_inv("-A-A-B-B-A-A-B-B", 8, "-b", 2), "-B"));
+	assert(!strcmpnul(libsimple_rawmemrelem_inv("-A-A-B-B-A-A-B-B", 8, "-B", 2), "-A-B-B"));
+	assert(!strcmpnul(libsimple_rawmemrelem_inv("-a-a-b-b-a-a-b-b", 8, "-a", 2), "-b"));
+	assert(!strcmpnul(libsimple_rawmemrelem_inv("-a-a-b-b-b-b\0\0\0\0", 8, "\0\0", 2), "-b"));
+
+	assert(!strcmpnul(libsimple_rawmemrelem_inv("--a--a--b--b--a--a--b--b", 8, "--b", 3), "--a--b--b"));
+	assert(!strcmpnul(libsimple_rawmemrelem_inv("--a--a--b--b--a--a--b--b", 8, "--B", 3), "--b"));
+	assert(!strcmpnul(libsimple_rawmemrelem_inv("--A--A--B--B--A--A--B--B", 8, "--b", 3), "--B"));
+	assert(!strcmpnul(libsimple_rawmemrelem_inv("--A--A--B--B--A--A--B--B", 8, "--B", 3), "--A--B--B"));
+	assert(!strcmpnul(libsimple_rawmemrelem_inv("--a--a--b--b--a--a--b--b", 8, "--a", 3), "--b"));
+	assert(!strcmpnul(libsimple_rawmemrelem_inv("--a--a--b--b--b--b\0\0\0\0\0\0", 8, "\0\0\0", 3), "--b"));
+
+	assert(!strcmpnul(libsimple_rawmemrelem_inv("---a---a---b---b---a---a---b---b", 8, "---b", 4), "---a---b---b"));
+	assert(!strcmpnul(libsimple_rawmemrelem_inv("---a---a---b---b---a---a---b---b", 8, "---B", 4), "---b"));
+	assert(!strcmpnul(libsimple_rawmemrelem_inv("---A---A---B---B---A---A---B---B", 8, "---b", 4), "---B"));
+	assert(!strcmpnul(libsimple_rawmemrelem_inv("---A---A---B---B---A---A---B---B", 8, "---B", 4), "---A---B---B"));
+	assert(!strcmpnul(libsimple_rawmemrelem_inv("---a---a---b---b---a---a---b---b", 8, "---a", 4), "---b"));
+	assert(!strcmpnul(libsimple_rawmemrelem_inv("---a---a---b---b---b---b\0\0\0\0\0\0\0\0", 8, "\0\0\0\0", 4), "---b"));
+
+	assert(!strcmpnul(libsimple_rawmemrelem_inv("-------a-------a-------b-------b-------a-------a-------b-------b", 8,
+	                                            "-------b", 8), "-------a-------b-------b"));
+	assert(!strcmpnul(libsimple_rawmemrelem_inv("-------a-------a-------b-------b-------a-------a-------b-------b", 8,
+	                                            "-------B", 8), "-------b"));
+	assert(!strcmpnul(libsimple_rawmemrelem_inv("-------A-------A-------B-------B-------A-------A-------B-------B", 8,
+	                                            "-------b", 8), "-------B"));
+	assert(!strcmpnul(libsimple_rawmemrelem_inv("-------A-------A-------B-------B-------A-------A-------B-------B", 8,
+	                                            "-------B", 8), "-------A-------B-------B"));
+	assert(!strcmpnul(libsimple_rawmemrelem_inv("-------a-------a-------b-------b-------a-------a-------b-------b", 8,
+	                                            "-------a", 8), "-------b"));
+	assert(!strcmpnul(libsimple_rawmemrelem_inv("-------a-------a-------b-------b-------b-------b"
+	                                            "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0", 8, "\0\0\0\0\0\0\0\0", 8), "-------b"));
+
+	assert(!strcmpnul(libsimple_rawmemrelem_inv("aaaa-aaa", 4, "aa", 2), "-aaa"));
+	assert(!strcmpnul(libsimple_rawmemrelem_inv("aaaaaa-aaaaa", 4, "aaa", 3), "-aaaaa"));
+	assert(!strcmpnul(libsimple_rawmemrelem_inv("aaaaaaaa-aaaaaaa", 4, "aaaa", 4), "-aaaaaaa"));
+	assert(!strcmpnul(libsimple_rawmemrelem_inv("aaaaaaaaaaaaaaaa-aaaaaaaaaaaaaaa", 4, "aaaaaaaa", 8), "-aaaaaaaaaaaaaaa"));
+
 	return 0;
 }