From a8bd174cd088d7f5fa278805d4ef0772ae00a248 Mon Sep 17 00:00:00 2001
From: voddan <dgvodopyan@gmail.com>
Date: Thu, 31 Mar 2016 11:42:39 +0300
Subject: [PATCH] Added tests for parsing with radix. #KT-8286

---
 .../test/text/ParsePrimitivesJVMTest.kt       | 68 +++++++++++++++++--
 1 file changed, 62 insertions(+), 6 deletions(-)

diff --git a/libraries/stdlib/test/text/ParsePrimitivesJVMTest.kt b/libraries/stdlib/test/text/ParsePrimitivesJVMTest.kt
index 12f2a84cbf8..30fc5326afd 100644
--- a/libraries/stdlib/test/text/ParsePrimitivesJVMTest.kt
+++ b/libraries/stdlib/test/text/ParsePrimitivesJVMTest.kt
@@ -15,25 +15,32 @@ class ParsePrimitivesJVMTest {
 
     @test fun toByte() {
         CompareBehaviorContext({it.toByte()}, {it.toByteOrNull()}).apply {
-
             assertProduce("+77", 77.toByte())
             assertProduce("-128", Byte.MIN_VALUE)
             assertFailsOrNull("128")
         }
+
+        CompareBehaviorWithRadixContext(String::toByte, String::toByteOrNull).apply {
+            assertProduce(16, "7F", 127.toByte())
+            assertFailsOrNull(2, "10000000")
+        }
     }
 
     @test fun toShort() {
         CompareBehaviorContext({it.toShort()}, {it.toShortOrNull()}).apply {
-
             assertProduce("77", 77.toShort())
             assertProduce("-32768", Short.MIN_VALUE)
             assertFailsOrNull("+32768")
         }
+
+        CompareBehaviorWithRadixContext(String::toShort, String::toShortOrNull).apply {
+            assertProduce(16, "7F", 127.toShort())
+            assertFailsOrNull(5, "10000000")
+        }
     }
 
     @test fun toInt() {
         CompareBehaviorContext({it.toInt()}, {it.toIntOrNull()}).apply {
-
             assertProduce("77", 77)
             assertProduce("+2147483647", Int.MAX_VALUE)
             assertProduce("-2147483648", Int.MIN_VALUE)
@@ -42,11 +49,30 @@ class ParsePrimitivesJVMTest {
             assertFailsOrNull("-2147483649")
             assertFailsOrNull("239239kotlin")
         }
+
+        CompareBehaviorWithRadixContext(String::toInt, String::toIntOrNull).apply {
+            assertProduce(10, "0", 0)
+            assertProduce(10, "473", 473)
+            assertProduce(10, "+42", 42)
+            assertProduce(10, "-0", 0)
+            assertProduce(10, "2147483647", 2147483647)
+            assertProduce(10, "-2147483648", -2147483648)
+
+            assertProduce(16, "-FF", -255)
+            assertProduce(2, "1100110", 102)
+            assertProduce(27, "Kona", 411787)
+
+            assertFailsOrNull(10, "2147483648")
+            assertFailsOrNull(8, "99")
+            assertFailsOrNull(10, "Kona")
+        }
+
+        assertFailsWith<NumberFormatException>("Expected to fail with radix 1") { "1".toInt(radix = 1) }
+        assertFailsWith<NumberFormatException>("Expected to fail with radix 37") { "37".toIntOrNull(radix = 37) }
     }
 
     @test fun toLong() {
         CompareBehaviorContext({it.toLong()}, {it.toLongOrNull()}).apply {
-
             assertProduce("77", 77.toLong())
             assertProduce("+9223372036854775807", Long.MAX_VALUE)
             assertProduce("-9223372036854775808", Long.MIN_VALUE)
@@ -58,11 +84,27 @@ class ParsePrimitivesJVMTest {
             assertFailsOrNull("92233`75809")
             assertFailsOrNull("-922337KOTLIN775809")
         }
+
+        CompareBehaviorWithRadixContext(String::toLong, String::toLongOrNull).apply {
+            assertProduce(10, "0", 0L)
+            assertProduce(10, "473", 473L)
+            assertProduce(10, "+42", 42L)
+            assertProduce(10, "-0", 0L)
+
+            assertProduce(16, "-FF", -255L)
+            assertProduce(2, "1100110", 102L)
+            assertProduce(36, "Hazelnut", 1356099454469L)
+
+            assertFailsOrNull(8, "99")
+            assertFailsOrNull(10, "Hazelnut")
+        }
+
+        assertFailsWith<NumberFormatException>("Expected to fail with radix 37") { "37".toLong(radix = 37) }
+        assertFailsWith<NumberFormatException>("Expected to fail with radix 1") { "1".toLongOrNull(radix = 1) }
     }
 
     @test fun toFloat() {
         CompareBehaviorContext({it.toFloat()}, {it.toFloatOrNull()}).apply {
-
             assertProduce("77.0", 77.0f)
             assertProduce("-1e39", Float.NEGATIVE_INFINITY)
             assertProduce("1000000000000000000000000000000000000000", Float.POSITIVE_INFINITY)
@@ -72,7 +114,6 @@ class ParsePrimitivesJVMTest {
 
     @test fun toDouble() {
         CompareBehaviorContext({it.toDouble()}, {it.toDoubleOrNull()}).apply {
-
             assertProduce("-77", -77.0)
             assertProduce("77.", 77.0)
             assertProduce("77.0", 77.0)
@@ -107,3 +148,18 @@ private class CompareBehaviorContext<T: Any>(val convertOrFail: (String) -> T,
         assertNull (convertOrNull(input), message = "On input \"$input\"")
     }
 }
+
+private class CompareBehaviorWithRadixContext<T: Any>(val convertOrFail: String.(Int) -> T,
+                                                      val convertOrNull: String.(Int) -> T?) {
+    fun assertProduce(radix: Int, input: String, output: T) {
+        assertEquals(output, input.convertOrFail(radix))
+        assertEquals(output, input.convertOrNull(radix))
+    }
+
+    fun assertFailsOrNull(radix: Int, input: String) {
+        assertFailsWith<NumberFormatException>("Expected to fail on input \"$input\" with radix $radix",
+                                               { input.convertOrFail(radix) })
+
+        assertNull (input.convertOrNull(radix), message = "On input \"$input\" with radix $radix")
+    }
+}