Merge pull request #8742 from thomasvl/cypher_to_cipher

cypher -> cipher for the codespell workflow.

CHANGES.txt

@@ -277,7 +277,7 @@
     collection directly instead of using the other methods of the BaseContainer.
   * MessageFactory.CreateProtoype can be overridden to customize class creation.
   * Fix PyUnknownFields memory leak (#7928)
-  * Add macOS big sur compatibility (#8126)
+  * Add macOS Big Sur compatibility (#8126)
 
   JavaScript
   * Generate `getDescriptor` methods with `*` as their `this` type.

src/google/protobuf/stubs/strutil.cc

@@ -2101,7 +2101,7 @@ int Base64EscapeInternal(const unsigned char *src, int szsrc,
   char *limit_dest = dest + szdest;
   const unsigned char *limit_src = src + szsrc;
 
-  // Three bytes of data encodes to four characters of cyphertext.
+  // Three bytes of data encodes to four characters of ciphertext.
   // So we can pump through three-byte chunks atomically.
   while (cur_src < limit_src - 3) {  // keep going as long as we have >= 32 bits
     uint32 in = BigEndian::Load32(cur_src) >> 8;
@@ -2128,7 +2128,7 @@ int Base64EscapeInternal(const unsigned char *src, int szsrc,
       break;
     case 1: {
       // One byte left: this encodes to two characters, and (optionally)
-      // two pad characters to round out the four-character cypherblock.
+      // two pad characters to round out the four-character cipherblock.
       if ((szdest -= 2) < 0) return 0;
       uint32 in = cur_src[0];
       cur_dest[0] = base64[in >> 2];
@@ -2145,7 +2145,7 @@ int Base64EscapeInternal(const unsigned char *src, int szsrc,
     }
     case 2: {
       // Two bytes left: this encodes to three characters, and (optionally)
-      // one pad character to round out the four-character cypherblock.
+      // one pad character to round out the four-character cipherblock.
       if ((szdest -= 3) < 0) return 0;
       uint32 in = BigEndian::Load16(cur_src);
       cur_dest[0] = base64[in >> 10];

src/google/protobuf/stubs/strutil_unittest.cc

@@ -83,7 +83,7 @@ TEST(StringUtilityTest, ImmuneToLocales) {
 static struct {
   int plain_length;
   const char* plaintext;
-  const char* cyphertext;
+  const char* ciphertext;
 } base64_tests[] = {
   // Empty string.
   { 0, "", ""},
@@ -343,10 +343,10 @@ static struct {
 
 static struct {
   const char* plaintext;
-  const char* cyphertext;
+  const char* ciphertext;
 } base64_strings[] = {
   // Some google quotes
-  // Cyphertext created with "uuencode (GNU sharutils) 4.6.3"
+  // Ciphertext created with "uuencode (GNU sharutils) 4.6.3"
   // (Note that we're testing the websafe encoding, though, so if
   // you add messages, be sure to run "tr -- '+/' '-_'" on the output)
   { "I was always good at math and science, and I never realized "
@@ -441,7 +441,7 @@ TEST(Base64, EscapeAndUnescape) {
     int encode_length;
     char decode_buffer[100];
     int decode_length;
-    int cypher_length;
+    int cipher_length;
     std::string decode_str;
 
     const unsigned char* unsigned_plaintext =
@@ -450,7 +450,7 @@ TEST(Base64, EscapeAndUnescape) {
     StringPiece plaintext(base64_tests[i].plaintext,
                           base64_tests[i].plain_length);
 
-    cypher_length = strlen(base64_tests[i].cyphertext);
+    cipher_length = strlen(base64_tests[i].ciphertext);
 
     // The basic escape function:
     memset(encode_buffer, 0, sizeof(encode_buffer));
@@ -459,30 +459,30 @@ TEST(Base64, EscapeAndUnescape) {
                                  encode_buffer,
                                  sizeof(encode_buffer));
     //    Is it of the expected length?
-    EXPECT_EQ(encode_length, cypher_length);
+    EXPECT_EQ(encode_length, cipher_length);
     // Would it have been okay to allocate only CalculateBase64EscapeLen()?
     EXPECT_EQ(CalculateBase64EscapedLen(base64_tests[i].plain_length),
               encode_length);
 
     //    Is it the expected encoded value?
-    ASSERT_STREQ(encode_buffer, base64_tests[i].cyphertext);
+    ASSERT_STREQ(encode_buffer, base64_tests[i].ciphertext);
 
     // If we encode it into a buffer of exactly the right length...
     memset(encode_buffer, 0, sizeof(encode_buffer));
     encode_length = Base64Escape(unsigned_plaintext,
                                           base64_tests[i].plain_length,
                                           encode_buffer,
-                                          cypher_length);
+                                          cipher_length);
     //    Is it still of the expected length?
-    EXPECT_EQ(encode_length, cypher_length);
+    EXPECT_EQ(encode_length, cipher_length);
 
     //    And is the value still correct?  (i.e., not losing the last byte)
-    EXPECT_STREQ(encode_buffer, base64_tests[i].cyphertext);
+    EXPECT_STREQ(encode_buffer, base64_tests[i].ciphertext);
 
     // If we decode it back:
     decode_str.clear();
     EXPECT_TRUE(Base64Unescape(
-        StringPiece(encode_buffer, cypher_length), &decode_str));
+        StringPiece(encode_buffer, cipher_length), &decode_str));
 
     //    Is it of the expected length?
     EXPECT_EQ(base64_tests[i].plain_length, decode_str.length());
@@ -495,11 +495,11 @@ TEST(Base64, EscapeAndUnescape) {
     Base64Escape(
         std::string(base64_tests[i].plaintext, base64_tests[i].plain_length),
         &encoded);
-    EXPECT_EQ(encoded, std::string(encode_buffer, cypher_length));
+    EXPECT_EQ(encoded, std::string(encode_buffer, cipher_length));
 
     std::string decoded("this junk should be ignored");
     EXPECT_TRUE(Base64Unescape(
-        StringPiece(encode_buffer, cypher_length), &decoded));
+        StringPiece(encode_buffer, cipher_length), &decoded));
     EXPECT_EQ(decoded.size(), base64_tests[i].plain_length);
     EXPECT_EQ_ARRAY(decoded.size(), decoded, base64_tests[i].plaintext, i);
 
@@ -578,7 +578,7 @@ TEST(Base64, EscapeAndUnescape) {
 
     char websafe[100];
     memset(websafe, 0, sizeof(websafe));
-    strncpy(websafe, base64_tests[i].cyphertext, cypher_length);
+    strncpy(websafe, base64_tests[i].ciphertext, cipher_length);
     for (int c = 0; c < sizeof(websafe); ++c) {
       if ('+' == websafe[c]) { websafe[c] = '-'; }
       if ('/' == websafe[c]) { websafe[c] = '_'; }
@@ -592,7 +592,7 @@ TEST(Base64, EscapeAndUnescape) {
                                                  sizeof(encode_buffer),
                                                  true);
     //    Is it of the expected length?
-    EXPECT_EQ(encode_length, cypher_length);
+    EXPECT_EQ(encode_length, cipher_length);
     EXPECT_EQ(
         CalculateBase64EscapedLen(base64_tests[i].plain_length, true),
         encode_length);
@@ -605,10 +605,10 @@ TEST(Base64, EscapeAndUnescape) {
     encode_length = WebSafeBase64Escape(unsigned_plaintext,
                                                  base64_tests[i].plain_length,
                                                  encode_buffer,
-                                                 cypher_length,
+                                                 cipher_length,
                                                  true);
     //    Is it still of the expected length?
-    EXPECT_EQ(encode_length, cypher_length);
+    EXPECT_EQ(encode_length, cipher_length);
 
     //    And is the value still correct?  (i.e., not losing the last byte)
     EXPECT_STREQ(encode_buffer, websafe);
@@ -618,13 +618,13 @@ TEST(Base64, EscapeAndUnescape) {
     WebSafeBase64Escape(
         unsigned_plaintext, base64_tests[i].plain_length,
         &encoded, true);
-    EXPECT_EQ(encoded.size(), cypher_length);
+    EXPECT_EQ(encoded.size(), cipher_length);
     EXPECT_STREQ(encoded.c_str(), websafe);
 
     //    If we decode it back:
     memset(decode_buffer, 0, sizeof(decode_buffer));
     decode_length = WebSafeBase64Unescape(encode_buffer,
-                                                   cypher_length,
+                                                   cipher_length,
                                                    decode_buffer,
                                                    sizeof(decode_buffer));
 
@@ -638,7 +638,7 @@ TEST(Base64, EscapeAndUnescape) {
     //    If we decode it into a buffer of exactly the right length...
     memset(decode_buffer, 0, sizeof(decode_buffer));
     decode_length = WebSafeBase64Unescape(encode_buffer,
-                                                   cypher_length,
+                                                   cipher_length,
                                                    decode_buffer,
                                                    decode_length);
 
@@ -650,14 +650,14 @@ TEST(Base64, EscapeAndUnescape) {
               memcmp(decode_buffer, base64_tests[i].plaintext, decode_length));
 
     // Try using '.' for the pad character.
-    for (int c = cypher_length - 1; c >= 0 && '=' == encode_buffer[c]; --c) {
+    for (int c = cipher_length - 1; c >= 0 && '=' == encode_buffer[c]; --c) {
       encode_buffer[c] = '.';
     }
 
     // If we decode it back:
     memset(decode_buffer, 0, sizeof(decode_buffer));
     decode_length = WebSafeBase64Unescape(encode_buffer,
-                                                   cypher_length,
+                                                   cipher_length,
                                                    decode_buffer,
                                                    sizeof(decode_buffer));
 
@@ -671,7 +671,7 @@ TEST(Base64, EscapeAndUnescape) {
     // If we decode it into a buffer of exactly the right length...
     memset(decode_buffer, 0, sizeof(decode_buffer));
     decode_length = WebSafeBase64Unescape(encode_buffer,
-                                                   cypher_length,
+                                                   cipher_length,
                                                    decode_buffer,
                                                    decode_length);
 
@@ -685,7 +685,7 @@ TEST(Base64, EscapeAndUnescape) {
     // Let's try the string version of the decoder
     decoded = "this junk should be ignored";
     EXPECT_TRUE(WebSafeBase64Unescape(
-        StringPiece(encode_buffer, cypher_length), &decoded));
+        StringPiece(encode_buffer, cipher_length), &decoded));
     EXPECT_EQ(decoded.size(), base64_tests[i].plain_length);
     EXPECT_EQ_ARRAY(decoded.size(), decoded, base64_tests[i].plaintext, i);
 
@@ -695,7 +695,7 @@ TEST(Base64, EscapeAndUnescape) {
     for (int c = 0; c < sizeof(websafe); ++c) {
       if ('=' == websafe[c]) {
         websafe[c] = '\0';
-        cypher_length = c;
+        cipher_length = c;
         break;
       }
     }
@@ -708,7 +708,7 @@ TEST(Base64, EscapeAndUnescape) {
                                                  sizeof(encode_buffer),
                                                  false);
     //    Is it of the expected length?
-    EXPECT_EQ(encode_length, cypher_length);
+    EXPECT_EQ(encode_length, cipher_length);
     EXPECT_EQ(
         CalculateBase64EscapedLen(base64_tests[i].plain_length, false),
         encode_length);
@@ -721,10 +721,10 @@ TEST(Base64, EscapeAndUnescape) {
     encode_length = WebSafeBase64Escape(unsigned_plaintext,
                                                  base64_tests[i].plain_length,
                                                  encode_buffer,
-                                                 cypher_length,
+                                                 cipher_length,
                                                  false);
     //    Is it still of the expected length?
-    EXPECT_EQ(encode_length, cypher_length);
+    EXPECT_EQ(encode_length, cipher_length);
 
     //    And is the value still correct?  (i.e., not losing the last byte)
     EXPECT_STREQ(encode_buffer, websafe);
@@ -733,13 +733,13 @@ TEST(Base64, EscapeAndUnescape) {
     std::string plain(base64_tests[i].plaintext, base64_tests[i].plain_length);
     encoded = "this junk should be ignored";
     WebSafeBase64Escape(plain, &encoded);
-    EXPECT_EQ(encoded.size(), cypher_length);
+    EXPECT_EQ(encoded.size(), cipher_length);
     EXPECT_STREQ(encoded.c_str(), websafe);
 
     //    If we decode it back:
     memset(decode_buffer, 0, sizeof(decode_buffer));
     decode_length = WebSafeBase64Unescape(encode_buffer,
-                                                   cypher_length,
+                                                   cipher_length,
                                                    decode_buffer,
                                                    sizeof(decode_buffer));
 
@@ -753,7 +753,7 @@ TEST(Base64, EscapeAndUnescape) {
     //    If we decode it into a buffer of exactly the right length...
     memset(decode_buffer, 0, sizeof(decode_buffer));
     decode_length = WebSafeBase64Unescape(encode_buffer,
-                                                   cypher_length,
+                                                   cipher_length,
                                                    decode_buffer,
                                                    decode_length);
 
@@ -768,7 +768,7 @@ TEST(Base64, EscapeAndUnescape) {
     // Let's try the string version of the decoder
     decoded = "this junk should be ignored";
     EXPECT_TRUE(WebSafeBase64Unescape(
-        StringPiece(encode_buffer, cypher_length), &decoded));
+        StringPiece(encode_buffer, cipher_length), &decoded));
     EXPECT_EQ(decoded.size(), base64_tests[i].plain_length);
     EXPECT_EQ_ARRAY(decoded.size(), decoded, base64_tests[i].plaintext, i);
 
@@ -781,18 +781,18 @@ TEST(Base64, EscapeAndUnescape) {
     const unsigned char* unsigned_plaintext =
       reinterpret_cast<const unsigned char*>(base64_strings[i].plaintext);
     int plain_length = strlen(base64_strings[i].plaintext);
-    int cypher_length = strlen(base64_strings[i].cyphertext);
+    int cipher_length = strlen(base64_strings[i].ciphertext);
-    std::vector<char> buffer(cypher_length+1);
+    std::vector<char> buffer(cipher_length+1);
     int encode_length = WebSafeBase64Escape(unsigned_plaintext,
                                                      plain_length,
                                                      &buffer[0],
                                                      buffer.size(),
                                                      false);
-    EXPECT_EQ(cypher_length, encode_length);
+    EXPECT_EQ(cipher_length, encode_length);
     EXPECT_EQ(
         CalculateBase64EscapedLen(plain_length, false), encode_length);
     buffer[ encode_length ] = '\0';
-    EXPECT_STREQ(base64_strings[i].cyphertext, &buffer[0]);
+    EXPECT_STREQ(base64_strings[i].ciphertext, &buffer[0]);
   }
 
   // Verify the behavior when decoding bad data