Statically disallow invalid radix, fix unittests

Author: andralex

src/core/internal/string.d

@@ -29,11 +29,8 @@ Returns:
     The unsigned integer value as a string of characters
 */
 char[] unsignedToTempString(uint radix = 10)(ulong value, return scope char[] buf) @safe
+if (radix >= 2 && radix <= 16)
 {
-    if (radix < 2)
-        // not a valid radix, just return an empty string
-        return buf[$ .. $];
-
     size_t i = buf.length;
     do
     {
@@ -105,8 +102,8 @@ unittest
     assert(ulong.max.unsignedToTempString == "18446744073709551615");
 
     // test bad radices
-    assert(100.unsignedToTempString!1(buf) == "");
-    assert(100.unsignedToTempString!0(buf) == "");
+    assert(!is(typeof(100.unsignedToTempString!1(buf))));
+    assert(!is(typeof(100.unsignedToTempString!0(buf) == "")));
 }
 
 alias SignedStringBuf = char[20];
@@ -144,34 +141,34 @@ auto signedToTempString(uint radix = 10)(long value) @safe
 unittest
 {
     SignedStringBuf buf;
-    assert(0.signedToTempString(buf, 10) == "0");
+    assert(0.signedToTempString(buf) == "0");
     assert(1.signedToTempString(buf) == "1");
     assert((-1).signedToTempString(buf) == "-1");
     assert(12.signedToTempString(buf) == "12");
     assert((-12).signedToTempString(buf) == "-12");
-    assert(0x12ABCF .signedToTempString(buf, 16) == "12abcf");
-    assert((-0x12ABCF) .signedToTempString(buf, 16) == "-12abcf");
+    assert(0x12ABCF .signedToTempString(buf) == "12abcf");
+    assert((-0x12ABCF) .signedToTempString(buf) == "-12abcf");
     assert(long.sizeof.signedToTempString(buf) == "8");
     assert(int.max.signedToTempString(buf) == "2147483647");
     assert(int.min.signedToTempString(buf) == "-2147483648");
     assert(long.max.signedToTempString(buf) == "9223372036854775807");
     assert(long.min.signedToTempString(buf) == "-9223372036854775808");
 
     // use stack allocated struct version
-    assert(0.signedToTempString(10) == "0");
+    assert(0.signedToTempString() == "0");
     assert(1.signedToTempString == "1");
     assert((-1).signedToTempString == "-1");
     assert(12.signedToTempString == "12");
     assert((-12).signedToTempString == "-12");
-    assert(0x12ABCF .signedToTempString(16) == "12abcf");
-    assert((-0x12ABCF) .signedToTempString(16) == "-12abcf");
+    assert(0x12ABCF .signedToTempString!16 == "12abcf");
+    assert((-0x12ABCF) .signedToTempString!16 == "-12abcf");
     assert(long.sizeof.signedToTempString == "8");
     assert(int.max.signedToTempString == "2147483647");
     assert(int.min.signedToTempString == "-2147483648");
     assert(long.max.signedToTempString == "9223372036854775807");
     assert(long.min.signedToTempString == "-9223372036854775808");
-    assert(long.max.signedToTempString(2) == "111111111111111111111111111111111111111111111111111111111111111");
-    assert(long.min.signedToTempString(2) == "-1000000000000000000000000000000000000000000000000000000000000000");
+    assert(long.max.signedToTempString!2 == "111111111111111111111111111111111111111111111111111111111111111");
+    assert(long.min.signedToTempString!2 == "-1000000000000000000000000000000000000000000000000000000000000000");
 }
 
 

src/core/time.d

@@ -1806,7 +1806,7 @@ unittest
         auto _str(F)(F val)
         {
             static if (is(F == int) || is(F == long))
-                return signedToTempString(val, 10);
+                return signedToTempString(val);
             else
                 return unsignedToTempString(val);
         }
@@ -2407,8 +2407,8 @@ assert(before + timeElapsed == after);
         static if (clockType == ClockType.normal)
             return "MonoTime(" ~ signedToTempString(_ticks) ~ " ticks, " ~ signedToTempString(ticksPerSecond) ~ " ticks per second)";
         else
-            return "MonoTimeImpl!(ClockType." ~ _clockName ~ ")(" ~ signedToTempString(_ticks, 10) ~ " ticks, " ~
-                   signedToTempString(ticksPerSecond, 10) ~ " ticks per second)";
+            return "MonoTimeImpl!(ClockType." ~ _clockName ~ ")(" ~ signedToTempString(_ticks) ~ " ticks, " ~
+                   signedToTempString(ticksPerSecond) ~ " ticks per second)";
     }
 
     version (CoreUnittest) unittest
@@ -2428,9 +2428,9 @@ assert(before + timeElapsed == after);
         else
             eat(str, "MonoTimeImpl!(ClockType."~_clockName~")(");
 
-        eat(str, signedToTempString(mt._ticks, 10));
+        eat(str, signedToTempString(mt._ticks));
         eat(str, " ticks, ");
-        eat(str, signedToTempString(ticksPerSecond, 10));
+        eat(str, signedToTempString(ticksPerSecond));
         eat(str, " ticks per second)");
     }
 
@@ -3970,7 +3970,7 @@ string doubleToString(double value) @safe pure nothrow
     if (value < 0 && cast(long)value == 0)
         result = "-0";
     else
-        result = signedToTempString(cast(long)value, 10).idup;
+        result = signedToTempString(cast(long)value).idup;
     result ~= '.';
     result ~= unsignedToTempString(cast(ulong)(_abs((value - cast(long)value) * 1_000_000) + .5));
 
@@ -3996,7 +3996,7 @@ unittest
 
 version (CoreUnittest) const(char)* numToStringz()(long value) @trusted pure nothrow
 {
-    return (signedToTempString(value, 10) ~ "\0").ptr;
+    return (signedToTempString(value) ~ "\0").ptr;
 }
 
 
@@ -4121,9 +4121,9 @@ version (CoreUnittest) void assertApprox(D, E)(D actual,
 {
     if (actual.length < lower.length || actual.length > upper.length)
     {
-        throw new AssertError(msg ~ (": [" ~ signedToTempString(lower.length, 10) ~ "] [" ~
-                              signedToTempString(actual.length, 10) ~ "] [" ~
-                              signedToTempString(upper.length, 10) ~ "]").idup,
+        throw new AssertError(msg ~ (": [" ~ signedToTempString(lower.length) ~ "] [" ~
+                              signedToTempString(actual.length) ~ "] [" ~
+                              signedToTempString(upper.length) ~ "]").idup,
                               __FILE__, line);
     }
 }
@@ -4145,7 +4145,7 @@ version (CoreUnittest) void assertApprox()(long actual,
                                       size_t line = __LINE__)
 {
     if (actual < lower)
-        throw new AssertError(msg ~ ": lower: " ~ signedToTempString(actual, 10).idup, __FILE__, line);
+        throw new AssertError(msg ~ ": lower: " ~ signedToTempString(actual).idup, __FILE__, line);
     if (actual > upper)
-        throw new AssertError(msg ~ ": upper: " ~ signedToTempString(actual, 10).idup, __FILE__, line);
+        throw new AssertError(msg ~ ": upper: " ~ signedToTempString(actual).idup, __FILE__, line);
 }