Add support for generating unsigned progression iteration codegen tests

2018-08-02 23:49:25 +03:00
parent 1dbaaf7f8a
commit bb1ce52267
13 changed files with 398 additions and 29 deletions
@@ -57,5 +57,45 @@ fun box(): String {
        return "Wrong elements for 'z'..'a': $list5"
    }

+    val list6 = ArrayList<UInt>()
+    val range6 = 10u..5u
+    for (i in range6) {
+        list6.add(i)
+        if (list6.size > 23) break
+    }
+    if (list6 != listOf<UInt>()) {
+        return "Wrong elements for 10u..5u: $list6"
+    }
+
+    val list7 = ArrayList<UInt>()
+    val range7 = 10u.toUByte()..5u.toUByte()
+    for (i in range7) {
+        list7.add(i)
+        if (list7.size > 23) break
+    }
+    if (list7 != listOf<UInt>()) {
+        return "Wrong elements for 10u.toUByte()..5u.toUByte(): $list7"
+    }
+
+    val list8 = ArrayList<UInt>()
+    val range8 = 10u.toUShort()..5u.toUShort()
+    for (i in range8) {
+        list8.add(i)
+        if (list8.size > 23) break
+    }
+    if (list8 != listOf<UInt>()) {
+        return "Wrong elements for 10u.toUShort()..5u.toUShort(): $list8"
+    }
+
+    val list9 = ArrayList<ULong>()
+    val range9 = 10uL..5uL
+    for (i in range9) {
+        list9.add(i)
+        if (list9.size > 23) break
+    }
+    if (list9 != listOf<ULong>()) {
+        return "Wrong elements for 10uL..5uL: $list9"
+    }
+
    return "OK"
 }
@@ -10,6 +10,8 @@ const val MaxB = Byte.MAX_VALUE
 const val MaxS = Short.MAX_VALUE
 const val MaxL = Long.MAX_VALUE
 const val MaxC = Char.MAX_VALUE
+const val MaxUI = UInt.MAX_VALUE
+const val MaxUL = ULong.MAX_VALUE

 fun box(): String {
    val list1 = ArrayList<Int>()
@@ -62,5 +64,25 @@ fun box(): String {
        return "Wrong elements for (MaxC - 2)..MaxC: $list5"
    }

+    val list6 = ArrayList<UInt>()
+    val range6 = (MaxUI - 2u)..MaxUI
+    for (i in range6) {
+        list6.add(i)
+        if (list6.size > 23) break
+    }
+    if (list6 != listOf<UInt>(MaxUI - 2u, MaxUI - 1u, MaxUI)) {
+        return "Wrong elements for (MaxUI - 2u)..MaxUI: $list6"
+    }
+
+    val list7 = ArrayList<ULong>()
+    val range7 = (MaxUL - 2u)..MaxUL
+    for (i in range7) {
+        list7.add(i)
+        if (list7.size > 23) break
+    }
+    if (list7 != listOf<ULong>(MaxUL - 2u, MaxUL - 1u, MaxUL)) {
+        return "Wrong elements for (MaxUL - 2u)..MaxUL: $list7"
+    }
+
    return "OK"
 }
@@ -10,6 +10,8 @@ const val MaxB = Byte.MAX_VALUE
 const val MaxS = Short.MAX_VALUE
 const val MaxL = Long.MAX_VALUE
 const val MaxC = Char.MAX_VALUE
+const val MaxUI = UInt.MAX_VALUE
+const val MaxUL = ULong.MAX_VALUE

 fun box(): String {
    val list1 = ArrayList<Int>()
@@ -62,5 +64,25 @@ fun box(): String {
        return "Wrong elements for MaxC..MaxC: $list5"
    }

+    val list6 = ArrayList<UInt>()
+    val range6 = MaxUI..MaxUI
+    for (i in range6) {
+        list6.add(i)
+        if (list6.size > 23) break
+    }
+    if (list6 != listOf<UInt>(MaxUI)) {
+        return "Wrong elements for MaxUI..MaxUI: $list6"
+    }
+
+    val list7 = ArrayList<ULong>()
+    val range7 = MaxUL..MaxUL
+    for (i in range7) {
+        list7.add(i)
+        if (list7.size > 23) break
+    }
+    if (list7 != listOf<ULong>(MaxUL)) {
+        return "Wrong elements for MaxUL..MaxUL: $list7"
+    }
+
    return "OK"
 }
@@ -15,6 +15,10 @@ const val MaxL = Long.MAX_VALUE
 const val MinL = Long.MIN_VALUE
 const val MaxC = Char.MAX_VALUE
 const val MinC = Char.MIN_VALUE
