eval_data/java_eval.jsonl

{"task_id": "Java/0", "prompt": "为以下代码写单测，请不要说明：\n```\npublic class Validate {\n    public static void inclusiveBetween(final double start, final double end, final double value, final String message) {\n        // TODO when breaking BC, consider returning value\n        if (value < start || value > end) {\n            throw new IllegalArgumentException(message);\n        }\n    }\n}\n```\n"}
{"task_id": "Java/1", "prompt": "为以下代码写单测，请不要说明：\n```\npublic final class Range<T> implements Serializable {\n    private final Comparator<T> comparator;\n    private final T maximum;\n    private final T minimum;\n\n    public static <T> Range<T> between(T fromInclusive, T toInclusive, Comparator<T> comparator) {\n        return new Range(fromInclusive, toInclusive, comparator);\n    }\n\n    private Range(T element1, T element2, Comparator<T> comp) {\n        if (element1 != null && element2 != null) {\n            if (comp == null) {\n                this.comparator = Range.ComparableComparator.INSTANCE;\n            } else {\n                this.comparator = comp;\n            }\n\n            if (this.comparator.compare(element1, element2) < 1) {\n                this.minimum = element1;\n                this.maximum = element2;\n            } else {\n                this.minimum = element2;\n                this.maximum = element1;\n            }\n\n        } else {\n            throw new IllegalArgumentException(\"Elements in a range must not be null: element1=\" + element1 + \", element2=\" + element2);\n        }\n    }\n\n    public boolean contains(final T element) {\n        if (element == null) {\n            return false;\n        }\n        return comparator.compare(element, minimum) > -1 && comparator.compare(element, maximum) < 1;\n    }\n}\n```\n"}
{"task_id": "Java/2", "prompt": "为以下代码写单测，请不要说明：\n```\npublic class ArrayUtils {\n    public static final int INDEX_NOT_FOUND = -1;\n    public static int lastIndexOf(final Object[] array, final Object objectToFind, int startIndex) {\n        if (array == null || startIndex < 0) {\n            return INDEX_NOT_FOUND;\n        }\n        if (startIndex >= array.length) {\n            startIndex = array.length - 1;\n        }\n        if (objectToFind == null) {\n            for (int i = startIndex; i >= 0; i--) {\n                if (array[i] == null) {\n                    return i;\n                }\n            }\n        } else if (array.getClass().getComponentType().isInstance(objectToFind)) {\n            for (int i = startIndex; i >= 0; i--) {\n                if (objectToFind.equals(array[i])) {\n                    return i;\n                }\n            }\n        }\n        return INDEX_NOT_FOUND;\n    }\n}\n```\n"}
{"task_id": "Java/3", "prompt": "为以下代码写单测，请不要说明：\n```\npublic class Validate {\n    public static <T> void inclusiveBetween(final T start, final T end, final Comparable<T> value) {\n        // TODO when breaking BC, consider returning value\n        if (value.compareTo(start) < 0 || value.compareTo(end) > 0) {\n            throw new IllegalArgumentException(String.format(DEFAULT_INCLUSIVE_BETWEEN_EX_MESSAGE, value, start, end));\n        }\n    }\n}\n```\n"}
{"task_id": "Java/4", "prompt": "为以下代码写单测，请不要说明：\n```\npublic class UnicodeUnescaper {\n    @Override\n    public int translate(final CharSequence input, final int index, final Writer out) throws IOException {\n        if (input.charAt(index) == '\\\\' && index + 1 < input.length() && input.charAt(index + 1) == 'u') {\n            // consume optional additional 'u' chars\n            int i = 2;\n            while (index + i < input.length() && input.charAt(index + i) == 'u') {\n                i++;\n            }\n\n            if (index + i < input.length() && input.charAt(index + i) == '+') {\n                i++;\n            }\n\n            if (index + i + 4 <= input.length()) {\n                // Get 4 hex digits\n                final CharSequence unicode = input.subSequence(index + i, index + i + 4);\n\n                try {\n                    final int value = Integer.parseInt(unicode.toString(), 16);\n                    out.write((char) value);\n                } catch (final NumberFormatException nfe) {\n                    throw new IllegalArgumentException(\"Unable to parse unicode value: \" + unicode, nfe);\n                }\n                return i + 4;\n            }\n            throw new IllegalArgumentException(\"Less than 4 hex digits in unicode value: '\" + input.subSequence(index, input.length())\n                    + \"' due to end of CharSequence\");\n        }\n        return 0;\n    }\n}\n```\n"}
{"task_id": "Java/5", "prompt": "为以下代码写单测，请不要说明：\n```\npublic class ObjectUtils {\n    public static <T> T requireNonNull(T obj, String message) {\n        if (obj == null)\n            throw new NullPointerException(message);\n        return obj;\n    }\n    public static <T> T requireNonEmpty(final T obj, final String message) {\n        // check for null first to give the most precise exception.\n        Objects.requireNonNull(obj, message);\n        if (isEmpty(obj)) {\n            throw new IllegalArgumentException(message);\n        }\n        return obj;\n    }\n}\npublic class BooleanUtils {\n    public static boolean and(final boolean... array) {\n        ObjectUtils.requireNonEmpty(array, \"array\");\n        for (final boolean element : array) {\n            if (!element) {\n                return false;\n            }\n        }\n        return true;\n    }\n}\n```\n"}
{"task_id": "Java/6", "prompt": "为以下代码写单测，请不要说明：\n```\npublic class Range {\n    private final Comparator<T> comparator;\n    private final T maximum;\n    private final T minimum;\n\n    public static <T> Range<T> between(T fromInclusive, T toInclusive, Comparator<T> comparator) {\n        return new Range(fromInclusive, toInclusive, comparator);\n    }\n\n    private Range(T element1, T element2, Comparator<T> comp) {\n        if (element1 != null && element2 != null) {\n            if (comp == null) {\n                this.comparator = Range.ComparableComparator.INSTANCE;\n            } else {\n                this.comparator = comp;\n            }\n\n            if (this.comparator.compare(element1, element2) < 1) {\n                this.minimum = element1;\n                this.maximum = element2;\n            } else {\n                this.minimum = element2;\n                this.maximum = element1;\n            }\n\n        } else {\n            throw new IllegalArgumentException(\"Elements in a range must not be null: element1=\" + element1 + \", element2=\" + element2);\n        }\n    }\n\n    public boolean isAfter(final T element) {\n        if (element == null) {\n            return false;\n        }\n        return comparator.compare(element, minimum) < 0;\n    }\n    public boolean isBefore(final T element) {\n        if (element == null) {\n            return false;\n        }\n        return comparator.compare(element, maximum) > 0;\n    }\n\n    public int elementCompareTo(final T element) {\n        // Comparable API says throw NPE on null\n        Objects.requireNonNull(element, \"element\");\n        if (isAfter(element)) {\n            return -1;\n        }\n        if (isBefore(element)) {\n            return 1;\n        }\n        return 0;\n    }\n}\n```\n"}
{"task_id": "Java/7", "prompt": "为以下代码写单测，请不要说明：\n```\npublic class CompareToBuilder {\n    private int comparison;\n    public int toComparison() {\n        return comparison;\n    }\n    public CompareToBuilder append(final double[] lhs, final double[] rhs) {\n        if (comparison != 0) {\n            return this;\n        }\n        if (lhs == rhs) {\n            return this;\n        }\n        if (lhs == null) {\n            comparison = -1;\n            return this;\n        }\n        if (rhs == null) {\n            comparison = 1;\n            return this;\n        }\n        if (lhs.length != rhs.length) {\n            comparison = lhs.length < rhs.length ? -1 : 1;\n            return this;\n        }\n        for (int i = 0; i < lhs.length && comparison == 0; i++) {\n            append(lhs[i], rhs[i]);\n        }\n        return this;\n    }\n}\n```\n"}
{"task_id": "Java/8", "prompt": "为以下代码写单测，请不要说明：\n```\npublic class NumberUtils {\n    public static boolean withDecimalsParsing(final String str, final int beginIdx) {\n        int decimalPoints = 0;\n        for (int i = beginIdx; i < str.length(); i++) {\n            final boolean isDecimalPoint = str.charAt(i) == '.';\n            if (isDecimalPoint) {\n                decimalPoints++;\n            }\n            if (decimalPoints > 1) {\n                return false;\n            }\n            if (!isDecimalPoint && !Character.isDigit(str.charAt(i))) {\n                return false;\n            }\n        }\n        return true;\n    }\n}\n```\n"}
{"task_id": "Java/9", "prompt": "为以下代码写单测，请不要说明：\n```\npublic class TypeUtils {\n    private static boolean equals(final WildcardType wildcardType, final Type type) {\n        if (type instanceof WildcardType) {\n            final WildcardType other = (WildcardType) type;\n            return equals(getImplicitLowerBounds(wildcardType), getImplicitLowerBounds(other))\n                && equals(getImplicitUpperBounds(wildcardType), getImplicitUpperBounds(other));\n        }\n        return false;\n    }\n\n    public static boolean equals(final Type type1, final Type type2) {\n        if (Objects.equals(type1, type2)) {\n            return true;\n        }\n        if (type1 instanceof ParameterizedType) {\n            return equals((ParameterizedType) type1, type2);\n        }\n        if (type1 instanceof GenericArrayType) {\n            return equals((GenericArrayType) type1, type2);\n        }\n        if (type1 instanceof WildcardType) {\n            return equals((WildcardType) type1, type2);\n        }\n        return false;\n    }\n}\n```\n"}
{"task_id": "Java/10", "prompt": "为以下代码写单测，请不要说明：\n```\npublic class UnicodeUnpairedSurrogateRemover {\n    @Override\n    public boolean translate(final int codePoint, final Writer out) throws IOException {\n        // true: It's a surrogate. Write nothing and say we've translated.\n        return codePoint >= Character.MIN_SURROGATE && codePoint <= Character.MAX_SURROGATE;\n        // It's not a surrogate. Don't translate it.\n    }\n}\n```\n"}
{"task_id": "Java/11", "prompt": "为以下代码写单测，请不要说明：\n```\npublic class StringUtils {\n    public static String getDigits(final String str) {\n        if (isEmpty(str)) {\n            return str;\n        }\n        final int sz = str.length();\n        final StringBuilder strDigits = new StringBuilder(sz);\n        for (int i = 0; i < sz; i++) {\n            final char tempChar = str.charAt(i);\n            if (Character.isDigit(tempChar)) {\n                strDigits.append(tempChar);\n            }\n        }\n        return strDigits.toString();\n    }\n}\n```\n"}
{"task_id": "Java/12", "prompt": "为以下代码写单测，请不要说明：\n```\npublic class StringUtils {\n    public static void convertRemainingAccentCharacters(final StringBuilder decomposed) {\n        for (int i = 0; i < decomposed.length(); i++) {\n            if (decomposed.charAt(i) == '\\u0141') {\n                decomposed.setCharAt(i, 'L');\n            } else if (decomposed.charAt(i) == '\\u0142') {\n                decomposed.setCharAt(i, 'l');\n            }\n        }\n    }\n}\n```\n"}
{"task_id": "Java/13", "prompt": "为以下代码写单测，请不要说明：\n```\npublic class TimedSemaphore {\n    private final ScheduledExecutorService executorService;\n    private final long period;\n\n    /** The time unit for the period. */\n    private final TimeUnit unit;\n\n    /** A flag whether the executor service was created by this object. */\n    private final boolean ownExecutor;\n\n    private boolean shutdown;\n\n    public TimedSemaphore(final ScheduledExecutorService service, final long timePeriod,\n                          final TimeUnit timeUnit, final int limit) {\n        Validate.inclusiveBetween(1, Long.MAX_VALUE, timePeriod, \"Time period must be greater than 0!\");\n\n        period = timePeriod;\n        unit = timeUnit;\n\n        if (service != null) {\n            executorService = service;\n            ownExecutor = false;\n        } else {\n            final ScheduledThreadPoolExecutor s = new ScheduledThreadPoolExecutor(\n                    THREAD_POOL_SIZE);\n            s.setContinueExistingPeriodicTasksAfterShutdownPolicy(false);\n            s.setExecuteExistingDelayedTasksAfterShutdownPolicy(false);\n            executorService = s;\n            ownExecutor = true;\n        }\n\n        setLimit(limit);\n    }\n    public synchronized void shutdown() {\n        if (!shutdown) {\n\n            if (ownExecutor) {\n                // if the executor was created by this instance, it has\n                // to be shutdown\n                getExecutorService().shutdownNow();\n            }\n            if (task != null) {\n                task.cancel(false);\n            }\n\n            shutdown = true;\n        }\n    }\n}\n```\n"}
{"task_id": "Java/14", "prompt": "为以下代码写单测，请不要说明：\n```\npublic class ObjectUtils {\n    public static boolean isEmpty(final Object object) {\n        if (object == null) {\n            return true;\n        }\n        if (object instanceof CharSequence) {\n            return ((CharSequence) object).length() == 0;\n        }\n        if (isArray(object)) {\n            return Array.getLength(object) == 0;\n        }\n        if (object instanceof Collection<?>) {\n            return ((Collection<?>) object).isEmpty();\n        }\n        if (object instanceof Map<?, ?>) {\n            return ((Map<?, ?>) object).isEmpty();\n        }\n        if (object instanceof Optional<?>) {\n            // TODO Java 11 Use Optional#isEmpty()\n            return !((Optional<?>) object).isPresent();\n        }\n        return false;\n    }\n}\n```\n"}
{"task_id": "Java/16", "prompt": "为以下代码写单测，请不要说明：\n```\npublic class StringUtils {\n    public static String leftPad(final String str, final int size, String padStr) {\n        if (str == null) {\n            return null;\n        }\n        if (isEmpty(padStr)) {\n            padStr = SPACE;\n        }\n        final int padLen = padStr.length();\n        final int strLen = str.length();\n        final int pads = size - strLen;\n        if (pads <= 0) {\n            return str; // returns original String when possible\n        }\n        if (padLen == 1 && pads <= PAD_LIMIT) {\n            return leftPad(str, size, padStr.charAt(0));\n        }\n\n        if (pads == padLen) {\n            return padStr.concat(str);\n        }\n        if (pads < padLen) {\n            return padStr.substring(0, pads).concat(str);\n        }\n        final char[] padding = new char[pads];\n        final char[] padChars = padStr.toCharArray();\n        for (int i = 0; i < pads; i++) {\n            padding[i] = padChars[i % padLen];\n        }\n        return new String(padding).concat(str);\n    }\n\n    public static String rightPad(final String str, final int size, String padStr) {\n        if (str == null) {\n            return null;\n        }\n        if (isEmpty(padStr)) {\n            padStr = SPACE;\n        }\n        final int padLen = padStr.length();\n        final int strLen = str.length();\n        final int pads = size - strLen;\n        if (pads <= 0) {\n            return str; // returns original String when possible\n        }\n        if (padLen == 1 && pads <= PAD_LIMIT) {\n            return rightPad(str, size, padStr.charAt(0));\n        }\n\n        if (pads == padLen) {\n            return str.concat(padStr);\n        }\n        if (pads < padLen) {\n            return str.concat(padStr.substring(0, pads));\n        }\n        final char[] padding = new char[pads];\n        final char[] padChars = padStr.toCharArray();\n        for (int i = 0; i < pads; i++) {\n            padding[i] = padChars[i % padLen];\n        }\n        return str.concat(new String(padding));\n    }\n\n    public static String center(String str, final int size, String padStr) {\n        if (str == null || size <= 0) {\n            return str;\n        }\n        if (isEmpty(padStr)) {\n            padStr = SPACE;\n        }\n        final int strLen = str.length();\n        final int pads = size - strLen;\n        if (pads <= 0) {\n            return str;\n        }\n        str = leftPad(str, strLen + pads / 2, padStr);\n        str = rightPad(str, size, padStr);\n        return str;\n    }\n}\n```\n"}
{"task_id": "Java/17", "prompt": "为以下代码写单测，请不要说明：\n```\npublic class WordUtils {\n    public static boolean containsAllWords(final CharSequence word, final CharSequence... words) {\n        if (StringUtils.isEmpty(word) || ArrayUtils.isEmpty(words)) {\n            return false;\n        }\n        for (final CharSequence w : words) {\n            if (StringUtils.isBlank(w)) {\n                return false;\n            }\n            final Pattern p = Pattern.compile(\".*\\\\b\" + w + \"\\\\b.*\");\n            if (!p.matcher(word).matches()) {\n                return false;\n            }\n        }\n        return true;\n    }\n}\n```\n"}
{"task_id": "Java/18", "prompt": "为以下代码写单测，请不要说明：\n```\npublic class RandomStringUtils {\n    public static String random(int count, int start, int end, final boolean letters, final boolean numbers,\n                                final char[] chars, final Random random) {\n        if (count == 0) {\n            return StringUtils.EMPTY;\n        }\n        if (count < 0) {\n            throw new IllegalArgumentException(\"Requested random string length \" + count + \" is less than 0.\");\n        }\n        if (chars != null && chars.length == 0) {\n            throw new IllegalArgumentException(\"The chars array must not be empty\");\n        }\n\n        if (start == 0 && end == 0) {\n            if (chars != null) {\n                end = chars.length;\n            } else if (!letters && !numbers) {\n                end = Character.MAX_CODE_POINT;\n            } else {\n                end = 'z' + 1;\n                start = ' ';\n            }\n        } else if (end <= start) {\n            throw new IllegalArgumentException(\"Parameter end (\" + end + \") must be greater than start (\" + start + \")\");\n        }\n\n        final int zero_digit_ascii = 48;\n        final int first_letter_ascii = 65;\n\n        if (chars == null && (numbers && end <= zero_digit_ascii\n                || letters && end <= first_letter_ascii)) {\n            throw new IllegalArgumentException(\"Parameter end (\" + end + \") must be greater then (\" + zero_digit_ascii + \") for generating digits \" +\n                    \"or greater then (\" + first_letter_ascii + \") for generating letters.\");\n        }\n\n        final StringBuilder builder = new StringBuilder(count);\n        final int gap = end - start;\n\n        while (count-- != 0) {\n            final int codePoint;\n            if (chars == null) {\n                codePoint = random.nextInt(gap) + start;\n\n                switch (Character.getType(codePoint)) {\n                case Character.UNASSIGNED:\n                case Character.PRIVATE_USE:\n                case Character.SURROGATE:\n                    count++;\n                    continue;\n                }\n\n            } else {\n                codePoint = chars[random.nextInt(gap) + start];\n            }\n\n            final int numberOfChars = Character.charCount(codePoint);\n            if (count == 0 && numberOfChars > 1) {\n                count++;\n                continue;\n            }\n\n            if (letters && Character.isLetter(codePoint)\n                    || numbers && Character.isDigit(codePoint)\n                    || !letters && !numbers) {\n                builder.appendCodePoint(codePoint);\n\n                if (numberOfChars == 2) {\n                    count--;\n                }\n\n            } else {\n                count++;\n            }\n        }\n        return builder.toString();\n    }\n}\n```\n"}
{"task_id": "Java/19", "prompt": "为以下代码写单测，请不要说明：\n```\npublic class ClassUtils {\n    public static String getPackageName(String className) {\n        if (StringUtils.isEmpty(className)) {\n            return StringUtils.EMPTY;\n        }\n\n        // Strip array encoding\n        while (className.charAt(0) == '[') {\n            className = className.substring(1);\n        }\n        // Strip Object type encoding\n        if (className.charAt(0) == 'L' && className.charAt(className.length() - 1) == ';') {\n            className = className.substring(1);\n        }\n\n        final int i = className.lastIndexOf(PACKAGE_SEPARATOR_CHAR);\n        if (i == -1) {\n            return StringUtils.EMPTY;\n        }\n        return className.substring(0, i);\n    }\n}\n```\n"}
{"task_id": "Java/21", "prompt": "为以下代码写单测，请不要说明：\n```\npublic class StringUtils {\n    public static final int INDEX_NOT_FOUND = -1;\n    public static int indexOfIgnoreCase(final CharSequence str, final CharSequence searchStr, int startPos) {\n        if (str == null || searchStr == null) {\n            return INDEX_NOT_FOUND;\n        }\n        if (startPos < 0) {\n            startPos = 0;\n        }\n        final int endLimit = str.length() - searchStr.length() + 1;\n        if (startPos > endLimit) {\n            return INDEX_NOT_FOUND;\n        }\n        if (searchStr.length() == 0) {\n            return startPos;\n        }\n        for (int i = startPos; i < endLimit; i++) {\n            if (CharSequenceUtils.regionMatches(str, true, i, searchStr, 0, searchStr.length())) {\n                return i;\n            }\n        }\n        return INDEX_NOT_FOUND;\n    }\n}\n```\n"}
{"task_id": "Java/22", "prompt": "为以下代码写单测，请不要说明：\n```\npublic class MutableFloat {\n    private float value;\n\n    public MutableFloat() {\n    }\n\n    public MutableFloat(final float value) {\n        this.value = value;\n    }\n\n    @Override\n    public Float getValue() {\n        return Float.valueOf(this.value);\n    }\n\n    public float getAndDecrement() {\n        final float last = value;\n        value--;\n        return last;\n    }\n}\n```\n"}
{"task_id": "Java/24", "prompt": "为以下代码写单测，请不要说明：\n```\npublic class StringUtils {\n    public static boolean contains(final CharSequence seq, final int searchChar) {\n        if (isEmpty(seq)) {\n            return false;\n        }\n        return CharSequenceUtils.indexOf(seq, searchChar, 0) >= 0;\n    }\n}\n```\n"}
{"task_id": "Java/25", "prompt": "为以下代码写单测，请不要说明：\n```\npublic class CharSequenceUtils {\n    static int lastIndexOf(final CharSequence cs, final CharSequence searchChar, int start) {\n        if (searchChar == null || cs == null) {\n            return NOT_FOUND;\n        }\n        if (searchChar instanceof String) {\n            if (cs instanceof String) {\n                return ((String) cs).lastIndexOf((String) searchChar, start);\n            }\n            if (cs instanceof StringBuilder) {\n                return ((StringBuilder) cs).lastIndexOf((String) searchChar, start);\n            }\n            if (cs instanceof StringBuffer) {\n                return ((StringBuffer) cs).lastIndexOf((String) searchChar, start);\n            }\n        }\n\n        final int len1 = cs.length();\n        final int len2 = searchChar.length();\n\n        if (start > len1) {\n            start = len1;\n        }\n\n        if (start < 0 || len2 > len1) {\n            return NOT_FOUND;\n        }\n\n        if (len2 == 0) {\n            return start;\n        }\n\n        if (len2 <= TO_STRING_LIMIT) {\n            if (cs instanceof String) {\n                return ((String) cs).lastIndexOf(searchChar.toString(), start);\n            }\n            if (cs instanceof StringBuilder) {\n                return ((StringBuilder) cs).lastIndexOf(searchChar.toString(), start);\n            }\n            if (cs instanceof StringBuffer) {\n                return ((StringBuffer) cs).lastIndexOf(searchChar.toString(), start);\n            }\n        }\n\n        if (start + len2 > len1) {\n            start = len1 - len2;\n        }\n\n        final char char0 = searchChar.charAt(0);\n\n        int i = start;\n        while (true) {\n            while (cs.charAt(i) != char0) {\n                i--;\n                if (i < 0) {\n                    return NOT_FOUND;\n                }\n            }\n            if (checkLaterThan1(cs, searchChar, len2, i)) {\n                return i;\n            }\n            i--;\n            if (i < 0) {\n                return NOT_FOUND;\n            }\n        }\n    }\n}\n```\n"}
{"task_id": "Java/26", "prompt": "为以下代码写单测，请不要说明：\n```\npublic class FastTimeZone {\n    private static final Pattern GMT_PATTERN = Pattern.compile(\"^(?:(?i)GMT)?([+-])?(\\\\d\\\\d?)?(:?(\\\\d\\\\d?))?$\");\n\n    private static final TimeZone GREENWICH = new GmtTimeZone(false, 0, 0);\n\n    public static TimeZone getGmtTimeZone() {\n        return GREENWICH;\n    }\n\n    public static TimeZone getGmtTimeZone(final String pattern) {\n        if (\"Z\".equals(pattern) || \"UTC\".equals(pattern)) {\n            return GREENWICH;\n        }\n\n        final Matcher m = GMT_PATTERN.matcher(pattern);\n        if (m.matches()) {\n            final int hours = parseInt(m.group(2));\n            final int minutes = parseInt(m.group(4));\n            if (hours == 0 && minutes == 0) {\n                return GREENWICH;\n            }\n            return new GmtTimeZone(parseSign(m.group(1)), hours, minutes);\n        }\n        return null;\n    }\n}\n```\n"}
{"task_id": "Java/27", "prompt": "为以下代码写单测，请不要说明：\n```\npublic class Conversion {\n    public static byte binaryToByte(final boolean[] src, final int srcPos, final byte dstInit, final int dstPos,\n            final int nBools) {\n        if (src.length == 0 && srcPos == 0 || 0 == nBools) {\n            return dstInit;\n        }\n        if (nBools - 1 + dstPos >= 8) {\n            throw new IllegalArgumentException(\"nBools-1+dstPos is greater or equal to than 8\");\n        }\n        byte out = dstInit;\n        for (int i = 0; i < nBools; i++) {\n            final int shift = i + dstPos;\n            final int bits = (src[i + srcPos] ? 1 : 0) << shift;\n            final int mask = 0x1 << shift;\n            out = (byte) ((out & ~mask) | bits);\n        }\n        return out;\n    }\n}\n```\n"}
{"task_id": "Java/28", "prompt": "为以下代码写单测，请不要说明：\n```\npublic class StrBuilder {\n    public void getChars(final int startIndex, final int endIndex, final char[] destination, final int destinationIndex) {\n        if (startIndex < 0) {\n            throw new StringIndexOutOfBoundsException(startIndex);\n        }\n        if (endIndex < 0 || endIndex > length()) {\n            throw new StringIndexOutOfBoundsException(endIndex);\n        }\n        if (startIndex > endIndex) {\n            throw new StringIndexOutOfBoundsException(\"end < start\");\n        }\n        System.arraycopy(buffer, startIndex, destination, destinationIndex, endIndex - startIndex);\n    }\n}\n```\n"}
{"task_id": "Java/29", "prompt": "为以下代码写单测，请不要说明：\n```\npublic class Conversion {\n    public static char binaryToHexDigitMsb0_4bits(final boolean[] src, final int srcPos) {\n        if (src.length > 8) {\n            throw new IllegalArgumentException(\"src.length>8: src.length=\" + src.length);\n        }\n        if (src.length - srcPos < 4) {\n            throw new IllegalArgumentException(\"src.length-srcPos<4: src.length=\" + src.length + \", srcPos=\" + srcPos);\n        }\n        if (src[srcPos + 3]) {\n            if (src[srcPos + 2]) {\n                if (src[srcPos + 1]) {\n                    return src[srcPos] ? 'f' : '7';\n                }\n                return src[srcPos] ? 'b' : '3';\n            }\n            if (src[srcPos + 1]) {\n                return src[srcPos] ? 'd' : '5';\n            }\n            return src[srcPos] ? '9' : '1';\n        }\n        if (src[srcPos + 2]) {\n            if (src[srcPos + 1]) {\n                return src[srcPos] ? 'e' : '6';\n            }\n            return src[srcPos] ? 'a' : '2';\n        }\n        if (src[srcPos + 1]) {\n            return src[srcPos] ? 'c' : '4';\n        }\n        return src[srcPos] ? '8' : '0';\n    }\n}\n```\n"}
{"task_id": "Java/30", "prompt": "为以下代码写单测，请不要说明：\n```\npublic class ArrayUtils {\n    public static void reverse(final double[] array, final int startIndexInclusive, final int endIndexExclusive) {\n        if (array == null) {\n            return;\n        }\n        int i = Math.max(startIndexInclusive, 0);\n        int j = Math.min(array.length, endIndexExclusive) - 1;\n        double tmp;\n        while (j > i) {\n            tmp = array[j];\n            array[j] = array[i];\n            array[i] = tmp;\n            j--;\n            i++;\n        }\n    }\n\n    public static void reverse(final double[] array) {\n        if (array != null) {\n            reverse(array, 0, array.length);\n        }\n    }\n}\n```\n"}
{"task_id": "Java/31", "prompt": "为以下代码写单测，请不要说明：\n```\npublic class CompareToBuilder {\n    private int comparison;\n    public int toComparison() {\n        return comparison;\n    }\n    public CompareToBuilder appendSuper(final int superCompareTo) {\n        if (comparison != 0) {\n            return this;\n        }\n        comparison = superCompareTo;\n        return this;\n    }\n}\n```\n"}
{"task_id": "Java/32", "prompt": "为以下代码写单测，请不要说明：\n```\npublic class ArrayUtils {\n    public static int getLength(final Object array) {\n        return array != null ? Array.getLength(array) : 0;\n    }\n\n    public static boolean isSorted(final float[] array) {\n        if (getLength(array) < 2) {\n            return true;\n        }\n\n        float previous = array[0];\n        final int n = array.length;\n        for (int i = 1; i < n; i++) {\n            final float current = array[i];\n            if (Float.compare(previous, current) > 0) {\n                return false;\n            }\n\n            previous = current;\n        }\n        return true;\n    }\n}\n```\n"}
{"task_id": "Java/33", "prompt": "为以下代码写单测，请不要说明：\n```\npublic class ExceptionUtils {\n    private static final String[] CAUSE_METHOD_NAMES = {\n        \"getCause\",\n        \"getNextException\",\n        \"getTargetException\",\n        \"getException\",\n        \"getSourceException\",\n        \"getRootCause\",\n        \"getCausedByException\",\n        \"getNested\",\n        \"getLinkedException\",\n        \"getNestedException\",\n        \"getLinkedCause\",\n        \"getThrowable\",\n    };\n\n    public static Throwable getCause(final Throwable throwable, String[] methodNames) {\n        if (throwable == null) {\n            return null;\n        }\n        if (methodNames == null) {\n            final Throwable cause = throwable.getCause();\n            if (cause != null) {\n                return cause;\n            }\n            methodNames = CAUSE_METHOD_NAMES;\n        }\n        return Stream.of(methodNames).map(m -> getCauseUsingMethodName(throwable, m)).filter(Objects::nonNull).findFirst().orElse(null);\n    }\n}\n```\n"}
{"task_id": "Java/34", "prompt": "为以下代码写单测，请不要说明：\n```\npublic class ArrayUtils {\n    public static void reverse(final int[] array, final int startIndexInclusive, final int endIndexExclusive) {\n        if (array == null) {\n            return;\n        }\n        int i = Math.max(startIndexInclusive, 0);\n        int j = Math.min(array.length, endIndexExclusive) - 1;\n        int tmp;\n        while (j > i) {\n            tmp = array[j];\n            array[j] = array[i];\n            array[i] = tmp;\n            j--;\n            i++;\n        }\n    }\n\n    public static void reverse(final int[] array) {\n        if (array != null) {\n            reverse(array, 0, array.length);\n        }\n    }\n}\n```\n"}
{"task_id": "Java/35", "prompt": "为以下代码写单测，请不要说明：\n```\npublic class EnumUtils {\n    public static <E extends Enum<E>> E getFirstEnumIgnoreCase(final Class<E> enumClass, final String enumName, final Function<E, String> stringFunction,\n        final E defaultEnum) {\n        if (enumName == null || !enumClass.isEnum()) {\n            return defaultEnum;\n        }\n        return Stream.of(enumClass.getEnumConstants()).filter(e -> enumName.equalsIgnoreCase(stringFunction.apply(e))).findFirst().orElse(defaultEnum);\n    }\n}\n```\n"}
{"task_id": "Java/36", "prompt": "为以下代码写单测，请不要说明：\n```\npublic class Conversion {\n    public static int hexDigitToInt(final char hexDigit) {\n        final int digit = Character.digit(hexDigit, 16);\n        if (digit < 0) {\n            throw new IllegalArgumentException(\"Cannot interpret '\" + hexDigit + \"' as a hexadecimal digit\");\n        }\n        return digit;\n    }\n}\n```\n"}
{"task_id": "Java/37", "prompt":"为以下代码写单测，请不要说明：\n```\npublic abstract class ToStringStyle implements Serializable {\n    public String arrayEnd = \"}\";\n    public void setArrayEnd(String arrayEnd) {\n        if (arrayEnd == null) {\n            arrayEnd = StringUtils.EMPTY;\n        }\n        this.arrayEnd = arrayEnd;\n    }\n}\n```"}
{"task_id": "Java/38", "prompt":"为以下代码写单测，请不要说明：\n```\npublic abstract class ToStringStyle implements Serializable {\n    public void append(final StringBuffer buffer, final String fieldName, final char[] array, final Boolean fullDetail) {\n        appendFieldStart(buffer, fieldName);\n\n        if (array == null) {\n            appendNullText(buffer, fieldName);\n\n        } else if (isFullDetail(fullDetail)) {\n            appendDetail(buffer, fieldName, array);\n\n        } else {\n            appendSummary(buffer, fieldName, array);\n        }\n\n        appendFieldEnd(buffer, fieldName);\n    }\n}\n```"}
{"task_id": "Java/39", "prompt":"为以下代码写单测，请不要说明：\n```\npublic abstract class ToStringStyle implements Serializable {\n    public void appendToString(final StringBuffer buffer, final String toString) {\n        if (toString != null) {\n            final int pos1 = toString.indexOf(contentStart) + contentStart.length();\n            final int pos2 = toString.lastIndexOf(contentEnd);\n            if (pos1 != pos2 && pos1 >= 0 && pos2 >= 0) {\n                if (fieldSeparatorAtStart) {\n                    removeLastFieldSeparator(buffer);\n                }\n                buffer.append(toString, pos1, pos2);\n                appendFieldSeparator(buffer);\n            }\n        }\n    }\n}\n```"}