reflow comments in platform/{testing,text}

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

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 60 matching lines @@
   bool hasStrongDirectionality;
   String data(entry.text, entry.length);
   TextRun run(data);
   TextDirection direction =
       determineParagraphDirectionality(run, &hasStrongDirectionality);
   EXPECT_EQ(entry.expectedStrong, hasStrongDirectionality);
   EXPECT_EQ(entry.expectedDirection, direction);
 }
 
 TEST(BidiResolver, ParagraphDirectionSurrogates) {
-  const TestData testData[] = {
-      // Test strong RTL, non-BMP. (U+10858 Imperial Aramaic number one, strong RTL)
-      {{0xD802, 0xDC58}, 2, RTL, true},
+  const TestData testData[] = {// Test strong RTL, non-BMP. (U+10858 Imperial
+                               // Aramaic number one, strong RTL)
+                               {{0xD802, 0xDC58}, 2, RTL, true},
 
-      // Test strong LTR, non-BMP. (U+1D15F Musical symbol quarter note, strong LTR)
-      {{0xD834, 0xDD5F}, 2, LTR, true},
+                               // Test strong LTR, non-BMP. (U+1D15F Musical
+                               // symbol quarter note, strong LTR)
+                               {{0xD834, 0xDD5F}, 2, LTR, true},
 
-      // Test broken surrogate: valid leading, invalid trail. (Lead of U+10858, space)
-      {{0xD802, ' '}, 2, LTR, false},
+                               // Test broken surrogate: valid leading, invalid
+                               // trail. (Lead of U+10858, space)
+                               {{0xD802, ' '}, 2, LTR, false},
 
-      // Test broken surrogate: invalid leading. (Trail of U+10858, U+05D0 Hebrew Alef)
-      {{0xDC58, 0x05D0}, 2, RTL, true},
+                               // Test broken surrogate: invalid leading. (Trail
+                               // of U+10858, U+05D0 Hebrew Alef)
+                               {{0xDC58, 0x05D0}, 2, RTL, true},
 
-      // Test broken surrogate: valid leading, invalid trail/valid lead, valid trail.
-      {{0xD802, 0xD802, 0xDC58}, 3, RTL, true},
+                               // Test broken surrogate: valid leading, invalid
+                               // trail/valid lead, valid trail.
+                               {{0xD802, 0xD802, 0xDC58}, 3, RTL, true},
 
-      // Test broken surrogate: valid leading, no trail (string too short). (Lead of U+10858)
-      {{0xD802, 0xDC58}, 1, LTR, false},
+                               // Test broken surrogate: valid leading, no trail
+                               // (string too short). (Lead of U+10858)
+                               {{0xD802, 0xDC58}, 1, LTR, false},
 
-      // Test broken surrogate: trail appearing before lead. (U+10858 units reversed)
-      {{0xDC58, 0xD802}, 2, LTR, false}};
+                               // Test broken surrogate: trail appearing before
+                               // lead. (U+10858 units reversed)
+                               {{0xDC58, 0xD802}, 2, LTR, false}};
   for (size_t i = 0; i < WTF_ARRAY_LENGTH(testData); ++i)
     testDirectionality(testData[i]);
 }
 
 class BidiTestRunner {
  public:
   BidiTestRunner()
       : m_testsRun(0),
         m_testsSkipped(0),
         m_ignoredCharFailures(0),
@@ skipping 12 matching lines @@
   size_t m_testsRun;
   size_t m_testsSkipped;
   std::set<UChar> m_skippedCodePoints;
   size_t m_ignoredCharFailures;
   size_t m_levelFailures;
   size_t m_orderFailures;
 };
 
 // Blink's UBA does not filter out control characters, etc. Maybe it should?
 // Instead it depends on later layers of Blink to simply ignore them.
-// This function helps us emulate that to be compatible with BidiTest.txt expectations.
+// This function helps us emulate that to be compatible with BidiTest.txt
+// expectations.
 static bool isNonRenderedCodePoint(UChar c) {
   // The tests also expect us to ignore soft-hyphen.
   if (c == 0xAD)
     return true;
   // Control characters are not rendered:
   return c >= 0x202A && c <= 0x202E;
   // But it seems to expect LRI, etc. to be rendered!?
 }
 
 std::string diffString(const std::vector<int>& actual,
@@ skipping 49 matching lines @@
   std::ostringstream errorContext;
   errorContext << ", line " << lineNumber << " \"" << line << "\"";
   errorContext << " context: "
                << bidi_test::nameFromParagraphDirection(paragraphDirection);
 
   std::vector<int> actualOrder;
   std::vector<int> actualLevels;
   actualLevels.assign(input.size(), -1);
   BidiCharacterRun* run = runs.firstRun();
   while (run) {
-    // Blink's UBA just makes runs, the actual ordering of the display of characters
-    // is handled later in our pipeline, so we fake it here:
+    // Blink's UBA just makes runs, the actual ordering of the display of
+    // characters is handled later in our pipeline, so we fake it here:
     bool reversed = run->reversed(false);
     ASSERT(run->stop() >= run->start());
     size_t length = run->stop() - run->start();
     for (size_t i = 0; i < length; i++) {
       int inputIndex = reversed ? run->stop() - i - 1 : run->start() + i;
       if (!isNonRenderedCodePoint(input[inputIndex]))
         actualOrder.push_back(inputIndex);
-      // BidiTest.txt gives expected level data in the order of the original input.
+      // BidiTest.txt gives expected level data in the order of the original
+      // input.
       actualLevels[inputIndex] = run->level();
     }
     run = run->next();
   }
 
   if (expectedOrder.size() != actualOrder.size()) {
     m_ignoredCharFailures++;
     EXPECT_EQ(expectedOrder.size(), actualOrder.size()) << errorContext.str();
   } else if (expectedOrder != actualOrder) {
     m_orderFailures++;
@@ skipping 59 matching lines @@
   // The unittest harness only pays attention to GTest output, so we verify
   // that the tests behaved as expected:
   EXPECT_EQ(352098u, runner.m_testsRun);
   EXPECT_EQ(418143u, runner.m_testsSkipped);
   EXPECT_EQ(0u, runner.m_ignoredCharFailures);
   EXPECT_EQ(44882u, runner.m_levelFailures);
   EXPECT_EQ(19151u, runner.m_orderFailures);
 }
 
 }  // namespace blink