rmultimarkdown 6.2.2.1 → 6.4.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4f0aaf2e4578f029b57651048a9fe007addc2b7e
-  data.tar.gz: 533529a83e637367139cd68245606400262d0296
+  metadata.gz: 1014dc60ab5f2b6f2a75676afb5277d454d85375
+  data.tar.gz: 95e5652fde10146a1b110674ae68065bd4967420
 SHA512:
-  metadata.gz: 615409a10996e6a2720369e7b301cc07e24832b974944d73e899639c5cfb7c212aff6bcfd49247b1cf3625269e13f212e2142acd4f0c8d4a6f92e27c978a2e18
-  data.tar.gz: b0a4b8f9e386eb5d9c0fe6581e27a5a1642c54a38462cb0ebc3dacb358ac7fab7892dca4330d7627c50b333458072844a3272e6464a5568b1f3ce2e6ca31470c
+  metadata.gz: 180941d10b28d4062792e8b1b448c2c3948969859f9e7f8aeab2f23f55e5d3c27eb3f7537c240fad3cc6f103431f14f6e1446ba63b7af1ed38e9d9eeff08d077
+  data.tar.gz: ffb6e4b40683fa51fc47673d2df9ab4716a9dc1d37f43a6670bb260abec10b9559ba56b2f3dbf5fcf08a29fcf92b0dfcc497af6098058d86fe51137b12102b2b

data/ext/Makefile

@@ -136,8 +136,8 @@ target_prefix =
 LOCAL_LIBS = 
 LIBS =   -lpthread -lgmp -ldl -lobjc 
 ORIG_SRCS = ruby_multi_markdown.c
-SRCS = $(ORIG_SRCS) aho-corasick.c beamer.c char.c char_lookup.c critic_markup.c d_string.c epub.c fodt.c html.c latex.c lexer.c memoir.c miniz.c mmd.c object_pool.c opendocument-content.c opendocument.c parser.c rng.c scanners.c stack.c textbundle.c token.c token_pairs.c transclude.c uuid.c writer.c zip.c ruby_multi_markdown.c
-OBJS = mmd/aho-corasick.o mmd/beamer.o mmd/char.o mmd/char_lookup.o mmd/critic_markup.o mmd/d_string.o mmd/epub.o mmd/fodt.o mmd/html.o mmd/latex.o mmd/lexer.o mmd/memoir.o mmd/miniz.o mmd/mmd.o mmd/object_pool.o mmd/opendocument-content.o mmd/opendocument.o mmd/parser.o mmd/rng.o mmd/scanners.o mmd/stack.o mmd/textbundle.o mmd/token.o mmd/token_pairs.o mmd/transclude.o mmd/uuid.o mmd/writer.o mmd/zip.o ruby_multi_markdown.o
+SRCS = $(ORIG_SRCS) memoir.c object_pool.c char_lookup.c textbundle.c miniz.c char.c writer.c beamer.c latex.c stack.c zip.c opendocument.c d_string.c lexer.c token.c transclude.c aho-corasick.c mmd.c uuid.c opml-reader.c html.c epub.c file.c critic_markup.c scanners.c opml-lexer.c parser.c opendocument-content.c opml-parser.c opml.c token_pairs.c rng.c ruby_multi_markdown.c
+OBJS = mmd/memoir.o mmd/object_pool.o mmd/char_lookup.o mmd/textbundle.o mmd/miniz.o mmd/char.o mmd/writer.o mmd/beamer.o mmd/latex.o mmd/stack.o mmd/zip.o mmd/opendocument.o mmd/d_string.o mmd/lexer.o mmd/token.o mmd/transclude.o mmd/aho-corasick.o mmd/mmd.o mmd/uuid.o mmd/opml-reader.o mmd/html.o mmd/epub.o mmd/file.o mmd/critic_markup.o mmd/scanners.o mmd/opml-lexer.o mmd/parser.o mmd/opendocument-content.o mmd/opml-parser.o mmd/opml.o mmd/token_pairs.o mmd/rng.o ruby_multi_markdown.o
 HDRS = $(srcdir)/extconf.h
 TARGET = multi_markdown
 TARGET_NAME = multi_markdown

data/ext/mmd/aho-corasick.c

@@ -285,7 +285,7 @@ void ac_trie_node_prepare(trie * a, size_t s, char * buffer, unsigned short dept
 	// Prepare children
 	for (int i = 0; i < 256; ++i) {
 		if ((n->child[i] != 0) &&
-		        (n->child[i] != s)) {
+				(n->child[i] != s)) {
 			buffer[depth] = i;
 
 			ac_trie_node_prepare(a, n->child[i], buffer, depth + 1, last_match_state);
@@ -403,7 +403,7 @@ match * ac_trie_search(trie * a, const char * source, size_t start, size_t len)
 				}
 
 				m = match_add(m, counter - a->node[temp_state].len,
-				              a->node[temp_state].len, a->node[temp_state].match_type);
+							  a->node[temp_state].len, a->node[temp_state].match_type);
 			}
 
 			// Iterate to find shorter matches
@@ -445,7 +445,7 @@ int match_count(match * m) {
 
 void match_describe(match * m, const char * source) {
 	fprintf(stderr, "'%.*s'(%d) at %lu:%lu\n", (int)m->len, &source[m->start],
-	        m->match_type, m->start, m->start + m->len);
+			m->match_type, m->start, m->start + m->len);
 }
 
 
