assertEquals("0.1 kB", format.format(_50_bytes, ScaleUnit.KILOBYTE));
        assertEquals("0 MB", format.format(_50_bytes, ScaleUnit.MEGABYTE));
        assertEquals("0 GB", format.format(_50_bytes, ScaleUnit.GIGABYTE));

        long _999_bytes = 999L;
        assertEquals("999 B", format.format(_999_bytes));
        assertEquals("999 B", format.format(_999_bytes, ScaleUnit.BYTE));

        val value = evaluated.value
        val psi = evaluated.psi as? KtElement
        return when (evaluated.kind) {
            ConstantValueKind.Byte -> KaConstantValue.KaByteConstantValue(value as Byte, psi)
            ConstantValueKind.Int -> KaConstantValue.KaIntConstantValue(value as Int, psi)
            ConstantValueKind.Long -> KaConstantValue.KaLongConstantValue(value as Long, psi)

    @Deprecated("Use 'short' instead.", replaceWith = ReplaceWith("short"))
    public val SHORT: KaType
        get() = short

    public abstract val byte: KaType

    @Deprecated("Use 'byte' instead.", replaceWith = ReplaceWith("byte"))
    public val BYTE: KaType
        get() = byte

    public abstract val float: KaType

    @Deprecated("Use 'float' instead.", replaceWith = ReplaceWith("float"))
    public val FLOAT: KaType

    public val KaType.isShort: Boolean get() = withValidityAssertion { isClassTypeWithClassId(DefaultTypeClassIds.SHORT) }
    public val KaType.isByte: Boolean get() = withValidityAssertion { isClassTypeWithClassId(DefaultTypeClassIds.BYTE) }
    public val KaType.isFloat: Boolean get() = withValidityAssertion { isClassTypeWithClassId(DefaultTypeClassIds.FLOAT) }

                            throw new MaxLengthExceededException("The content length (" + responseData.getContentLength()
                                    + " byte) is over " + maxLength + " byte. The url is " + filePath);
                        }
                    }
                } else {
                    // Forbidden

    override val short: KaType
        get() = withValidityAssertion { analysisContext.builtIns.shortType.toKtType(analysisContext) }

    override val byte: KaType
        get() = withValidityAssertion { analysisContext.builtIns.byteType.toKtType(analysisContext) }

    override val float: KaType

        <version>${mockitoVersion}</version>
        <type>pom</type>
        <scope>import</scope>
      </dependency>
      <dependency>
        <groupId>net.bytebuddy</groupId>
        <artifactId>byte-buddy</artifactId>
        <version>${byteBuddyVersion}</version>
      </dependency>
    </dependencies>
    <!--bootstrap-start-comment-->
  </dependencyManagement>
  <!--bootstrap-end-comment-->
  <!--