diff -r 000000000000 -r 6474c204b198 xpcom/tests/TestStrings.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/xpcom/tests/TestStrings.cpp	Wed Dec 31 06:09:35 2014 +0100
@@ -0,0 +1,1254 @@
+/* vim:set ts=2 sw=2 et cindent: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include "nsString.h"
+#include "nsStringBuffer.h"
+#include "nsReadableUtils.h"
+#include "nsCRTGlue.h"
+
+namespace TestStrings {
+
+void test_assign_helper(const nsACString& in, nsACString &_retval)
+  {
+    _retval = in;
+  }
+
+bool test_assign()
+  {
+    nsCString result;
+    test_assign_helper(NS_LITERAL_CSTRING("a") + NS_LITERAL_CSTRING("b"), result);
+    bool r = strcmp(result.get(), "ab") == 0;
+    if (!r)
+      printf("[result=%s]\n", result.get());
+    return r;
+  }
+
+bool test_assign_c()
+  {
+    nsCString c; c.Assign('c');
+    bool r = strcmp(c.get(), "c") == 0;
+    if (!r)
+      printf("[result=%s]\n", c.get());
+    return r;
+  }
+
+bool test1()
+  {
+    NS_NAMED_LITERAL_STRING(empty, "");
+    const nsAString& aStr = empty;
+
+    nsAutoString buf(aStr);
+
+    int32_t n = buf.FindChar(',');
+
+    n = buf.Length();
+
+    buf.Cut(0, n + 1);
+    n = buf.FindChar(',');
+
+    if (n != kNotFound)
+      printf("n=%d\n", n);
+
+    return n == kNotFound;
+  }
+
+bool test2()
+  {
+    nsCString data("hello world");
+    const nsACString& aStr = data;
+
+    nsCString temp(aStr);
+    temp.Cut(0, 6);
+
+    bool r = strcmp(temp.get(), "world") == 0;
+    if (!r)
+      printf("[temp=%s]\n", temp.get());
+    return r;
+  }
+
+bool test_find()
+  {
+    nsCString src("<!DOCTYPE blah blah blah>");
+
+    int32_t i = src.Find("DOCTYPE", true, 2, 1);
+    if (i == 2)
+      return true;
+
+    printf("i=%d\n", i);
+    return false;
+  }
+
+bool test_rfind()
+  {
+    const char text[] = "<!DOCTYPE blah blah blah>";
+    const char term[] = "bLaH";
+    nsCString src(text);
+    int32_t i;
+
+    i = src.RFind(term, true, 3, -1); 
+    if (i != kNotFound)
+      {
+        printf("unexpected result searching from offset=3, i=%d\n", i);
+        return false;
+      }
+
+    i = src.RFind(term, true, -1, -1);
+    if (i != 20)
+      {
+        printf("unexpected result searching from offset=-1, i=%d\n", i);
+        return false;
+      }
+
+    i = src.RFind(term, true, 13, -1);
+    if (i != 10)
+      {
+        printf("unexpected result searching from offset=13, i=%d\n", i);
+        return false;
+      }
+
+    i = src.RFind(term, true, 22, 3);
+    if (i != 20)
+      {
+        printf("unexpected result searching from offset=22, i=%d\n", i);
+        return false;
+      }
+
+    return true;
+  }
+
+bool test_rfind_2()
+  {
+    const char text[] = "<!DOCTYPE blah blah blah>";
+    nsCString src(text);
+    int32_t i = src.RFind("TYPE", false, 5, -1); 
+    if (i == 5)
+      return true;
+
+    printf("i=%d\n", i);
+    return false;
+  }
+
+bool test_rfind_3()
+  {
+    const char text[] = "urn:mozilla:locale:en-US:necko";
+    nsAutoCString value(text);
+    int32_t i = value.RFind(":");
+    if (i == 24)
+      return true;
+
+    printf("i=%d\n", i);
+    return false;
+  }
+
+bool test_rfind_4()
+  {
+    nsCString value("a.msf");
+    int32_t i = value.RFind(".msf");
+    if (i != 1)
+      {
+        printf("i=%d\n", i);
+        return false;
+      }
+
+    return true;
+  }
+
+bool test_findinreadable()
+  {
+    const char text[] = "jar:jar:file:///c:/software/mozilla/mozilla_2006_02_21.jar!/browser/chrome/classic.jar!/";
+    nsAutoCString value(text);
+
+    nsACString::const_iterator begin, end;
+    value.BeginReading(begin);
+    value.EndReading(end);
+    nsACString::const_iterator delim_begin (begin),
+                               delim_end   (end);
+
+    // Search for last !/ at the end of the string
+    if (!FindInReadable(NS_LITERAL_CSTRING("!/"), delim_begin, delim_end))
+        return false;
+    char *r = ToNewCString(Substring(delim_begin, delim_end));
+    // Should match the first "!/" but not the last
+    if ((delim_end == end) || (strcmp(r, "!/")!=0))
+      {
+        printf("r = %s\n", r);
+        nsMemory::Free(r);
+        return false;
+      }
+    nsMemory::Free(r);
+
+    delim_begin = begin;
+    delim_end = end;
+
+    // Search for first jar:
+    if (!FindInReadable(NS_LITERAL_CSTRING("jar:"), delim_begin, delim_end))
+        return false;
+
+    r = ToNewCString(Substring(delim_begin, delim_end));
+    // Should not match the first jar:, but the second one
+    if ((delim_begin != begin) || (strcmp(r, "jar:")!=0))
+      {
+        printf("r = %s\n", r);
+        nsMemory::Free(r);
+        return false;
+      }
+    nsMemory::Free(r);
+
+    // Search for jar: in a Substring
+    delim_begin = begin; delim_begin++;
+    delim_end = end;
+    if (!FindInReadable(NS_LITERAL_CSTRING("jar:"), delim_begin, delim_end))
+        return false;
+
+    r = ToNewCString(Substring(delim_begin, delim_end));
+    // Should not match the first jar:, but the second one
+    if ((delim_begin == begin) || (strcmp(r, "jar:")!=0))
+      {
+        printf("r = %s\n", r);
+        nsMemory::Free(r);
+        return false;
+      }
+    nsMemory::Free(r);
+
+    // Should not find a match
+    if (FindInReadable(NS_LITERAL_CSTRING("gecko"), delim_begin, delim_end))
+        return false;
+
+    // When no match is found, range should be empty
+    if (delim_begin != delim_end) 
+        return false;
+
+    // Should not find a match (search not beyond Substring)
+    delim_begin = begin; for (int i=0;i<6;i++) delim_begin++;
+    delim_end = end;
+    if (FindInReadable(NS_LITERAL_CSTRING("jar:"), delim_begin, delim_end))
+        return false;
+
+    // When no match is found, range should be empty
+    if (delim_begin != delim_end) 
+        return false;
+
+    // Should not find a match (search not beyond Substring)
+    delim_begin = begin;
+    delim_end = end; for (int i=0;i<7;i++) delim_end--;
+    if (FindInReadable(NS_LITERAL_CSTRING("classic"), delim_begin, delim_end))
+        return false;
+
+    // When no match is found, range should be empty
+    if (delim_begin != delim_end) 
+        return false;
+
+    return true;
+  }
+
+bool test_rfindinreadable()
+  {
+    const char text[] = "jar:jar:file:///c:/software/mozilla/mozilla_2006_02_21.jar!/browser/chrome/classic.jar!/";
+    nsAutoCString value(text);
+
+    nsACString::const_iterator begin, end;
+    value.BeginReading(begin);
+    value.EndReading(end);
+    nsACString::const_iterator delim_begin (begin),
+                               delim_end   (end);
+
+    // Search for last !/ at the end of the string
+    if (!RFindInReadable(NS_LITERAL_CSTRING("!/"), delim_begin, delim_end))
+        return false;
+    char *r = ToNewCString(Substring(delim_begin, delim_end));
+    // Should match the last "!/"
+    if ((delim_end != end) || (strcmp(r, "!/")!=0))
+      {
+        printf("r = %s\n", r);
+        nsMemory::Free(r);
+        return false;
+      }
+    nsMemory::Free(r);
+
+    delim_begin = begin;
+    delim_end = end;
+
+    // Search for last jar: but not the first one...
+    if (!RFindInReadable(NS_LITERAL_CSTRING("jar:"), delim_begin, delim_end))
+        return false;
+
+    r = ToNewCString(Substring(delim_begin, delim_end));
+    // Should not match the first jar:, but the second one
+    if ((delim_begin == begin) || (strcmp(r, "jar:")!=0))
+      {
+        printf("r = %s\n", r);
+        nsMemory::Free(r);
+        return false;
+      }
+    nsMemory::Free(r);
+
+    // Search for jar: in a Substring
+    delim_begin = begin;
+    delim_end = begin; for (int i=0;i<6;i++) delim_end++;
+    if (!RFindInReadable(NS_LITERAL_CSTRING("jar:"), delim_begin, delim_end)) {
+        printf("Search for jar: in a Substring\n");
+        return false;
+    }
+
+    r = ToNewCString(Substring(delim_begin, delim_end));
+    // Should not match the first jar:, but the second one
+    if ((delim_begin != begin) || (strcmp(r, "jar:")!=0))
+      {
+        printf("r = %s\n", r);
+        nsMemory::Free(r);
+        return false;
+      }
+    nsMemory::Free(r);
+
+    // Should not find a match
+    delim_begin = begin;
+    delim_end = end;
+    if (RFindInReadable(NS_LITERAL_CSTRING("gecko"), delim_begin, delim_end)) {
+        printf("Should not find a match\n");
+        return false;
+    }
+
+    // When no match is found, range should be empty
+    if (delim_begin != delim_end) {
+        printf("1: When no match is found, range should be empty\n");
+        return false;
+    }
+
+    // Should not find a match (search not before Substring)
+    delim_begin = begin; for (int i=0;i<6;i++) delim_begin++;
+    delim_end = end;
+    if (RFindInReadable(NS_LITERAL_CSTRING("jar:"), delim_begin, delim_end)) {
+        printf("Should not find a match (search not before Substring)\n");
+        return false;
+    }
+
+    // When no match is found, range should be empty
+    if (delim_begin != delim_end) {
+        printf("2: When no match is found, range should be empty\n");
+        return false;
+    }
+
+    // Should not find a match (search not beyond Substring)
+    delim_begin = begin;
+    delim_end = end; for (int i=0;i<7;i++) delim_end--;
+    if (RFindInReadable(NS_LITERAL_CSTRING("classic"), delim_begin, delim_end)) {
+        printf("Should not find a match (search not beyond Substring)\n");
+        return false;
+    }
+
+    // When no match is found, range should be empty
+    if (delim_begin != delim_end) {
+        printf("3: When no match is found, range should be empty\n");
+        return false;
+    }
+
+    return true;
+  }
+
+bool test_distance()
+  {
+    const char text[] = "abc-xyz";
+    nsCString s(text);
+    nsCString::const_iterator begin, end;
+    s.BeginReading(begin);
+    s.EndReading(end);
+    size_t d = Distance(begin, end);
+    bool r = (d == sizeof(text)-1);
+    if (!r)
+      printf("d=%u\n", d);
+    return r;
+  }
+
+bool test_length()
+  {
+    const char text[] = "abc-xyz";
+    nsCString s(text);
+    size_t d = s.Length();
+    bool r = (d == sizeof(text)-1);
+    if (!r)
+      printf("d=%u\n", d);
+    return r;
+  }
+
+bool test_trim()
+  {
+    const char text[] = " a\t    $   ";
+    const char set[] = " \t$";
+
+    nsCString s(text);
+    s.Trim(set);
+    bool r = strcmp(s.get(), "a") == 0;
+    if (!r)
+      printf("[s=%s]\n", s.get());
+    return r;
+  }
+
+bool test_replace_substr()
+  {
+    const char text[] = "abc-ppp-qqq-ppp-xyz";
+    nsCString s(text);
+    s.ReplaceSubstring("ppp", "www");
+    bool r = strcmp(s.get(), "abc-www-qqq-www-xyz") == 0;
+    if (!r)
+      {
+        printf("[s=%s]\n", s.get());
+        return false;
+      }
+
+    s.Assign("foobar");
+    s.ReplaceSubstring("foo", "bar");
+    s.ReplaceSubstring("bar", "");
+    r = strcmp(s.get(), "") == 0;
+    if (!r)
+      {
+        printf("[s=%s]\n", s.get());
+        return false;
+      }
+
+    s.Assign("foofoofoo");
+    s.ReplaceSubstring("foo", "foo");
+    r = strcmp(s.get(), "foofoofoo") == 0;
+    if (!r)
+      {
+        printf("[s=%s]\n", s.get());
+        return false;
+      }
+
+    s.Assign("foofoofoo");
+    s.ReplaceSubstring("of", "fo");
+    r = strcmp(s.get(), "fofoofooo") == 0;
+    if (!r)
+      {
+        printf("[s=%s]\n", s.get());
+        return false;
+      }
+
+    return true;
+  }
+
+bool test_replace_substr_2()
+  {
+    const char *oldName = nullptr;
+    const char *newName = "user";
+    nsString acctName; acctName.AssignLiteral("forums.foo.com");
+    nsAutoString newAcctName, oldVal, newVal;
+    oldVal.AssignWithConversion(oldName);
+    newVal.AssignWithConversion(newName);
+    newAcctName.Assign(acctName);
+
+    // here, oldVal is empty.  we are testing that this function
+    // does not hang.  see bug 235355.
+    newAcctName.ReplaceSubstring(oldVal, newVal);
+
+    // we expect that newAcctName will be unchanged.
+    if (!newAcctName.Equals(acctName))
+      return false;
+
+    return true;
+  }
+
+bool test_strip_ws()
+  {
+    const char text[] = " a    $   ";
+    nsCString s(text);
+    s.StripWhitespace();
+    bool r = strcmp(s.get(), "a$") == 0;
+    if (!r)
+      printf("[s=%s]\n", s.get());
+    return r;
+  }
+
+bool test_equals_ic()
+  {
+    nsCString s;
+    bool r = s.LowerCaseEqualsLiteral("view-source");
+    if (r)
+      printf("[r=%d]\n", r);
+    return !r;
+  }
+
+bool test_fixed_string()
+  {
+    char buf[256] = "hello world";
+
+    nsFixedCString s(buf, sizeof(buf));
+
+    if (s.Length() != strlen(buf))
+      return false;
+
+    if (strcmp(s.get(), buf) != 0)
+      return false;
+
+    s.Assign("foopy doopy doo");
+    if (s.get() != buf)
+      return false;
+    
+    return true;
+  }
+
+bool test_concat()
+  {
+    nsCString bar("bar");
+    const nsACString& barRef = bar;
+
+    const nsPromiseFlatCString& result =
+        PromiseFlatCString(NS_LITERAL_CSTRING("foo") +
+                           NS_LITERAL_CSTRING(",") +
+                           barRef);
+    if (strcmp(result.get(), "foo,bar") == 0)
+      return true;
+
+    printf("[result=%s]\n", result.get());
+    return false;
+  }
+
+bool test_concat_2()
+  {
+    nsCString fieldTextStr("xyz");
+    nsCString text("text");
+    const nsACString& aText = text;
+
+    nsAutoCString result( fieldTextStr + aText );
+
+    if (strcmp(result.get(), "xyztext") == 0)
+      return true;
+    
+    printf("[result=%s]\n", result.get());
+    return false;
+  }
+
+bool test_concat_3()
+  {
+    nsCString result;
+    nsCString ab("ab"), c("c");
+
+    result = ab + result + c;
+    if (strcmp(result.get(), "abc") == 0)
+      return true;
+
+    printf("[result=%s]\n", result.get());
+    return false;
+  }
+
+bool test_xpidl_string()
+  {
+    nsXPIDLCString a, b;
+    a = b;
+    if (a != b)
+      return false;
+
+    a.Adopt(0);
+    if (a != b)
+      return false;
+
+    a.Append("foopy");
+    a.Assign(b);
+    if (a != b)
+      return false;
+
+    a.Insert("", 0);
+    a.Assign(b);
+    if (a != b)
+      return false;
+
+    const char text[] = "hello world";
+    *getter_Copies(a) = NS_strdup(text);
+    if (strcmp(a, text) != 0)
+      return false;
+
+    b = a;
+    if (strcmp(a, b) != 0)
+      return false;
+
+    a.Adopt(0);
+    nsACString::const_iterator begin, end;
+    a.BeginReading(begin);
+    a.EndReading(end);
+    char *r = ToNewCString(Substring(begin, end));
+    if (strcmp(r, "") != 0)
+      return false;
+    nsMemory::Free(r);
+
+    a.Adopt(0);
+    if (a != (const char*) 0)
+      return false;
+
+    /*
+    int32_t index = a.FindCharInSet("xyz");
+    if (index != kNotFound)
+      return false;
+    */
+
+    return true;
+  }
+
+bool test_empty_assign()
+  {
+    nsCString a;
+    a.AssignLiteral("");
+
+    a.AppendLiteral("");
+
+    nsCString b;
+    b.SetCapacity(0);
+    return true;
+  }
+
+bool test_set_length()
+  {
+    const char kText[] = "Default Plugin";
+    nsCString buf;
+    buf.SetCapacity(sizeof(kText)-1);
+    buf.Assign(kText);
+    buf.SetLength(sizeof(kText)-1);
+    if (strcmp(buf.get(), kText) != 0)
+      return false;
+    return true;
+  }
+
+bool test_substring()
+  {
+    nsCString super("hello world"), sub("hello");
+
+    // this tests that |super| starts with |sub|,
+    
+    bool r = sub.Equals(StringHead(super, sub.Length()));
+    if (!r)
+      return false;
+
+    // and verifies that |sub| does not start with |super|.
+
+    r = super.Equals(StringHead(sub, super.Length()));
+    if (r)
+      return false;
+
+    return true;
+  }
+
+#define test_append(str, int, suffix) \
+  str.Truncate(); \
+  str.AppendInt(suffix = int ## suffix); \
+  if (!str.EqualsLiteral(#int)) { \
+    fputs("Error appending " #int "\n", stderr); \
+    return false; \
+  }
+
+#define test_appends(int, suffix) \
+  test_append(str, int, suffix) \
+  test_append(cstr, int, suffix)
+
+#define test_appendbase(str, prefix, int, suffix, base) \
+  str.Truncate(); \
+  str.AppendInt(suffix = prefix ## int ## suffix, base); \
+  if (!str.EqualsLiteral(#int)) { \
+    fputs("Error appending " #prefix #int "\n", stderr); \
+    return false; \
+  }
+
+#define test_appendbases(prefix, int, suffix, base) \
+  test_appendbase(str, prefix, int, suffix, base) \
+  test_appendbase(cstr, prefix, int, suffix, base)
+
+bool test_appendint()
+  {
+    nsString str;
+    nsCString cstr;
+    int32_t L;
+    uint32_t UL;
+    int64_t LL;
+    uint64_t ULL;
+    test_appends(2147483647, L)
+    test_appends(-2147483648, L)
+    test_appends(4294967295, UL)
+    test_appends(9223372036854775807, LL)
+    test_appends(-9223372036854775808, LL)
+    test_appends(18446744073709551615, ULL)
+    test_appendbases(0, 17777777777, L, 8)
+    test_appendbases(0, 20000000000, L, 8)
+    test_appendbases(0, 37777777777, UL, 8)
+    test_appendbases(0, 777777777777777777777, LL, 8)
+    test_appendbases(0, 1000000000000000000000, LL, 8)
+    test_appendbases(0, 1777777777777777777777, ULL, 8)
+    test_appendbases(0x, 7fffffff, L, 16)
+    test_appendbases(0x, 80000000, L, 16)
+    test_appendbases(0x, ffffffff, UL, 16)
+    test_appendbases(0x, 7fffffffffffffff, LL, 16)
+    test_appendbases(0x, 8000000000000000, LL, 16)
+    test_appendbases(0x, ffffffffffffffff, ULL, 16)
+    return true;
+  }
+
+bool test_appendint64()
+  {
+    nsCString str;
+
+    int64_t max = INT64_MAX;
+    static const char max_expected[] = "9223372036854775807";
+    int64_t min = INT64_MIN;
+    static const char min_expected[] = "-9223372036854775808";
+    static const char min_expected_oct[] = "1000000000000000000000";
+    int64_t maxint_plus1 = 1LL << 32;
+    static const char maxint_plus1_expected[] = "4294967296";
+    static const char maxint_plus1_expected_x[] = "100000000";
+
+    str.AppendInt(max);
+
+    if (!str.Equals(max_expected)) {
+      fprintf(stderr, "Error appending INT64_MAX: Got %s\n", str.get());
+      return false;
+    }
+
+    str.Truncate();
+    str.AppendInt(min);
+    if (!str.Equals(min_expected)) {
+      fprintf(stderr, "Error appending INT64_MIN: Got %s\n", str.get());
+      return false;
+    }
+    str.Truncate();
+    str.AppendInt(min, 8);
+    if (!str.Equals(min_expected_oct)) {
+      fprintf(stderr, "Error appending INT64_MIN (oct): Got %s\n", str.get());
+      return false;
+    }
+
+
+    str.Truncate();
+    str.AppendInt(maxint_plus1);
+    if (!str.Equals(maxint_plus1_expected)) {
+      fprintf(stderr, "Error appending UINT32_MAX + 1: Got %s\n", str.get());
+      return false;
+    }
+    str.Truncate();
+    str.AppendInt(maxint_plus1, 16);
+    if (!str.Equals(maxint_plus1_expected_x)) {
+      fprintf(stderr, "Error appending UINT32_MAX + 1 (hex): Got %s\n", str.get());
+      return false;
+    }
+
+
+    return true;
+  }
+
+bool test_appendfloat()
+  {
+    nsCString str;
+    double bigdouble = 11223344556.66;
+    static const char double_expected[] = "11223344556.66";
+    static const char float_expected[] = "0.01";
+
+    // AppendFloat is used to append doubles, therefore the precision must be
+    // large enough (see bug 327719)
+    str.AppendFloat( bigdouble );
+    if (!str.Equals(double_expected)) {
+      fprintf(stderr, "Error appending a big double: Got %s\n", str.get());
+      return false;
+    }
+    
+    str.Truncate();
+    // AppendFloat is used to append floats (bug 327719 #27)
+    str.AppendFloat( 0.1f * 0.1f );
+    if (!str.Equals(float_expected)) {
+      fprintf(stderr, "Error appending a float: Got %s\n", str.get());
+      return false;
+    }
+
+    return true;
+  }
+
+bool test_findcharinset()
+  {
+    nsCString buf("hello, how are you?");
+
+    int32_t index = buf.FindCharInSet(",?", 5);
+    if (index != 5)
+      return false;
+
+    index = buf.FindCharInSet("helo", 0);
+    if (index != 0)
+      return false;
+
+    index = buf.FindCharInSet("z?", 6);
+    if (index != (int32_t) buf.Length()-1)
+      return false;
+
+    return true;
+  }
+
+bool test_rfindcharinset()
+  {
+    nsCString buf("hello, how are you?");
+
+    int32_t index = buf.RFindCharInSet(",?", 5);
+    if (index != 5)
+      return false;
+
+    index = buf.RFindCharInSet("helo", 0);
+    if (index != 0)
+      return false;
+
+    index = buf.RFindCharInSet("z?", 6);
+    if (index != kNotFound)
+      return false;
+
+    index = buf.RFindCharInSet("l", 5);
+    if (index != 3)
+      return false;
+
+    buf.Assign("abcdefghijkabc");
+
+    index = buf.RFindCharInSet("ab");
+    if (index != 12)
+      return false;
+
+    index = buf.RFindCharInSet("ab", 11);
+    if (index != 11)
+      return false;
+
+    index = buf.RFindCharInSet("ab", 10);
+    if (index != 1)
+      return false;
+
+    index = buf.RFindCharInSet("ab", 0);
+    if (index != 0)
+      return false;
+
+    index = buf.RFindCharInSet("cd", 1);
+    if (index != kNotFound)
+      return false;
+
+    index = buf.RFindCharInSet("h");
+    if (index != 7)
+      return false;
+
+    return true;
+  }
+
+bool test_stringbuffer()
+  {
+    const char kData[] = "hello world";
+
+    nsStringBuffer *buf;
+    
+    buf = nsStringBuffer::Alloc(sizeof(kData));
+    if (!buf)
+      return false;
+    buf->Release();
+ 
+    buf = nsStringBuffer::Alloc(sizeof(kData));
+    if (!buf)
+      return false;
+    char *data = (char *) buf->Data();
+    memcpy(data, kData, sizeof(kData));
+
+    nsCString str;
+    buf->ToString(sizeof(kData)-1, str);
+
+    nsStringBuffer *buf2;
+    buf2 = nsStringBuffer::FromString(str);
+
+    bool rv = (buf == buf2);
+
+    buf->Release();
+    return rv;
+  }
+
+bool test_voided()
+  {
+    const char kData[] = "hello world";
+
+    nsXPIDLCString str;
+    if (str)
+      return false;
+    if (!str.IsVoid())
+      return false;
+    if (!str.IsEmpty())
+      return false;
+
+    str.Assign(kData);
+    if (strcmp(str, kData) != 0)
+      return false;
+
+    str.SetIsVoid(true);
+    if (str)
+      return false;
+    if (!str.IsVoid())
+      return false;
+    if (!str.IsEmpty())
+      return false;
+
+    str.SetIsVoid(false);
+    if (strcmp(str, "") != 0)
+      return false;
+
+    return true;
+  }
+
+bool test_voided_autostr()
+  {
+    const char kData[] = "hello world";
+
+    nsAutoCString str;
+    if (str.IsVoid())
+      return false;
+    if (!str.IsEmpty())
+      return false;
+
+    str.Assign(kData);
+    if (strcmp(str.get(), kData) != 0)
+      return false;
+
+    str.SetIsVoid(true);
+    if (!str.IsVoid())
+      return false;
+    if (!str.IsEmpty())
+      return false;
+
+    str.Assign(kData);
+    if (str.IsVoid())
+      return false;
+    if (str.IsEmpty())
+      return false;
+    if (strcmp(str.get(), kData) != 0)
+      return false;
+
+    return true;
+  }
+
+bool test_voided_assignment()
+  {
+    nsCString a, b;
+    b.SetIsVoid(true);
+    a = b;
+    return a.IsVoid() && a.get() == b.get();
+  }
+
+bool test_empty_assignment()
+  {
+    nsCString a, b;
+    a = b;
+    return a.get() == b.get();
+  }
+
+struct ToIntegerTest
+{
+  const char *str;
+  uint32_t radix;
+  int32_t result;
+  nsresult rv;
+};
+
+static const ToIntegerTest kToIntegerTests[] = {
+  { "123", 10, 123, NS_OK },
+  { "7b", 16, 123, NS_OK },
+  { "90194313659", 10, 0, NS_ERROR_ILLEGAL_VALUE },
+  { nullptr, 0, 0, 0 }
+};
+
+bool test_string_tointeger()
+{
+  int32_t i;
+  nsresult rv;
+  for (const ToIntegerTest* t = kToIntegerTests; t->str; ++t) {
+    int32_t result = nsAutoCString(t->str).ToInteger(&rv, t->radix);
+    if (rv != t->rv || result != t->result)
+      return false;
+    result = nsAutoCString(t->str).ToInteger(&i, t->radix);
+    if ((nsresult)i != t->rv || result != t->result)
+      return false;
+  }
+  return true;
+}
+
+static bool test_parse_string_helper(const char* str, char separator, int len,
+                                       const char* s1, const char* s2)
+{
+  nsCString data(str);
+  nsTArray<nsCString> results;
+  if (!ParseString(data, separator, results))
+    return false;
+  if (int(results.Length()) != len)
+    return false;
+  const char* strings[] = { s1, s2 };
+  for (int i = 0; i < len; ++i) {
+    if (!results[i].Equals(strings[i]))
+      return false;
+  }
+  return true;
+}
+
+static bool test_parse_string_helper0(const char* str, char separator)
+{
+  return test_parse_string_helper(str, separator, 0, nullptr, nullptr);
+}
+
+static bool test_parse_string_helper1(const char* str, char separator, const char* s1)
+{
+  return test_parse_string_helper(str, separator, 1, s1, nullptr);
+}
+
+static bool test_parse_string_helper2(const char* str, char separator, const char* s1, const char* s2)
+{
+  return test_parse_string_helper(str, separator, 2, s1, s2);
+}
+
+static bool test_parse_string()
+{
+  return test_parse_string_helper1("foo, bar", '_', "foo, bar") &&
+         test_parse_string_helper2("foo, bar", ',', "foo", " bar") &&
+         test_parse_string_helper2("foo, bar ", ' ', "foo,", "bar") &&
+         test_parse_string_helper2("foo,bar", 'o', "f", ",bar") &&
+         test_parse_string_helper0("", '_') &&
+         test_parse_string_helper0("  ", ' ') &&
+         test_parse_string_helper1(" foo", ' ', "foo") &&
+         test_parse_string_helper1("  foo", ' ', "foo");
+}
+
+static bool test_strip_chars_helper(const char16_t* str, const char16_t* strip, const nsAString& result, uint32_t offset=0)
+{
+  nsAutoString tmp(str);
+  nsAString& data = tmp;
+  data.StripChars(strip, offset);
+  return data.Equals(result);
+}
+
+static bool test_strip_chars()
+{
+  return test_strip_chars_helper(MOZ_UTF16("foo \r \nbar"),
+                                 MOZ_UTF16(" \n\r"),
+                                 NS_LITERAL_STRING("foobar")) &&
+         test_strip_chars_helper(MOZ_UTF16("\r\nfoo\r\n"),
+                                 MOZ_UTF16(" \n\r"),
+                                 NS_LITERAL_STRING("foo")) &&
+         test_strip_chars_helper(MOZ_UTF16("foo"),
+                                 MOZ_UTF16(" \n\r"),
+                                 NS_LITERAL_STRING("foo")) &&
+         test_strip_chars_helper(MOZ_UTF16("foo"),
+                                 MOZ_UTF16("fo"),
+                                 NS_LITERAL_STRING("")) &&
+         test_strip_chars_helper(MOZ_UTF16("foo"),
+                                 MOZ_UTF16("foo"),
+                                 NS_LITERAL_STRING("")) &&
+         test_strip_chars_helper(MOZ_UTF16(" foo"),
+                                 MOZ_UTF16(" "),
+                                 NS_LITERAL_STRING(" foo"), 1);
+}
+
+static bool test_huge_capacity()
+{
+  nsString a, b, c, d, e, f, g, h, i, j, k, l, m, n;
+  nsCString n1;
+  bool fail = false;
+#undef ok
+#define ok(x) { fail |= !(x); }
+
+  ok(a.SetCapacity(1));
+  ok(!a.SetCapacity(nsString::size_type(-1)/2));
+  ok(a.SetCapacity(0));  // free the allocated memory
+
+  ok(b.SetCapacity(1));
+  ok(!b.SetCapacity(nsString::size_type(-1)/2 - 1));
+  ok(b.SetCapacity(0));
+
+  ok(c.SetCapacity(1));
+  ok(!c.SetCapacity(nsString::size_type(-1)/2));
+  ok(c.SetCapacity(0));
+
+  ok(!d.SetCapacity(nsString::size_type(-1)/2 - 1));
+  ok(!d.SetCapacity(nsString::size_type(-1)/2));
+  ok(d.SetCapacity(0));
+
+  ok(!e.SetCapacity(nsString::size_type(-1)/4));
+  ok(!e.SetCapacity(nsString::size_type(-1)/4 + 1));
+  ok(e.SetCapacity(0));
+
+  ok(!f.SetCapacity(nsString::size_type(-1)/2));
+  ok(f.SetCapacity(0));
+
+  ok(!g.SetCapacity(nsString::size_type(-1)/4 + 1000));
+  ok(!g.SetCapacity(nsString::size_type(-1)/4 + 1001));
+  ok(g.SetCapacity(0));
+
+  ok(!h.SetCapacity(nsString::size_type(-1)/4+1));
+  ok(!h.SetCapacity(nsString::size_type(-1)/2));
+  ok(h.SetCapacity(0));
+
+  ok(i.SetCapacity(1));
+  ok(i.SetCapacity(nsString::size_type(-1)/4 - 1000));
+  ok(!i.SetCapacity(nsString::size_type(-1)/4 + 1));
+  ok(i.SetCapacity(0));
+
+  ok(j.SetCapacity(nsString::size_type(-1)/4 - 1000));
+  ok(!j.SetCapacity(nsString::size_type(-1)/4 + 1));
+  ok(j.SetCapacity(0));
+
+  ok(k.SetCapacity(nsString::size_type(-1)/8 - 1000));
+  ok(k.SetCapacity(nsString::size_type(-1)/4 - 1001));
+  ok(k.SetCapacity(nsString::size_type(-1)/4 - 998));
+  ok(!k.SetCapacity(nsString::size_type(-1)/4 + 1));
+  ok(k.SetCapacity(0));
+
+  ok(l.SetCapacity(nsString::size_type(-1)/8));
+  ok(l.SetCapacity(nsString::size_type(-1)/8 + 1));
+  ok(l.SetCapacity(nsString::size_type(-1)/8 + 2));
+  ok(l.SetCapacity(0));
+
+  ok(m.SetCapacity(nsString::size_type(-1)/8 + 1000));
+  ok(m.SetCapacity(nsString::size_type(-1)/8 + 1001));
+  ok(m.SetCapacity(0));
+
+  ok(n.SetCapacity(nsString::size_type(-1)/8+1));
+  ok(!n.SetCapacity(nsString::size_type(-1)/4));
+  ok(n.SetCapacity(0));
+
+  ok(n.SetCapacity(0));
+  ok(n.SetCapacity((nsString::size_type(-1)/2 - sizeof(nsStringBuffer)) / 2 - 2));
+  ok(n.SetCapacity(0));
+  ok(!n.SetCapacity((nsString::size_type(-1)/2 - sizeof(nsStringBuffer)) / 2 - 1));
+  ok(n.SetCapacity(0));
+  ok(n1.SetCapacity(0));
+  ok(n1.SetCapacity((nsCString::size_type(-1)/2 - sizeof(nsStringBuffer)) / 1 - 2));
+  ok(n1.SetCapacity(0));
+  ok(!n1.SetCapacity((nsCString::size_type(-1)/2 - sizeof(nsStringBuffer)) / 1 - 1));
+  ok(n1.SetCapacity(0));
+
+  // Ignore the result if the address space is less than 64-bit because
+  // some of the allocations above will exhaust the address space.  
+  if (sizeof(void*) >= 8) {
+    return !fail;
+  }
+  return true;
+}
+
+static bool test_tofloat_helper(const nsString& aStr, float aExpected, bool aSuccess)
+{
+  int32_t result;
+  return aStr.ToFloat(&result) == aExpected &&
+         aSuccess ? result == NS_OK : result != NS_OK;
+}
+
+static bool test_tofloat()
+{
+  return \
+    test_tofloat_helper(NS_LITERAL_STRING("42"), 42.f, true) &&
+    test_tofloat_helper(NS_LITERAL_STRING("42.0"), 42.f, true) &&
+    test_tofloat_helper(NS_LITERAL_STRING("-42"), -42.f, true) &&
+    test_tofloat_helper(NS_LITERAL_STRING("+42"), 42, true) &&
+    test_tofloat_helper(NS_LITERAL_STRING("13.37"), 13.37f, true) &&
+    test_tofloat_helper(NS_LITERAL_STRING("1.23456789"), 1.23456789f, true) &&
+    test_tofloat_helper(NS_LITERAL_STRING("1.98765432123456"), 1.98765432123456f, true) &&
+    test_tofloat_helper(NS_LITERAL_STRING("0"), 0.f, true) &&
+    test_tofloat_helper(NS_LITERAL_STRING("1.e5"), 100000, true) &&
+    test_tofloat_helper(NS_LITERAL_STRING(""), 0.f, false) &&
+    test_tofloat_helper(NS_LITERAL_STRING("42foo"), 42.f, false) &&
+    test_tofloat_helper(NS_LITERAL_STRING("foo"), 0.f, false) &&
+    true;
+}
+
+static bool test_todouble_helper(const nsString& aStr, double aExpected, bool aSuccess)
+{
+  int32_t result;
+  return aStr.ToDouble(&result) == aExpected &&
+         aSuccess ? result == NS_OK : result != NS_OK;
+}
+
+static bool test_todouble()
+{
+  return \
+    test_todouble_helper(NS_LITERAL_STRING("42"), 42, true) &&
+    test_todouble_helper(NS_LITERAL_STRING("42.0"), 42, true) &&
+    test_todouble_helper(NS_LITERAL_STRING("-42"), -42, true) &&
+    test_todouble_helper(NS_LITERAL_STRING("+42"), 42, true) &&
+    test_todouble_helper(NS_LITERAL_STRING("13.37"), 13.37, true) &&
+    test_todouble_helper(NS_LITERAL_STRING("1.23456789"), 1.23456789, true) &&
+    test_todouble_helper(NS_LITERAL_STRING("1.98765432123456"), 1.98765432123456, true) &&
+    test_todouble_helper(NS_LITERAL_STRING("123456789.98765432123456"), 123456789.98765432123456, true) &&
+    test_todouble_helper(NS_LITERAL_STRING("0"), 0, true) &&
+    test_todouble_helper(NS_LITERAL_STRING("1.e5"), 100000, true) &&
+    test_todouble_helper(NS_LITERAL_STRING(""), 0, false) &&
+    test_todouble_helper(NS_LITERAL_STRING("42foo"), 42, false) &&
+    test_todouble_helper(NS_LITERAL_STRING("foo"), 0, false) &&
+    true;
+}
+
+//----
+
+typedef bool (*TestFunc)();
+
+static const struct Test
+  {
+    const char* name;
+    TestFunc    func;
+  }
+tests[] =
+  {
+    { "test_assign", test_assign },
+    { "test_assign_c", test_assign_c },
+    { "test1", test1 },
+    { "test2", test2 },
+    { "test_find", test_find },
+    { "test_rfind", test_rfind },
+    { "test_rfind_2", test_rfind_2 },
+    { "test_rfind_3", test_rfind_3 },
+    { "test_rfind_4", test_rfind_4 },
+    { "test_findinreadable", test_findinreadable },
+    { "test_rfindinreadable", test_rfindinreadable },
+    { "test_distance", test_distance },
+    { "test_length", test_length },
+    { "test_trim", test_trim },
+    { "test_replace_substr", test_replace_substr },
+    { "test_replace_substr_2", test_replace_substr_2 },
+    { "test_strip_ws", test_strip_ws },
+    { "test_equals_ic", test_equals_ic },
+    { "test_fixed_string", test_fixed_string },
+    { "test_concat", test_concat },
+    { "test_concat_2", test_concat_2 },
+    { "test_concat_3", test_concat_3 },
+    { "test_xpidl_string", test_xpidl_string },
+    { "test_empty_assign", test_empty_assign },
+    { "test_set_length", test_set_length },
+    { "test_substring", test_substring },
+    { "test_appendint", test_appendint },
+    { "test_appendint64", test_appendint64 },
+    { "test_appendfloat", test_appendfloat },
+    { "test_findcharinset", test_findcharinset },
+    { "test_rfindcharinset", test_rfindcharinset },
+    { "test_stringbuffer", test_stringbuffer },
+    { "test_voided", test_voided },
+    { "test_voided_autostr", test_voided_autostr },
+    { "test_voided_assignment", test_voided_assignment },
+    { "test_empty_assignment", test_empty_assignment },
+    { "test_string_tointeger", test_string_tointeger },
+    { "test_parse_string", test_parse_string },
+    { "test_strip_chars", test_strip_chars },
+    { "test_huge_capacity", test_huge_capacity },
+    { "test_tofloat", test_tofloat },
+    { "test_todouble", test_todouble },
+    { nullptr, nullptr }
+  };
+
+}
+
+using namespace TestStrings;
+
+int main(int argc, char **argv)
+  {
+    int count = 1;
+    if (argc > 1)
+      count = atoi(argv[1]);
+
+    NS_LogInit();
+
+    while (count--)
+      {
+        for (const Test* t = tests; t->name != nullptr; ++t)
+          {
+            printf("%25s : %s\n", t->name, t->func() ? "SUCCESS" : "FAILURE <--");
+          }
+      }
+    
+    return 0;
+  }