+const val MaxUI = UInt.MAX_VALUE
+const val MinUI = UInt.MIN_VALUE
+const val MaxUL = ULong.MAX_VALUE
+const val MinUL = ULong.MIN_VALUE

 fun box(): String {
    val list1 = ArrayList<Int>()
@@ -67,5 +71,25 @@ fun box(): String {
        return "Wrong elements for MaxC..MinC: $list5"
    }

+    val list6 = ArrayList<UInt>()
+    val range6 = MaxUI..MinUI
+    for (i in range6) {
+        list6.add(i)
+        if (list6.size > 23) break
+    }
+    if (list6 != listOf<UInt>()) {
+        return "Wrong elements for MaxUI..MinUI: $list6"
+    }
+
+    val list7 = ArrayList<ULong>()
+    val range7 = MaxUL..MinUL
+    for (i in range7) {
+        list7.add(i)
+        if (list7.size > 23) break
+    }
+    if (list7 != listOf<ULong>()) {
+        return "Wrong elements for MaxUL..MinUL: $list7"
+    }
+
    return "OK"
 }
@@ -57,5 +57,45 @@ fun box(): String {
        return "Wrong elements for 'k'..'k': $list5"
    }

+    val list6 = ArrayList<UInt>()
+    val range6 = 5u..5u
+    for (i in range6) {
+        list6.add(i)
+        if (list6.size > 23) break
+    }
+    if (list6 != listOf<UInt>(5u)) {
+        return "Wrong elements for 5u..5u: $list6"
+    }
+
+    val list7 = ArrayList<UInt>()
+    val range7 = 5u.toUByte()..5u.toUByte()
+    for (i in range7) {
+        list7.add(i)
+        if (list7.size > 23) break
+    }
+    if (list7 != listOf<UInt>(5u)) {
+        return "Wrong elements for 5u.toUByte()..5u.toUByte(): $list7"
+    }
+
+    val list8 = ArrayList<UInt>()
+    val range8 = 5u.toUShort()..5u.toUShort()
+    for (i in range8) {
+        list8.add(i)
+        if (list8.size > 23) break
+    }
+    if (list8 != listOf<UInt>(5u)) {
+        return "Wrong elements for 5u.toUShort()..5u.toUShort(): $list8"
+    }
+
+    val list9 = ArrayList<ULong>()
+    val range9 = 5uL..5uL
+    for (i in range9) {
+        list9.add(i)
+        if (list9.size > 23) break
+    }
+    if (list9 != listOf<ULong>(5uL)) {
+        return "Wrong elements for 5uL..5uL: $list9"
+    }
+
    return "OK"
 }
@@ -57,5 +57,45 @@ fun box(): String {
        return "Wrong elements for 'c'..'g': $list5"
    }

+    val list6 = ArrayList<UInt>()
+    val range6 = 3u..5u
+    for (i in range6) {
+        list6.add(i)
+        if (list6.size > 23) break
+    }
+    if (list6 != listOf<UInt>(3u, 4u, 5u)) {
+        return "Wrong elements for 3u..5u: $list6"
+    }
+
+    val list7 = ArrayList<UInt>()
+    val range7 = 3.toUByte()..5.toUByte()
+    for (i in range7) {
+        list7.add(i)
+        if (list7.size > 23) break
+    }
+    if (list7 != listOf<UInt>(3u, 4u, 5u)) {
+        return "Wrong elements for 3.toUByte()..5.toUByte(): $list7"
+    }
+
+    val list8 = ArrayList<UInt>()
+    val range8 = 3.toUShort()..5.toUShort()
+    for (i in range8) {
+        list8.add(i)
+        if (list8.size > 23) break
+    }
+    if (list8 != listOf<UInt>(3u, 4u, 5u)) {
+        return "Wrong elements for 3.toUShort()..5.toUShort(): $list8"
+    }
+
+    val list9 = ArrayList<ULong>()
+    val range9 = 3uL..5uL
+    for (i in range9) {
+        list9.add(i)
+        if (list9.size > 23) break
+    }
+    if (list9 != listOf<ULong>(3u, 4u, 5u)) {
+        return "Wrong elements for 3uL..5uL: $list9"
+    }
+
    return "OK"
 }
@@ -52,5 +52,41 @@ fun box(): String {
        return "Wrong elements for 'z'..'a': $list5"
    }

