labels.bad_word_link_upload=Téléverser
labels.bad_word_button_download=Télécharger
labels.bad_word_button_upload=Téléverser
labels.bad_word_list_suggest_word=Mot incorrect
labels.bad_word_suggest_word=Mot incorrect
labels.bad_word_file=Fichier de mots incorrects
labels.user_configuration=Utilisateur
labels.user_list_name=Nom
labels.user_password=Mot de passe
labels.user_confirm_password=Mot de passe (confirmer)

        assertThrows(PACDecodingException.class, () -> new KerberosToken(malformedToken));
    }

    /**
     * Test constructor with a token that has an incorrect OID.
     *
     * @throws IOException if an I/O error occurs
     */
    @Test
    void testConstructorWithWrongOid() throws IOException {

        // ask ':tooling-api:publishGradleDistributionPublicationToRemoteRepository' uses this output of task ':tooling-api:signLocalPublication'
        // without declaring an explicit or implicit dependency. This can lead to incorrect results being produced, depending on what order the tasks are executed.
        tasks.named("publishGradleDistributionPublicationToRemoteRepository") {
            dependsOn("signLocalPublication")
        }

	// code generated by the AEAD cipher.
	//
	// Here is an incorrect implementation of IsEncrypted:
	//
	//   return len(e) > 16 && !bytes.ContainsRune(e, '-')
	//
	// An encrypted ETag may contain some random bytes - e.g.
	// and nonce value. This nonce value may contain a '-'
	// just by its nature of being randomly generated.
	// The above implementation would incorrectly consider
	// such an ETag (with a nonce value containing a '-')

	}
	body, err := io.ReadAll(resp.Body)
	if err != nil {
		t.Fatalf("reading response body failed: %v", err)
	}
	if string(body) != "hello" {
		t.Fatalf("response body incorrect: %v", string(body))
	}

	// Check that Unwrap works
	if trw.Unwrap() != rw {
		t.Fatalf("Unwrap returned wrong result: %v", trw.Unwrap())
	}
}

func TestHeadersAlreadyWritten(t *testing.T) {

	for {
		line, err := scanner.ReadString('\n')
		if err == io.EOF {
			break
		}

		fields := strings.Fields(line)
		if len(fields) != expectedNumFieldsPerLine {
			// ignore incorrect lines.
			continue
		}

		// Freq should be an integer.
		if _, err := strconv.Atoi(fields[4]); err != nil {
			return nil, err
		}

		// Pass should be an integer.

* Missing null checks may cause NullPointerException
* Bridging with Kotlin code is polluted with platform types
* Some public APIs have incorrect nullability annotations (both overly restrictive and overly permissive)

While there are competing ways to represent absence (`Optional`, "Null Object" pattern, method overloads),

        byte[] expectedHash = preauthService.getCurrentPreauthHash(sessionId);

        // Validation should pass with correct hash
        assertTrue(preauthService.validatePreauthIntegrity(sessionId, expectedHash));

        // Validation should fail with incorrect hash
        byte[] incorrectHash = new byte[expectedHash.length];
        secureRandom.nextBytes(incorrectHash);

		if !bytes.Equal(h.Sum(nil), hashBuf[:n]) {
			return errFileCorrupt
		}
	}
	return nil
}

// bitrotSelfTest performs a self-test to ensure that bitrot
// algorithms compute correct checksums. If any algorithm
// produces an incorrect checksum it fails with a hard error.
//
// bitrotSelfTest tries to catch any issue in the bitrot implementation
// early instead of silently corrupting data.
func bitrotSelfTest() {

   * should use this method over {@link #setCountCheckReturnValue(Object, int)} when they expect
   * {@code setCount()} to throw an exception, as checking the return value could produce an
   * incorrect error message like "setCount() should return the original count" instead of the
   * message passed to a later invocation of {@code fail()}, like "setCount should throw
   * UnsupportedOperationException."
   */