ConstantValueKind.Long -> (value as Number).toLong()
            ConstantValueKind.Short -> (value as Number).toShort()
            ConstantValueKind.UnsignedByte -> (value as Number).toLong().toUByte()
            ConstantValueKind.UnsignedShort -> (value as Number).toLong().toUShort()
            ConstantValueKind.UnsignedInt -> (value as Number).toLong().toUInt()

            type.isLong -> KaConstantValue.KaLongConstantValue((value as Number).toLong(), expression)
            type.isULong -> KaConstantValue.KaUnsignedLongConstantValue((value as Number).toLong().toULong(), expression)
            type.isString -> KaConstantValue.KaStringConstantValue(value.toString(), expression)

                return "Long.getLong(\"$name\")"
            }

            @Override
            String getKotlinExpression() {
                return "System.getProperty(\"$name\")?.toLong()"
            }
        }
    }

    static SystemPropertyRead longGetLongWithPrimitiveDefault(String name, long defaultValue) {
        return new SystemPropertyRead() {
            @Override

      if (requestCaching.maxAgeSeconds != -1) {
        freshMillis = minOf(freshMillis, SECONDS.toMillis(requestCaching.maxAgeSeconds.toLong()))
      }

      var minFreshMillis: Long = 0
      if (requestCaching.minFreshSeconds != -1) {
        minFreshMillis = SECONDS.toMillis(requestCaching.minFreshSeconds.toLong())
      }

      var maxStaleMillis: Long = 0

      frameHeader(
        streamId = streamId,
        length = length + 4,
        type = TYPE_PUSH_PROMISE,
        flags = if (byteCount == length.toLong()) FLAG_END_HEADERS else 0,
      )
      sink.writeInt(promisedStreamId and 0x7fffffff)
      sink.write(hpackBuffer, length.toLong())

      if (byteCount > length) writeContinuationFrames(streamId, byteCount - length)
    }
  }

  @Throws(IOException::class)

        }

        toWrite = minOf(byteCount, writeBytesMaximum - writeBytesTotal).toInt()
        toWrite = minOf(toWrite, writer.maxDataLength())
        writeBytesTotal += toWrite.toLong()
      }

      byteCount -= toWrite.toLong()
      writer.data(outFinished && byteCount == 0L, streamId, buffer, toWrite)
    }
  }

  internal fun writeSynResetLater(
    streamId: Int,
    errorCode: ErrorCode,
  ) {

    assertThat(source.readByteString(prefix.size.toLong())).isEqualTo(prefix)
    assertThat(source.readLong()).isEqualTo(upstreamSize)
    assertThat(source.readLong()).isEqualTo(metadataSize.toLong())
    if (upstream != null) {
      assertThat(source.readUtf8(upstreamSize)).isEqualTo(upstream)
    }
    if (metadata != null) {
      assertThat(source.readByteString(metadataSize.toLong())).isEqualTo(metadata)
    }
    source.close()

     */
    fun maxAge(
      maxAge: Int,
      timeUnit: TimeUnit,
    ) = apply {
      require(maxAge >= 0) { "maxAge < 0: $maxAge" }
      val maxAgeSecondsLong = timeUnit.toSeconds(maxAge.toLong())
      this.maxAgeSeconds = maxAgeSecondsLong.commonClampToInt()
    }

    /**
     * Accept cached responses that have exceeded their freshness lifetime by up to `maxStale`. If

        // on Java 8
        writeLong(value.seconds)
        writeSmallInt(value.nano)
    }

    override suspend fun ReadContext.decode(): Duration =
        Duration.ofSeconds(readLong(), readSmallInt().toLong())

      .isEqualTo(Settings.DEFAULT_INITIAL_WINDOW_SIZE.toLong())
    assertThat(connection.writeBytesMaximum)
      .isEqualTo(Settings.DEFAULT_INITIAL_WINDOW_SIZE.toLong())
    assertThat(stream1.writeBytesTotal)
      .isEqualTo(Settings.DEFAULT_INITIAL_WINDOW_SIZE.toLong())
    assertThat(stream1.writeBytesMaximum)
      .isEqualTo(Settings.DEFAULT_INITIAL_WINDOW_SIZE.toLong())