+    val list6 = ArrayList<UInt>()
+    for (i in 10u..5u) {
+        list6.add(i)
+        if (list6.size > 23) break
+    }
+    if (list6 != listOf<UInt>()) {
+        return "Wrong elements for 10u..5u: $list6"
+    }
+
+    val list7 = ArrayList<UInt>()
+    for (i in 10u.toUByte()..5u.toUByte()) {
+        list7.add(i)
+        if (list7.size > 23) break
+    }
+    if (list7 != listOf<UInt>()) {
+        return "Wrong elements for 10u.toUByte()..5u.toUByte(): $list7"
+    }
+
+    val list8 = ArrayList<UInt>()
+    for (i in 10u.toUShort()..5u.toUShort()) {
+        list8.add(i)
+        if (list8.size > 23) break
+    }
+    if (list8 != listOf<UInt>()) {
+        return "Wrong elements for 10u.toUShort()..5u.toUShort(): $list8"
+    }
+
+    val list9 = ArrayList<ULong>()
+    for (i in 10uL..5uL) {
+        list9.add(i)
+        if (list9.size > 23) break
+    }
+    if (list9 != listOf<ULong>()) {
+        return "Wrong elements for 10uL..5uL: $list9"
+    }
+
    return "OK"
 }
@@ -10,6 +10,8 @@ const val MaxB = Byte.MAX_VALUE
 const val MaxS = Short.MAX_VALUE
 const val MaxL = Long.MAX_VALUE
 const val MaxC = Char.MAX_VALUE
+const val MaxUI = UInt.MAX_VALUE
+const val MaxUL = ULong.MAX_VALUE

 fun box(): String {
    val list1 = ArrayList<Int>()
@@ -57,5 +59,23 @@ fun box(): String {
        return "Wrong elements for (MaxC - 2)..MaxC: $list5"
    }

+    val list6 = ArrayList<UInt>()
+    for (i in (MaxUI - 2u)..MaxUI) {
+        list6.add(i)
+        if (list6.size > 23) break
+    }
+    if (list6 != listOf<UInt>(MaxUI - 2u, MaxUI - 1u, MaxUI)) {
+        return "Wrong elements for (MaxUI - 2u)..MaxUI: $list6"
+    }
+
+    val list7 = ArrayList<ULong>()
+    for (i in (MaxUL - 2u)..MaxUL) {
+        list7.add(i)
+        if (list7.size > 23) break
+    }
+    if (list7 != listOf<ULong>(MaxUL - 2u, MaxUL - 1u, MaxUL)) {
+        return "Wrong elements for (MaxUL - 2u)..MaxUL: $list7"
+    }
+
    return "OK"
 }
@@ -10,6 +10,8 @@ const val MaxB = Byte.MAX_VALUE
 const val MaxS = Short.MAX_VALUE
 const val MaxL = Long.MAX_VALUE
 const val MaxC = Char.MAX_VALUE
+const val MaxUI = UInt.MAX_VALUE
+const val MaxUL = ULong.MAX_VALUE

 fun box(): String {
    val list1 = ArrayList<Int>()
@@ -57,5 +59,23 @@ fun box(): String {
        return "Wrong elements for MaxC..MaxC: $list5"
    }

+    val list6 = ArrayList<UInt>()
+    for (i in MaxUI..MaxUI) {
+        list6.add(i)
+        if (list6.size > 23) break
+    }
+    if (list6 != listOf<UInt>(MaxUI)) {
+        return "Wrong elements for MaxUI..MaxUI: $list6"
+    }
+
+    val list7 = ArrayList<ULong>()
+    for (i in MaxUL..MaxUL) {
+        list7.add(i)
+        if (list7.size > 23) break
+    }
+    if (list7 != listOf<ULong>(MaxUL)) {
+        return "Wrong elements for MaxUL..MaxUL: $list7"
+    }
+
    return "OK"
 }
@@ -15,6 +15,10 @@ const val MaxL = Long.MAX_VALUE
 const val MinL = Long.MIN_VALUE
 const val MaxC = Char.MAX_VALUE
 const val MinC = Char.MIN_VALUE
