reflow comments in platform/{testing,text}

third_party/WebKit/Source/platform/text/UnicodeUtilities.cpp

 /*
- * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2012 Apple Inc. All rights reserved.
+ * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2012 Apple Inc. All
+ * rights reserved.
  * Copyright (C) 2005 Alexey Proskuryakov.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
@@ skipping 32 matching lines @@
   switch (static_cast<UChar>(c)) {
     case hebrewPunctuationGershayimCharacter:
     case leftDoubleQuotationMarkCharacter:
     case rightDoubleQuotationMarkCharacter:
       return '"';
     case hebrewPunctuationGereshCharacter:
     case leftSingleQuotationMarkCharacter:
     case rightSingleQuotationMarkCharacter:
       return '\'';
     case softHyphenCharacter:
-      // Replace soft hyphen with an ignorable character so that their presence or absence will
+      // Replace soft hyphen with an ignorable character so that their presence
+      // or absence will
       // not affect string comparison.
       return 0;
     default:
       return c;
   }
 }
 
 void foldQuoteMarksAndSoftHyphens(UChar* data, size_t length) {
   for (size_t i = 0; i < length; ++i)
     data[i] = foldQuoteMarkOrSoftHyphen(data[i]);
 }
 
 void foldQuoteMarksAndSoftHyphens(String& s) {
   s.replace(hebrewPunctuationGereshCharacter, '\'');
   s.replace(hebrewPunctuationGershayimCharacter, '"');
   s.replace(leftDoubleQuotationMarkCharacter, '"');
   s.replace(leftSingleQuotationMarkCharacter, '\'');
   s.replace(rightDoubleQuotationMarkCharacter, '"');
   s.replace(rightSingleQuotationMarkCharacter, '\'');
-  // Replace soft hyphen with an ignorable character so that their presence or absence will
+  // Replace soft hyphen with an ignorable character so that their presence or
+  // absence will
   // not affect string comparison.
   s.replace(softHyphenCharacter, static_cast<UChar>('\0'));
 }
 
 static bool isNonLatin1Separator(UChar32 character) {
   DCHECK_GE(character, 256);
   return U_GET_GC_MASK(character) &
          (U_GC_S_MASK | U_GC_P_MASK | U_GC_Z_MASK | U_GC_CF_MASK);
 }
 
 bool isSeparator(UChar32 character) {
-  static const bool
-      latin1SeparatorTable[256] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-                                   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-                                   0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-                                   1, 1, 1,  // space ! " # $ % & ' ( ) * + , - . /
-                                   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1,
-                                   1,  //                         : ; < = > ?
-                                   1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-                                   0,  //   @
-                                   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1,
-                                   1,  //                         [ \ ] ^ _
-                                   1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-                                   0,  //   `
-                                   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1,
-                                   0,  //                           { | } ~
-                                   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-                                   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-                                   0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1,
-                                   1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1,
-                                   1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-                                   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0,
-                                   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-                                   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
-                                   0, 0, 0, 0, 0, 0, 0, 0};
-
+  // clang-format off
+  static const bool latin1SeparatorTable[256] = {
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      // space ! " # $ % & ' ( ) * + , - . /
+      1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+      //                         : ; < = > ?
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1,
+      //   @
+      1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      //                         [ \ ] ^ _
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1,
+      //   `
+      1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      //                           { | } ~
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1,
+      1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0
+  };
+  // clang-format on
   if (character < 256)
     return latin1SeparatorTable[character];
 
   return isNonLatin1Separator(character);
 }
 
 // ICU's search ignores the distinction between small kana letters and ones
 // that are not small, and also characters that differ only in the voicing
 // marks when considering only primary collation strength differences.
 // This is not helpful for end users, since these differences make words
@@ skipping 184 matching lines @@
 
   if (status == U_ZERO_ERROR || status == U_STRING_NOT_TERMINATED_WARNING)
     return;
 
   status = U_ZERO_ERROR;
   unorm_normalize(characters, length, UNORM_NFC, 0, buffer.data(), bufferSize,
                   &status);
   ASSERT(status == U_STRING_NOT_TERMINATED_WARNING);
 }
 
-// This function returns kNotFound if |first| and |second| contain different Kana letters.
-// If |first| and |second| contain the same Kana letter
-// then function returns offset in characters from |first|.
-// Pointers to both strings increase simultaneously so so it is possible to use one offset value.
+// This function returns kNotFound if |first| and |second| contain different
+// Kana letters.  If |first| and |second| contain the same Kana letter then
+// function returns offset in characters from |first|.
+// Pointers to both strings increase simultaneously so so it is possible to use
+// one offset value.
 static inline size_t compareKanaLetterAndComposedVoicedSoundMarks(
     const UChar* first,
     const UChar* firstEnd,
     const UChar* second,
     const UChar* secondEnd) {
   const UChar* start = first;
   // Check for differences in the kana letter character itself.
   if (isSmallKanaLetter(*first) != isSmallKanaLetter(*second))
     return kNotFound;
   if (composedVoicedSoundMark(*first) != composedVoicedSoundMark(*second))
     return kNotFound;
   ++first;
   ++second;
 
-  // Check for differences in combining voiced sound marks found after the letter.
+  // Check for differences in combining voiced sound marks found after the
+  // letter.
   while (true) {
     const bool secondIsNotSoundMark =
         second == secondEnd || !isCombiningVoicedSoundMark(*second);
     if (first == firstEnd || !isCombiningVoicedSoundMark(*first)) {
       return secondIsNotSoundMark ? first - start : kNotFound;
     }
     if (secondIsNotSoundMark)
       return kNotFound;
     if (*first != *second)
       return kNotFound;
     ++first;
     ++second;
   }
 }
 
 bool checkOnlyKanaLettersInStrings(const UChar* firstData,
                                    unsigned firstLength,
                                    const UChar* secondData,
                                    unsigned secondLength) {
   const UChar* a = firstData;
   const UChar* aEnd = firstData + firstLength;
 
   const UChar* b = secondData;
   const UChar* bEnd = secondData + secondLength;
   while (true) {
     // Skip runs of non-kana-letter characters. This is necessary so we can
-    // correctly handle strings where the |firstData| and |secondData| have different-length
-    // runs of characters that match, while still double checking the correctness
-    // of matches of kana letters with other kana letters.
+    // correctly handle strings where the |firstData| and |secondData| have
+    // different-length runs of characters that match, while still double
+    // checking the correctness of matches of kana letters with other kana
+    // letters.
     while (a != aEnd && !isKanaLetter(*a))
       ++a;
     while (b != bEnd && !isKanaLetter(*b))
       ++b;
 
     // If we reached the end of either the target or the match, we should have
-    // reached the end of both; both should have the same number of kana letters.
+    // reached the end of both; both should have the same number of kana
+    // letters.
     if (a == aEnd || b == bEnd) {
       return a == aEnd && b == bEnd;
     }
 
     // Check that single Kana letters in |a| and |b| are the same.
     const size_t offset =
         compareKanaLetterAndComposedVoicedSoundMarks(a, aEnd, b, bEnd);
     if (offset == kNotFound)
       return false;
 
@@ skipping 13 matching lines @@
   const UChar* b = secondData;
   const UChar* bEnd = secondData + secondLength;
   while (true) {
     // Check for non-kana-letter characters.
     while (a != aEnd && !isKanaLetter(*a) && b != bEnd && !isKanaLetter(*b)) {
       if (*a++ != *b++)
         return false;
     }
 
     // If we reached the end of either the target or the match, we should have
-    // reached the end of both; both should have the same number of kana letters.
+    // reached the end of both; both should have the same number of kana
+    // letters.
     if (a == aEnd || b == bEnd) {
       return a == aEnd && b == bEnd;
     }
 
     if (isKanaLetter(*a) != isKanaLetter(*b))
       return false;
 
     // Check that single Kana letters in |a| and |b| are the same.
     const size_t offset =
         compareKanaLetterAndComposedVoicedSoundMarks(a, aEnd, b, bEnd);
     if (offset == kNotFound)
       return false;
 
     // Update values of |a| and |b| after comparing.
     a += offset;
     b += offset;
   }
 }
 
 }  // namespace blink