@@ -475,14 +475,16 @@ void match_set_filter_leftmost_longest(match * header) {
 			}
 
 			while (m->next &&
-			        m->next->start > m->start &&
-			        m->next->start < m->start + m->len) {
+					m->next->start > m->start &&
+					m->next->start < m->start + m->len) {
 				// This match is "lefter" than next
+				#ifndef __clang_analyzer__
 				match_excise(m->next);
+				#endif
 			}
 
 			while (m->next &&
-			        m->next->start < m->start) {
+					m->next->start < m->start) {
 				// Next match is "lefter" than us
 				n = m;
 				m = m->prev;
@@ -491,11 +493,13 @@ void match_set_filter_leftmost_longest(match * header) {
 		}
 
 		while (m->prev &&
-		        m->prev->len &&
-		        m->prev->start >= m->start) {
+				m->prev->len &&
+				m->prev->start >= m->start) {
 			// We are "lefter" than previous
 			n = m->prev;
+			#ifndef __clang_analyzer__
 			match_excise(n);
+			#endif
 		}
 
 		m = m->next;

data/ext/mmd/beamer.c

@@ -55,6 +55,7 @@
 
 #include "latex.h"
 #include "beamer.h"
+#include "parser.h"
 
 #define print(x) d_string_append(out, x)
 #define print_const(x) d_string_append_c_array(out, x, sizeof(x) - 1)
@@ -173,6 +174,33 @@ void mmd_export_token_beamer(DString * out, const char * source, token * t, scra
 			temp_char = get_fence_language_specifier(t->child->child, source);
 
 			if (temp_char) {
+				if (strncmp("{=", temp_char, 2) == 0) {
+					// Raw source
+					if (raw_filter_text_matches(temp_char, FORMAT_BEAMER)) {
+						switch (t->child->tail->type) {
+							case LINE_FENCE_BACKTICK_3:
+							case LINE_FENCE_BACKTICK_4:
+							case LINE_FENCE_BACKTICK_5:
+								temp_token = t->child->tail;
+								break;
+
+							default:
+								temp_token = NULL;
+						}
+
+						if (temp_token) {
+							d_string_append_c_array(out, &source[t->child->next->start], temp_token->start - t->child->next->start);
+							scratch->padded = 1;
+						} else {
+							d_string_append_c_array(out, &source[t->child->start + t->child->len], t->start + t->len - t->child->next->start);
+							scratch->padded = 0;
+						}
+					}
+
+					free(temp_char);
+					break;
+				}
+
 				printf("\\begin{lstlisting}[language=%s]\n", temp_char);
 			} else {
 				print_const("\\begin{verbatim}\n");
@@ -242,6 +270,7 @@ void mmd_export_token_beamer(DString * out, const char * source, token * t, scra
 			}
 
 			mmd_export_token_tree_beamer(out, source, t->child, scratch);
+			trim_trailing_whitespace_d_string(out);
 
 			if (scratch->extensions & EXT_NO_LABELS) {
 				print_const("}");

data/ext/mmd/critic_markup.c

@@ -191,6 +191,8 @@ void accept_token(DString * d, token * t) {
 		case CM_SUB_OPEN:
 		case CM_ADD_OPEN:
 		case CM_ADD_CLOSE:
+		case CM_HI_OPEN:
+		case CM_HI_CLOSE:
 			if (!t->mate) {
 				break;
 			}
@@ -233,8 +235,9 @@ void accept_token_tree(DString * d, token * t) {
 	}
 }
 
-void mmd_critic_markup_accept(DString * d) {
-	token * t = critic_parse_substring(d->str, 0, d->currentStringLength);
+
+void mmd_critic_markup_accept_range(DString * d, size_t start, size_t len) {
+	token * t = critic_parse_substring(d->str, start, len);
 
 	if (t && t->child) {
 		accept_token_tree(d, t->child->tail);
@@ -244,6 +247,11 @@ void mmd_critic_markup_accept(DString * d) {
 }
 
 
+void mmd_critic_markup_accept(DString * d) {
+	mmd_critic_markup_accept_range(d, 0, d->currentStringLength);
+}
+
+
 void reject_token_tree(DString * d, token * t);
 void reject_token(DString * d, token * t);
 
@@ -275,6 +283,8 @@ void reject_token(DString * d, token * t) {
 		case CM_SUB_OPEN:
 		case CM_DEL_OPEN:
 		case CM_DEL_CLOSE:
+		case CM_HI_OPEN:
+		case CM_HI_CLOSE:
 			if (!t->mate) {
 				break;
 			}
@@ -317,8 +327,9 @@ void reject_token_tree(DString * d, token * t) {
 	}
 }
 
-void mmd_critic_markup_reject(DString * d) {
-	token * t = critic_parse_substring(d->str, 0, d->currentStringLength);
+
+void mmd_critic_markup_reject_range(DString * d, size_t start, size_t len) {
+	token * t = critic_parse_substring(d->str, start, len);
 
 	if (t && t->child) {
 		reject_token_tree(d, t->child->tail);
@@ -328,3 +339,88 @@ void mmd_critic_markup_reject(DString * d) {
 
 }
 
+
+void mmd_critic_markup_reject(DString * d) {
+	mmd_critic_markup_reject_range(d, 0, d->currentStringLength);
+}
+
+
+#ifdef TEST
+void Test_critic(CuTest* tc) {
+	#ifdef kUseObjectPool
+	token_pool_init();
+	#endif
+
+	DString * test = d_string_new("{--foo bar--}");
+	mmd_critic_markup_reject(test);
+	CuAssertStrEquals(tc, "foo bar", test->str);
+
+	d_string_erase(test, 0, -1);
+	d_string_append(test, "{++foo bar++}");
+	mmd_critic_markup_reject(test);
+	CuAssertStrEquals(tc, "", test->str);
+
+
+	d_string_erase(test, 0, -1);
+	d_string_append(test, "{--foo bar--}");
+	mmd_critic_markup_accept(test);
+	CuAssertStrEquals(tc, "", test->str);
+
+	d_string_erase(test, 0, -1);
+	d_string_append(test, "{++foo bar++}");
+	mmd_critic_markup_accept(test);
+	CuAssertStrEquals(tc, "foo bar", test->str);
+
+	d_string_erase(test, 0, -1);
+	d_string_append(test, "{++foo{--bat--}bar++}");
+	mmd_critic_markup_accept(test);
+	CuAssertStrEquals(tc, "foobar", test->str);
+
+	d_string_erase(test, 0, -1);
+	d_string_append(test, "{--foo{-- bat --}bar--}");
+	mmd_critic_markup_reject(test);
+	CuAssertStrEquals(tc, "foo bat bar", test->str);
+
+	d_string_erase(test, 0, -1);
+	d_string_append(test, "{--foo{++ bat ++}bar--}");
+	mmd_critic_markup_reject(test);
+	CuAssertStrEquals(tc, "foobar", test->str);
+
+	d_string_erase(test, 0, -1);
+	d_string_append(test, "{==foo bar==}");
+	mmd_critic_markup_reject(test);
+	CuAssertStrEquals(tc, "foo bar", test->str);
+
+	d_string_erase(test, 0, -1);
+	d_string_append(test, "{==foo bar==}");
+	mmd_critic_markup_accept(test);
+	CuAssertStrEquals(tc, "foo bar", test->str);
+
+	d_string_erase(test, 0, -1);
+	d_string_append(test, "{>>foo bar<<}");
+	mmd_critic_markup_reject(test);
+	CuAssertStrEquals(tc, "", test->str);
+
+	d_string_erase(test, 0, -1);
+	d_string_append(test, "{>>foo bar<<}");
+	mmd_critic_markup_accept(test);
+	CuAssertStrEquals(tc, "", test->str);
+
+	d_string_erase(test, 0, -1);
+	d_string_append(test, "{++foo++}{>>bar<<}");
+	mmd_critic_markup_accept(test);
+	CuAssertStrEquals(tc, "foo", test->str);
+
+	d_string_erase(test, 0, -1);
+	d_string_append(test, "{++foo++}{>>bar<<}");
+	mmd_critic_markup_reject(test);
+	CuAssertStrEquals(tc, "", test->str);
+
+	#ifdef kUseObjectPool
+	// Decrement counter and clean up token pool
+	token_pool_drain();
+
+	token_pool_free();
+	#endif
+}
+#endif

data/ext/mmd/critic_markup.h

@@ -60,6 +60,11 @@
 
 #include "d_string.h"
 
+#ifdef TEST
+	#include "CuTest.h"
+#endif
+
+
 enum cm_types {
 	CM_ADD_OPEN = 1,		// Can't use type 0
 	CM_ADD_CLOSE,
@@ -88,7 +93,9 @@ enum cm_types {
 
 
 void mmd_critic_markup_accept(DString * d);
+void mmd_critic_markup_accept_range(DString * d, size_t start, size_t len);
 
 void mmd_critic_markup_reject(DString * d);
+void mmd_critic_markup_reject_range(DString * d, size_t start, size_t len);
 
 #endif

data/ext/mmd/d_string.c

@@ -17,7 +17,7 @@
 /*
 
 	Copyright © 2011 Daniel Jalkut.
-	Modifications by Fletcher T. Penney, Copyright © 2011-2017 Fletcher T. Penney.
+	Modifications by Fletcher T. Penney, Copyright © 2011-2018 Fletcher T. Penney.
 	Modifications by Dan Lowe, Copyright © 2011 Dan Lowe.
 
 
@@ -64,6 +64,10 @@
 
 #include "d_string.h"
 
+#ifdef TEST
+	#include "CuTest.h"
+#endif
+
 
 /*
  * The following section came from:
@@ -145,6 +149,31 @@ DString* d_string_new(const char * startingString) {
 }
 
 
+#ifdef TEST
+void Test_d_string_new(CuTest* tc) {
+	char * test = "foo";
+
+	DString * result = d_string_new(test);
+
+	CuAssertIntEquals(tc, 3, result->currentStringLength);
+	CuAssertIntEquals(tc, kStringBufferStartingSize, result->currentStringBufferSize);
+	CuAssertStrEquals(tc, test, result->str);
+	CuAssertIntEquals(tc, '\0', result->str[strlen(test)]);
+
+	d_string_free(result, true);
+
+	result = d_string_new(NULL);
+
+	CuAssertIntEquals(tc, 0, result->currentStringLength);
+	CuAssertIntEquals(tc, kStringBufferStartingSize, result->currentStringBufferSize);
+	CuAssertStrEquals(tc, "", result->str);
+	CuAssertIntEquals(tc, '\0', 0);
+
+	d_string_free(result, true);
+}
+#endif
+
+
 /// Free dynamic string
 char* d_string_free(DString * ripString, bool freeCharacterData) {
 	if (ripString == NULL) {
@@ -169,234 +198,588 @@ char* d_string_free(DString * ripString, bool freeCharacterData) {
 
 /// Ensure that dynamic string has specified capacity
 static void ensureStringBufferCanHold(DString * baseString, size_t newStringSize) {
-	size_t newBufferSizeNeeded = newStringSize + 1;
+	if (baseString) {
+		size_t newBufferSizeNeeded = newStringSize + 1;
+
+		if (newBufferSizeNeeded > baseString->currentStringBufferSize) {
+			size_t newBufferSize = baseString->currentStringBufferSize;
+
+			while (newBufferSizeNeeded > newBufferSize) {
+				if (newBufferSize > kStringBufferMaxIncrement) {
+					newBufferSize += kStringBufferMaxIncrement;
+				} else {
+					newBufferSize *= kStringBufferGrowthMultiplier;
+				}
+			}
 
-	if (newBufferSizeNeeded > baseString->currentStringBufferSize) {
-		size_t newBufferSize = baseString->currentStringBufferSize;
+			char *temp;
+			temp = realloc(baseString->str, newBufferSize);
 
-		while (newBufferSizeNeeded > newBufferSize) {
-			if (newBufferSize > kStringBufferMaxIncrement) {
-				newBufferSize += kStringBufferMaxIncrement;
-			} else {
-				newBufferSize *= kStringBufferGrowthMultiplier;
+			if (temp == NULL) {
+				/* realloc failed */
+				fprintf(stderr, "Error reallocating memory for d_string. Current buffer size %lu.\n", baseString->currentStringBufferSize);
+
+				exit(1);
 			}
+
+			baseString->str = temp;
+			baseString->currentStringBufferSize = newBufferSize;
 		}
+	}
+}
 
-		char *temp;
-		temp = realloc(baseString->str, newBufferSize);
 
-		if (temp == NULL) {
-			/* realloc failed */
-			fprintf(stderr, "Error reallocating memory for d_string. Current buffer size %lu.\n", baseString->currentStringBufferSize);
+#ifdef TEST
+void Test_ensureStringBufferCanHold(CuTest* tc) {
+	char * test = "foo";
 
-			exit(1);
-		}
+	DString * result = d_string_new(test);
 
-		baseString->str = temp;
-		baseString->currentStringBufferSize = newBufferSize;
-	}
+	ensureStringBufferCanHold(result, 1024);
+	CuAssertIntEquals(tc, 2048, result->currentStringBufferSize);
+
+	ensureStringBufferCanHold(result, 1024);
+	CuAssertIntEquals(tc, 2048, result->currentStringBufferSize);
+
+	/* This becomes 0 after we add 1 for the '\0' */
+	ensureStringBufferCanHold(result, -1);
+	CuAssertIntEquals(tc, 2048, result->currentStringBufferSize);
+
+	ensureStringBufferCanHold(result, 1024 * 1024 - 1);
+	CuAssertIntEquals(tc, 1024 * 1024, result->currentStringBufferSize);
+
+	ensureStringBufferCanHold(result, 1024 * 1024 - 1);
+	CuAssertIntEquals(tc, 1024 * 1024, result->currentStringBufferSize);
+
+	ensureStringBufferCanHold(NULL, 1024);
+
+	d_string_free(result, true);
 }
+#endif
 
 
 /// Append null-terminated string to end of dynamic string
 void d_string_append(DString * baseString, const char * appendedString) {
-	size_t appendedStringLength = strlen(appendedString);
+	if (baseString && appendedString) {
+		size_t appendedStringLength = strlen(appendedString);
 
-	if ((appendedString != NULL) && (appendedStringLength > 0)) {
-		size_t newStringLength = baseString->currentStringLength + appendedStringLength;
-		ensureStringBufferCanHold(baseString, newStringLength);
+		if (appendedStringLength > 0) {
+			size_t newStringLength = baseString->currentStringLength + appendedStringLength;
+			ensureStringBufferCanHold(baseString, newStringLength);
 
-		/* We already know where the current string ends, so pass that as the starting address for strncat */
-		strncat(baseString->str + baseString->currentStringLength, appendedString, appendedStringLength);
-		baseString->currentStringLength = newStringLength;
+			/* We already know where the current string ends, so pass that as the starting address for strncat */
+			strncat(baseString->str + baseString->currentStringLength, appendedString, appendedStringLength);
+			baseString->currentStringLength = newStringLength;
+		}
 	}
 }
 
 
+#ifdef TEST
+void Test_d_string_append(CuTest* tc) {
+	char * test = "foo";
+
+	DString * result = d_string_new(test);
+
+	d_string_append(result, "bar");
+	CuAssertStrEquals(tc, "foobar", result->str);
+
+	d_string_append(result, "");
+	CuAssertStrEquals(tc, "foobar", result->str);
+
+	d_string_append(result, NULL);
+	CuAssertStrEquals(tc, "foobar", result->str);
+
+	d_string_append(NULL, "foo");
+
+	d_string_free(result, true);
+}
+#endif
+
+
 /// Append single character to end of dynamic string
 void d_string_append_c(DString * baseString, char appendedCharacter) {
-	size_t newSizeNeeded = baseString->currentStringLength + 1;
-	ensureStringBufferCanHold(baseString, newSizeNeeded);
+	if (baseString && appendedCharacter) {
+		size_t newSizeNeeded = baseString->currentStringLength + 1;
+		ensureStringBufferCanHold(baseString, newSizeNeeded);
 
-	baseString->str[baseString->currentStringLength] = appendedCharacter;
-	baseString->currentStringLength++;
-	baseString->str[baseString->currentStringLength] = '\0';
+		baseString->str[baseString->currentStringLength] = appendedCharacter;
+		baseString->currentStringLength++;
+		baseString->str[baseString->currentStringLength] = '\0';
+	}
 }
 
 
+#ifdef TEST
+void Test_d_string_append_c(CuTest* tc) {
+	char * test = "foo";
+
+	DString * result = d_string_new(test);
+
+	d_string_append_c(result, 'z');
+	CuAssertStrEquals(tc, "fooz", result->str);
+	CuAssertIntEquals(tc, 4, result->currentStringLength);
+
+	d_string_append_c(result, 0);
+	CuAssertStrEquals(tc, "fooz", result->str);
+	CuAssertIntEquals(tc, 4, result->currentStringLength);
+
+	d_string_append_c(NULL, 'f');
+
+	d_string_free(result, true);
+}
+#endif
+
+
 /// Append array of characters to end of dynamic string
 void d_string_append_c_array(DString * baseString, const char * appendedChars, size_t bytes) {
-	size_t newSizeNeeded = baseString->currentStringLength + bytes;
-	ensureStringBufferCanHold(baseString, newSizeNeeded);
+	if (baseString && appendedChars) {
+		if (bytes == -1) {
+			// This is the same as regular append
+			d_string_append(baseString, appendedChars);
+		} else {
+			if (appendedChars) {
+				size_t newSizeNeeded = baseString->currentStringLength + bytes;
+				ensureStringBufferCanHold(baseString, newSizeNeeded);
+
+				memcpy(baseString->str + baseString->currentStringLength, appendedChars, bytes);
+
+				baseString->currentStringLength = newSizeNeeded;
+				baseString->str[baseString->currentStringLength] = '\0';
+			}
+		}
+	}
+}
+
+
+#ifdef TEST
+void Test_d_string_append_c_array(CuTest* tc) {
+	char * test = "foo";
+
+	DString * result = d_string_new(test);
 
-	memcpy(baseString->str + baseString->currentStringLength, appendedChars, bytes);
+	d_string_append_c_array(result, "bar", 3);
+	CuAssertStrEquals(tc, "foobar", result->str);
+	CuAssertIntEquals(tc, 6, result->currentStringLength);
 
-	baseString->currentStringLength = newSizeNeeded;
-	baseString->str[baseString->currentStringLength] = '\0';
+	d_string_append_c_array(result, "baz", -1);
+	CuAssertStrEquals(tc, "foobarbaz", result->str);
+	CuAssertIntEquals(tc, 9, result->currentStringLength);
+
+	d_string_append_c_array(result, NULL, 0);
+	CuAssertStrEquals(tc, "foobarbaz", result->str);
+	CuAssertIntEquals(tc, 9, result->currentStringLength);
+
+	d_string_append_c_array(result, NULL, -1);
+	CuAssertStrEquals(tc, "foobarbaz", result->str);
+	CuAssertIntEquals(tc, 9, result->currentStringLength);
+
+	d_string_append_c_array(NULL, "foo", -1);
+
+	d_string_free(result, true);
 }
+#endif
 
 
 /// Append to end of dynamic string using format specifier
 void d_string_append_printf(DString * baseString, const char * format, ...) {
-	va_list args;
-	va_start(args, format);
+	if (baseString && format) {
+		va_list args;
+		va_start(args, format);
+
+		char* formattedString = NULL;
+		vasprintf(&formattedString, format, args);
 
-	char* formattedString = NULL;
-	vasprintf(&formattedString, format, args);
+		if (formattedString != NULL) {
+			d_string_append(baseString, formattedString);
+			free(formattedString);
+		}
 
-	if (formattedString != NULL) {
-		d_string_append(baseString, formattedString);
-		free(formattedString);
+		va_end(args);
 	}
+}
+
+
+#ifdef TEST
+void Test_d_string_append_printf(CuTest* tc) {
+	char * test = "foo";
+
+	DString * result = d_string_new(test);
 
-	va_end(args);
+	d_string_append_printf(result, "%dbar%d", 5, 7);
+	CuAssertStrEquals(tc, "foo5bar7", result->str);
+	CuAssertIntEquals(tc, 8, result->currentStringLength);
+
+	d_string_append_printf(result, NULL);
+	CuAssertStrEquals(tc, "foo5bar7", result->str);
+	CuAssertIntEquals(tc, 8, result->currentStringLength);
+
+	d_string_append_printf(result, NULL, 5, 7);
+	CuAssertStrEquals(tc, "foo5bar7", result->str);
+	CuAssertIntEquals(tc, 8, result->currentStringLength);
+
+	d_string_append_printf(NULL, "foo");
+
+	d_string_free(result, true);
 }
+#endif
 
 
 /// Prepend null-terminated string to end of dynamic string
 void d_string_prepend(DString * baseString, const char * prependedString) {
-	size_t prependedStringLength = strlen(prependedString);
+	if (baseString && prependedString) {
+		size_t prependedStringLength = strlen(prependedString);
 
-	if ((prependedString != NULL) && (prependedStringLength > 0)) {
-		size_t newStringLength = baseString->currentStringLength + prependedStringLength;
-		ensureStringBufferCanHold(baseString, newStringLength);
+		if (prependedStringLength > 0) {
+			size_t newStringLength = baseString->currentStringLength + prependedStringLength;
+			ensureStringBufferCanHold(baseString, newStringLength);
 
-		memmove(baseString->str + prependedStringLength, baseString->str, baseString->currentStringLength);
-		strncpy(baseString->str, prependedString, prependedStringLength);
-		baseString->currentStringLength = newStringLength;
-		baseString->str[baseString->currentStringLength] = '\0';
+			memmove(baseString->str + prependedStringLength, baseString->str, baseString->currentStringLength);
+			strncpy(baseString->str, prependedString, prependedStringLength);
+			baseString->currentStringLength = newStringLength;
+			baseString->str[baseString->currentStringLength] = '\0';
+		}
 	}
 }
 
 
+#ifdef TEST
+void Test_d_string_prepend(CuTest* tc) {
+	char * test = "foo";
+
+	DString * result = d_string_new(test);
+
+	d_string_prepend(result, "bar");
+	CuAssertStrEquals(tc, "barfoo", result->str);
+	CuAssertIntEquals(tc, 6, result->currentStringLength);
+
+	d_string_prepend(result, NULL);
+	CuAssertStrEquals(tc, "barfoo", result->str);
+	CuAssertIntEquals(tc, 6, result->currentStringLength);
+
+	d_string_prepend(NULL, "bar");
+
+	d_string_free(result, true);
+}
+#endif
+
+
 /// Insert null-terminated string inside dynamic string
 void d_string_insert(DString * baseString, size_t pos, const char * insertedString) {
-	size_t insertedStringLength = strlen(insertedString);
+	if (baseString && insertedString) {
+		size_t insertedStringLength = strlen(insertedString);
+
+		if (insertedStringLength > 0) {
+			if (pos > baseString->currentStringLength) {
+				pos = baseString->currentStringLength;
+			}
+
+			size_t newStringLength = baseString->currentStringLength + insertedStringLength;
+			ensureStringBufferCanHold(baseString, newStringLength);
 
-	if ((insertedString != NULL) && (insertedStringLength > 0)) {
+			/* Shift following string to 'right' */
+			memmove(baseString->str + pos + insertedStringLength, baseString->str + pos, baseString->currentStringLength - pos);
+			strncpy(baseString->str + pos, insertedString, insertedStringLength);
+			baseString->currentStringLength = newStringLength;
+			baseString->str[baseString->currentStringLength] = '\0';
+		}
+	}
+}
+
+
+#ifdef TEST
+void Test_d_string_insert(CuTest* tc) {
+	char * test = "foo";
+
+	DString * result = d_string_new(test);
+
+	d_string_insert(result, 2, "bar");
+	CuAssertStrEquals(tc, "fobaro", result->str);
+	CuAssertIntEquals(tc, 6, result->currentStringLength);
+
+	d_string_insert(result, -1, "bar");
+	CuAssertStrEquals(tc, "fobarobar", result->str);
+	CuAssertIntEquals(tc, 9, result->currentStringLength);
+
+	d_string_insert(result, -1, NULL);
+	CuAssertStrEquals(tc, "fobarobar", result->str);
+	CuAssertIntEquals(tc, 9, result->currentStringLength);
+
+	d_string_insert(NULL, 0, NULL);
+
+	d_string_free(result, true);
+}
+#endif
+
+
+/// Insert single character inside dynamic string
+void d_string_insert_c(DString * baseString, size_t pos, char insertedCharacter) {
+	if (baseString && insertedCharacter) {
 		if (pos > baseString->currentStringLength) {
 			pos = baseString->currentStringLength;
 		}
 
-		size_t newStringLength = baseString->currentStringLength + insertedStringLength;
-		ensureStringBufferCanHold(baseString, newStringLength);
+		size_t newSizeNeeded = baseString->currentStringLength + 1;
+		ensureStringBufferCanHold(baseString, newSizeNeeded);
 
 		/* Shift following string to 'right' */
-		memmove(baseString->str + pos + insertedStringLength, baseString->str + pos, baseString->currentStringLength - pos);
-		strncpy(baseString->str + pos, insertedString, insertedStringLength);
-		baseString->currentStringLength = newStringLength;
+		memmove(baseString->str + pos + 1, baseString->str + pos, baseString->currentStringLength - pos);
+
+		baseString->str[pos] = insertedCharacter;
+		baseString->currentStringLength++;
 		baseString->str[baseString->currentStringLength] = '\0';
 	}
 }
 
 
-/// Insert single character inside dynamic string
-void d_string_insert_c(DString * baseString, size_t pos, char insertedCharacter) {
-	if (pos > baseString->currentStringLength) {
-		pos = baseString->currentStringLength;
-	}
+#ifdef TEST
+void Test_d_string_insert_c(CuTest* tc) {
+	char * test = "foo";
+
+	DString * result = d_string_new(test);
+
+	d_string_insert_c(result, 2, 'b');
+	CuAssertStrEquals(tc, "fobo", result->str);
+	CuAssertIntEquals(tc, 4, result->currentStringLength);
+
+	d_string_insert_c(result, -1, 'z');
+	CuAssertStrEquals(tc, "foboz", result->str);
+	CuAssertIntEquals(tc, 5, result->currentStringLength);
 
-	size_t newSizeNeeded = baseString->currentStringLength + 1;
-	ensureStringBufferCanHold(baseString, newSizeNeeded);
+	d_string_insert_c(result, 3, 0);
+	CuAssertStrEquals(tc, "foboz", result->str);
+	CuAssertIntEquals(tc, 5, result->currentStringLength);
 
-	/* Shift following string to 'right' */
-	memmove(baseString->str + pos + 1, baseString->str + pos, baseString->currentStringLength - pos);
+	d_string_insert_c(NULL, 0, 0);
 
-	baseString->str[pos] = insertedCharacter;
-	baseString->currentStringLength++;
-	baseString->str[baseString->currentStringLength] = '\0';
+	d_string_free(result, true);
 }
+#endif
 
 
 /// Insert inside dynamic string using format specifier
 void d_string_insert_printf(DString * baseString, size_t pos, const char * format, ...) {
-	va_list args;
-	va_start(args, format);
+	if (baseString && format) {
+		va_list args;
+		va_start(args, format);
 
-	char* formattedString = NULL;
-	vasprintf(&formattedString, format, args);
+		char* formattedString = NULL;
+		vasprintf(&formattedString, format, args);
 
-	if (formattedString != NULL) {
-		d_string_insert(baseString, pos, formattedString);
-		free(formattedString);
+		if (formattedString != NULL) {
+			d_string_insert(baseString, pos, formattedString);
+			free(formattedString);
+		}
+
+		va_end(args);
 	}
+}
+
+
+#ifdef TEST
+void Test_d_string_insert_printf(CuTest* tc) {
+	char * test = "foo";
 
-	va_end(args);
+	DString * result = d_string_new(test);
+
+	d_string_insert_printf(result, 2, "%dbar%d", 5, 7);
+	CuAssertStrEquals(tc, "fo5bar7o", result->str);
+	CuAssertIntEquals(tc, 8, result->currentStringLength);
+
+	d_string_insert_printf(result, -1, "z", 5, 7);
+	CuAssertStrEquals(tc, "fo5bar7oz", result->str);
+	CuAssertIntEquals(tc, 9, result->currentStringLength);
+
+	d_string_insert_printf(NULL, 0, NULL);
+
+	d_string_free(result, true);
 }
+#endif
 
 
 /// Erase portion of dynamic string
 void d_string_erase(DString * baseString, size_t pos, size_t len) {
-	if ((pos > baseString->currentStringLength) || (len <= 0)) {
-		return;
-	}
+	if (baseString) {
+		if ((pos > baseString->currentStringLength) || (len <= 0)) {
+			return;
+		}
 
-	if ((pos + len) >= baseString->currentStringLength) {
-		len = -1;
-	}
+		if ((pos + len) >= baseString->currentStringLength) {
+			len = -1;
+		}
 
-	if (len == -1) {
-		baseString->currentStringLength = pos;
-	} else {
-		memmove(baseString->str + pos, baseString->str + pos + len, baseString->currentStringLength - pos - len);
-		baseString->currentStringLength -= len;
+		if (len == -1) {
+			baseString->currentStringLength = pos;
+		} else {
+			memmove(baseString->str + pos, baseString->str + pos + len, baseString->currentStringLength - pos - len);
+			baseString->currentStringLength -= len;
+		}
+
+		baseString->str[baseString->currentStringLength] = '\0';
 	}
+}
+
+
+#ifdef TEST
+void Test_d_string_erase(CuTest* tc) {
+	char * test = "foobar";
 
-	baseString->str[baseString->currentStringLength] = '\0';
+	DString * result = d_string_new(test);
+
+	d_string_erase(result, 2, 1);
+	CuAssertStrEquals(tc, "fobar", result->str);
+	CuAssertIntEquals(tc, 5, result->currentStringLength);
+
+	d_string_erase(result, -1, -1);
+	CuAssertStrEquals(tc, "fobar", result->str);
+	CuAssertIntEquals(tc, 5, result->currentStringLength);
+
+	d_string_erase(result, 2, -1);
+	CuAssertStrEquals(tc, "fo", result->str);
+	CuAssertIntEquals(tc, 2, result->currentStringLength);
+
+	d_string_erase(NULL, 0, 0);
+
+	d_string_free(result, true);
 }
+#endif
+
 
 /// Copy a portion of dynamic string
 char * d_string_copy_substring(DString * d, size_t start, size_t len) {
-	char * result;
+	if (d) {
+		char * result;
+
+		if (len == -1) {
+			if (start <= d->currentStringLength) {
+				len = d->currentStringLength - start;
+			} else {
+				len = 0;
+			}
+		}
 
-	if (len == -1) {
-		len = d->currentStringLength - start;
-	} else {
 		if (start + len > d->currentStringLength) {
 			fprintf(stderr, "d_string: Asked to copy invalid substring range.\n");
 			fprintf(stderr, "start: %lu  len: %lu  string: %lu\n", start, len,
-			        d->currentStringLength);
+					d->currentStringLength);
 			return NULL;
 		}
+
+		result = malloc(len + 1);
+		strncpy(result, &d->str[start], len);
+		result[len] = '\0';
+
+		return result;
+	} else {
+		return NULL;
 	}
+}
+
+
+#ifdef TEST
+void Test_d_string_copy_substring(CuTest* tc) {
+	char * test = "foobar";
+
+	DString * result = d_string_new(test);
+
+	test = d_string_copy_substring(result, 0, -1);
+	CuAssertStrEquals(tc, "foobar", test);
+	free(test);
 
-	result = malloc(len + 1);
-	strncpy(result, &d->str[start], len);
-	result[len] = '\0';
+	test = d_string_copy_substring(result, 2, 3);
+	CuAssertStrEquals(tc, "oba", test);
+	free(test);
 
-	return result;
+	test = d_string_copy_substring(result, 8, 2);
+	CuAssertStrEquals(tc, NULL, test);
+	free(test);
+
+	test = d_string_copy_substring(result, -1, -1);
+	CuAssertStrEquals(tc, NULL, test);
+	free(test);
+
+	test = d_string_copy_substring(NULL, -1, -1);
+	CuAssertStrEquals(tc, NULL, test);
+
+	d_string_free(result, true);
 }
+#endif
 
 
 /// Replace occurences of "original" with "replace" inside the specified range
 /// Returns the change in overall length
 long d_string_replace_text_in_range(DString * d, size_t pos, size_t len, const char * original, const char * replace) {
-	long delta = 0;		// Overall change in length
+	if (d && original && replace) {
+		long delta = 0;		// Overall change in length
+
+		long len_o = strlen(original);
+		long len_r = strlen(replace);
+		long change = len_r - len_o;	// Change in length for each replacement
+
+		size_t stop;
+
+		if (len == -1) {
+			stop = d->currentStringLength;
+		} else {
+			stop = pos + len;
+
+			if (stop > d->currentStringLength) {
+				stop = d->currentStringLength;
+			}
+		}
+
+		char * match = strstr(&(d->str[pos]), original);
 
-	long len_o = strlen(original);
-	long len_r = strlen(replace);
-	long change = len_r - len_o;	// Change in length for each replacement
+		while (match && (match - d->str < stop)) {
+			pos = match - d->str;
+			d_string_erase(d, match - d->str, len_o);
+			d_string_insert(d, match - d->str, replace);
 
-	size_t stop;
+			delta += change;
+			stop += change;
+			match = strstr(d->str + pos + len_r, original);
+		}
 
-	if (len == -1) {
-		stop = d->currentStringLength;
+		return delta;
 	} else {
-		stop = pos + len;
+		return 0;
 	}
+}
 
-	char * match = strstr(&(d->str[pos]), original);
 
-	while (match && (match - d->str < stop)) {
-		pos = match - d->str;
-		d_string_erase(d, match - d->str, len_o);
-		d_string_insert(d, match - d->str, replace);
+#ifdef TEST
+void Test_d_string_replace_text_in_range(CuTest* tc) {
+	char * test = "foobarfoobarfoo";
+	long delta = 0;
 
-		delta += change;
-		stop += change;
-		match = strstr(d->str + pos + len_r, original);
-	}
+	DString * result = d_string_new(test);
 
-	return delta;
-}
+	delta = d_string_replace_text_in_range(result, 100, 3, "foo", "zapz");
+	CuAssertIntEquals(tc, 15, result->currentStringLength);
+	CuAssertStrEquals(tc, "foobarfoobarfoo", result->str);
+	CuAssertIntEquals(tc, delta, 0);
+
+	delta = d_string_replace_text_in_range(result, 0, 3, "foo", "zapz");
+	CuAssertIntEquals(tc, 16, result->currentStringLength);
+	CuAssertStrEquals(tc, "zapzbarfoobarfoo", result->str);
+	CuAssertIntEquals(tc, delta, 1);
 
+	delta = d_string_replace_text_in_range(result, 0, 100, "foo", "zapz");
+	CuAssertIntEquals(tc, 18, result->currentStringLength);
+	CuAssertStrEquals(tc, "zapzbarzapzbarzapz", result->str);
+	CuAssertIntEquals(tc, delta, 2);
+
+	delta = d_string_replace_text_in_range(result, 0, -1, NULL, "zap");
+	CuAssertIntEquals(tc, 18, result->currentStringLength);
+	CuAssertStrEquals(tc, "zapzbarzapzbarzapz", result->str);
+	CuAssertIntEquals(tc, delta, 0);
+
+	d_string_replace_text_in_range(result, 0, -1, "foo", NULL);
+	CuAssertIntEquals(tc, 18, result->currentStringLength);
+	CuAssertStrEquals(tc, "zapzbarzapzbarzapz", result->str);
+
+	d_string_replace_text_in_range(NULL, 0, -1, "foo", NULL);
+
+	d_string_free(result, true);
+}
+#endif