+const val MaxUI = UInt.MAX_VALUE
+const val MinUI = UInt.MIN_VALUE
+const val MaxUL = ULong.MAX_VALUE
+const val MinUL = ULong.MIN_VALUE

 fun box(): String {
    val list1 = ArrayList<Int>()
@@ -62,5 +66,23 @@ fun box(): String {
        return "Wrong elements for MaxC..MinC: $list5"
    }

+    val list6 = ArrayList<UInt>()
+    for (i in MaxUI..MinUI) {
+        list6.add(i)
+        if (list6.size > 23) break
+    }
+    if (list6 != listOf<UInt>()) {
+        return "Wrong elements for MaxUI..MinUI: $list6"
+    }
+
+    val list7 = ArrayList<ULong>()
+    for (i in MaxUL..MinUL) {
+        list7.add(i)
+        if (list7.size > 23) break
+    }
+    if (list7 != listOf<ULong>()) {
+        return "Wrong elements for MaxUL..MinUL: $list7"
+    }
+
    return "OK"
 }
@@ -52,5 +52,41 @@ fun box(): String {
        return "Wrong elements for 'k'..'k': $list5"
    }

+    val list6 = ArrayList<UInt>()
+    for (i in 5u..5u) {
+        list6.add(i)
+        if (list6.size > 23) break
+    }
+    if (list6 != listOf<UInt>(5u)) {
+        return "Wrong elements for 5u..5u: $list6"
+    }
+
+    val list7 = ArrayList<UInt>()
+    for (i in 5u.toUByte()..5u.toUByte()) {
+        list7.add(i)
+        if (list7.size > 23) break
+    }
+    if (list7 != listOf<UInt>(5u)) {
+        return "Wrong elements for 5u.toUByte()..5u.toUByte(): $list7"
+    }
+
+    val list8 = ArrayList<UInt>()
+    for (i in 5u.toUShort()..5u.toUShort()) {
+        list8.add(i)
+        if (list8.size > 23) break
+    }
+    if (list8 != listOf<UInt>(5u)) {
+        return "Wrong elements for 5u.toUShort()..5u.toUShort(): $list8"
+    }
+
+    val list9 = ArrayList<ULong>()
+    for (i in 5uL..5uL) {
+        list9.add(i)
+        if (list9.size > 23) break
+    }
+    if (list9 != listOf<ULong>(5uL)) {
+        return "Wrong elements for 5uL..5uL: $list9"
+    }
+
    return "OK"
 }
@@ -52,5 +52,41 @@ fun box(): String {
        return "Wrong elements for 'c'..'g': $list5"
    }

+    val list6 = ArrayList<UInt>()
+    for (i in 3u..5u) {
+        list6.add(i)
+        if (list6.size > 23) break
+    }
+    if (list6 != listOf<UInt>(3u, 4u, 5u)) {
+        return "Wrong elements for 3u..5u: $list6"
+    }
+
+    val list7 = ArrayList<UInt>()
+    for (i in 3.toUByte()..5.toUByte()) {
+        list7.add(i)
+        if (list7.size > 23) break
+    }
+    if (list7 != listOf<UInt>(3u, 4u, 5u)) {
+        return "Wrong elements for 3.toUByte()..5.toUByte(): $list7"
+    }
+
+    val list8 = ArrayList<UInt>()
+    for (i in 3.toUShort()..5.toUShort()) {
+        list8.add(i)
+        if (list8.size > 23) break
+    }
+    if (list8 != listOf<UInt>(3u, 4u, 5u)) {
+        return "Wrong elements for 3.toUShort()..5.toUShort(): $list8"
+    }
+
+    val list9 = ArrayList<ULong>()
+    for (i in 3uL..5uL) {
+        list9.add(i)
+        if (list9.size > 23) break
+    }
+    if (list9 != listOf<ULong>(3u, 4u, 5u)) {
+        return "Wrong elements for 3uL..5uL: $list9"
+    }
+
    return "OK"
 }
@@ -19,15 +19,12 @@ package org.jetbrains.kotlin.generators.tests;
 import com.intellij.openapi.util.io.FileUtil;
 import com.intellij.openapi.util.text.StringUtil;
 import com.intellij.util.LineSeparator;
-import com.intellij.util.containers.ContainerUtil;

 import java.io.File;
 import java.io.FileNotFoundException;
 import java.io.IOException;
 import java.io.PrintWriter;
-import java.util.Arrays;
-import java.util.List;
-import java.util.Map;
+import java.util.*;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;

