Pour parler de tâches "synchrones" (en opposition à "asynchrones"), on utilise souvent le terme "séquentiel", car l'ordinateur / le programme va effectuer toutes les étapes d'une tâche séquentiellement avant de passer à une autre tâche, même si ces étapes impliquent de l'attente.

### Concurrence et Burgers

			updateResourceMetrics(interfaceSubsystem, interfaceRxErrors, float64(stats.RxErrors), labels, true)
			updateResourceMetrics(interfaceSubsystem, interfaceTxBytes, float64(stats.TxBytes), labels, true)
			updateResourceMetrics(interfaceSubsystem, interfaceTxErrors, float64(stats.TxErrors), labels, true)
		}
		if hm.Mem != nil && len(hm.Mem.Info.Addr) > 0 {
			labels := map[string]string{}

    val source = response.body.source()
    source.timeout().timeout(1000, TimeUnit.MILLISECONDS)
    assertThat(source.readByte()).isEqualTo('A'.code.toByte())
    assertThat(source.readByte()).isEqualTo('B'.code.toByte())
    assertThat(source.readByte()).isEqualTo('C'.code.toByte())
    assertFailsWith<SocketTimeoutException> {
      source.readByte() // If Content-Length was accurate, this would return -1 immediately.
    }

    assertThat(actual).isEqualTo(expected)
  }

  private fun intArrayToByteArray(bytes: IntArray): ByteString {
    val data = ByteArray(bytes.size)
    for (i in bytes.indices) {
      data[i] = bytes[i].toByte()
    }
    return ByteString.of(*data)
  }

  private fun readerHeaderTableLength(): Int = hpackReader!!.dynamicTable.size

labels.url=URL
labels.userFavorite=Journal des favoris
labels.userInfo=Informations utilisateur
labels.webApiJson=Réponse JSON
labels.webConfigName=Nom de la configuration d'exploration Web
labels.allLanguages=Toutes les langues
labels.dictId=ID du dictionnaire
labels.docId=ID du document
labels.endTime=Heure de fin
labels.hq=hq
labels.inputs=Entrées
labels.jobLogging=Journalisation
labels.jobName=Nom
labels.jobStatus=Statut

Fiat Cryptography. DO NOT EDIT.' --package-name edwards25519 Scalar 64 '2^252 + 27742317777372353535' mul add sub opp nonzero from_montgomery to_montgomery to_bytes from_bytes // // curve description: Scalar // // machine_wordsize = 64 (from "64") // // requested operations: mul, add, sub, opp, nonzero, from_montgomery, to_montgomery, to_bytes, from_bytes // // m = 0x100000000000000000 (from "2^252 + 27742317777372353535") // // // // NOTE: In addition to the bounds specified above each function,...

    val request = Request.Builder().url(server.url("/b")).build()
    val response = client.newCall(request).execute()
    val bodySource = response.body.source()
    assertThat(bodySource.readByte()).isEqualTo('d'.code.toByte())

    // The second byte of this request will be delayed by 750ms so we should time out after 250ms.
    val startNanos = System.nanoTime()
    bodySource.use {
      assertFailsWith<IOException> {

Fiat Cryptography. DO NOT EDIT.' --package-name edwards25519 Scalar 64 '2^252 + 27742317777372353535' mul add sub opp nonzero from_montgomery to_montgomery to_bytes from_bytes // // curve description: Scalar // // machine_wordsize = 64 (from "64") // // requested operations: mul, add, sub, opp, nonzero, from_montgomery, to_montgomery, to_bytes, from_bytes // // m = 0x100000000000000000 (from "2^252 + 27742317777372353535") // // // // NOTE: In addition to the bounds specified above each function,...

    assertThat(peer.frameCount()).isEqualTo(5)
  }

  @Test fun maxFrameSizeHonored() {
    val buff = ByteArray(peer.maxOutboundDataLength() + 1)
    buff.fill('*'.code.toByte())

    // Write the mocking script.
    peer.sendFrame().settings(Settings())
    peer.acceptFrame() // ACK
    peer.acceptFrame() // SYN_STREAM
    peer.sendFrame().headers(false, 3, headerEntries("a", "android"))

        },
        "catalan_keywords": {
          "type":       "keyword_marker",