@@ -64,34 +61,53 @@ public class GenerateRangesCodegenTestData {
                                                      "    }\n" +
                                                      "\n";

-    private static final Map<String, String> ELEMENT_TYPE_KNOWN_SUBSTRINGS = new ContainerUtil.ImmutableMapBuilder<String, String>()
-            .put("'", "Char")
-            .put("\"", "Char")
-            .put("Float.NaN", "Float")
-            .put("Double.NaN", "Double")
-            .put("MaxL", "Long")
-            .put("MinL", "Long")
-            .put("MaxC", "Char")
-            .put("MinC", "Char")
-            .build();
+    private static final List<String> INTEGER_PRIMITIVES = Arrays.asList("Int", "Byte", "Short", "Long", "Char", "UInt", "UByte", "UShort", "ULong");
+
+    private static final Map<String, String> ELEMENT_TYPE_KNOWN_SUBSTRINGS = new HashMap<>();
+    private static final Map<String, String> MIN_MAX_CONSTANTS = new LinkedHashMap<>();
+
+    static {
+        for (String integerType : INTEGER_PRIMITIVES) {
+            String suffix = integerType.substring(0, integerType.startsWith("U") ? 2 : 1);
+            ELEMENT_TYPE_KNOWN_SUBSTRINGS.put("Max" + suffix, integerType);
+            ELEMENT_TYPE_KNOWN_SUBSTRINGS.put("Min" + suffix, integerType);
+            MIN_MAX_CONSTANTS.put("Max" + suffix, integerType + ".MAX_VALUE");
+            MIN_MAX_CONSTANTS.put("Min" + suffix, integerType + ".MIN_VALUE");
+        }
+
+        ELEMENT_TYPE_KNOWN_SUBSTRINGS.put("'", "Char");
+        ELEMENT_TYPE_KNOWN_SUBSTRINGS.put("\"", "Char");
+    }

    private static String detectElementType(String rangeExpression) {
        Matcher matcher = Pattern.compile("\\.to(\\w+)").matcher(rangeExpression);
        if (matcher.find()) {
            String elementType = matcher.group(1);
-            return elementType.equals("Byte") || elementType.equals("Short") ? "Int" : elementType;
-        }
-        if (Pattern.compile("\\d\\.\\d").matcher(rangeExpression).find()) {
-            return "Double";
+            return getResultingType(elementType);
        }
        for (String substring : ELEMENT_TYPE_KNOWN_SUBSTRINGS.keySet()) {
            if (rangeExpression.contains(substring)) {
-                return ELEMENT_TYPE_KNOWN_SUBSTRINGS.get(substring);
+                return getResultingType(ELEMENT_TYPE_KNOWN_SUBSTRINGS.get(substring));
            }
        }
+        if (Pattern.compile("\\dL").matcher(rangeExpression).find()) {
+            return "Long";
+        }
+        if (Pattern.compile("\\duL", Pattern.CASE_INSENSITIVE).matcher(rangeExpression).find()) {
+            return "ULong";
+        }
+        if (Pattern.compile("\\du", Pattern.CASE_INSENSITIVE).matcher(rangeExpression).find()) {
+            return "UInt";
+        }
        return "Int";
    }

+    private static String getResultingType(String operandType) {
+        return operandType.equals("Byte") || operandType.equals("Short") ? "Int" :
+               operandType.equals("UByte") || operandType.equals("UShort") ? "UInt" :
+               operandType;
+    }
+
    private static String renderTemplate(String template, int number, String elementType, String rangeExpression, String expectedListElements) {
        return template
                .replace("$RANGE_EXPR_ESCAPED", StringUtil.escapeStringCharacters(rangeExpression))
@@ -103,8 +119,6 @@ public class GenerateRangesCodegenTestData {
                .replace("\n", LineSeparator.getSystemLineSeparator().getSeparatorString());
    }

-    private static final List<String> INTEGER_PRIMITIVES = Arrays.asList("Int", "Byte", "Short", "Long", "Char");
-
    private static final List<String> IGNORED_FOR_JS_BACKEND = Collections.emptyList();

    private static final List<String> IGNORED_FOR_NATIVE_BACKEND = Collections.emptyList();
@@ -139,14 +153,11 @@ public class GenerateRangesCodegenTestData {
        out.println();
        // Import min/max values, but only in case when the generated test case actually uses them (not to clutter tests which don't)
        out.println();
-        for (String primitive : INTEGER_PRIMITIVES) {
-            String maxV = "Max" + primitive.charAt(0);
-            String minV = "Min" + primitive.charAt(0);
-            if (generatedBody.contains(maxV))
-                out.printf("const val %s = %s.MAX_VALUE", maxV, primitive).println();
-            if (generatedBody.contains(minV))
-                out.printf("const val %s = %s.MIN_VALUE", minV, primitive).println();
-        }
+        MIN_MAX_CONSTANTS.forEach((name, value) -> {
+            if (generatedBody.contains(name)) {
+                out.printf("const val %s = %s", name, value).println();
+            }
+        });

        out.println();
        out.println("fun box(): String {");