reflow comments in wtf

third_party/WebKit/Source/wtf/HashMapTest.cpp

 /*
  * Copyright (C) 2011 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:
  * 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
@@ skipping 50 matching lines @@
 
 using DoubleHashMap =
     HashMap<double, int64_t, DefaultHash<double>::Hash, TestDoubleHashTraits>;
 
 int bucketForKey(double key) {
   return DefaultHash<double>::Hash::hash(key) &
          (TestDoubleHashTraits::minimumTableSize - 1);
 }
 
 TEST(HashMapTest, DoubleHashCollisions) {
-  // The "clobber" key here is one that ends up stealing the bucket that the -0 key
-  // originally wants to be in. This makes the 0 and -0 keys collide and the test then
-  // fails unless the FloatHash::equals() implementation can distinguish them.
+  // The "clobber" key here is one that ends up stealing the bucket that the -0
+  // key originally wants to be in. This makes the 0 and -0 keys collide and
+  // the test then fails unless the FloatHash::equals() implementation can
+  // distinguish them.
   const double clobberKey = 6;
   const double zeroKey = 0;
   const double negativeZeroKey = -zeroKey;
 
   DoubleHashMap map;
 
   map.add(clobberKey, 1);
   map.add(zeroKey, 2);
   map.add(negativeZeroKey, 3);
 
@@ skipping 203 matching lines @@
 TEST(HashMapTest, ValueTypeDestructed) {
   InstanceCounter::counter = 0;
   HashMap<int, InstanceCounter> map;
   map.set(1, InstanceCounter());
   map.clear();
   EXPECT_EQ(0, InstanceCounter::counter);
 }
 
 class MoveOnly {
  public:
-  // kEmpty and kDeleted have special meanings when MoveOnly is used as the key of a hash table.
+  // kEmpty and kDeleted have special meanings when MoveOnly is used as the key
+  // of a hash table.
   enum { kEmpty = 0, kDeleted = -1, kMovedOut = -2 };
 
   explicit MoveOnly(int value = kEmpty) : m_value(value) {}
   MoveOnly(MoveOnly&& other) : m_value(other.m_value) {
     other.m_value = kMovedOut;
   }
   MoveOnly& operator=(MoveOnly&& other) {
     m_value = other.m_value;
     other.m_value = kMovedOut;
     return *this;
   }
 
   int value() const { return m_value; }
 
  private:
   MoveOnly(const MoveOnly&) = delete;
   MoveOnly& operator=(const MoveOnly&) = delete;
 
   int m_value;
 };
 
 struct MoveOnlyHashTraits : public GenericHashTraits<MoveOnly> {
-  // This is actually true, but we pretend that it's false to disable the optimization.
+  // This is actually true, but we pretend that it's false to disable the
+  // optimization.
   static const bool emptyValueIsZero = false;
 
   static const bool hasIsEmptyValueFunction = true;
   static bool isEmptyValue(const MoveOnly& value) {
     return value.value() == MoveOnly::kEmpty;
   }
   static void constructDeletedValue(MoveOnly& slot, bool) {
     slot = MoveOnly(MoveOnly::kDeleted);
   }
   static bool isDeletedValue(const MoveOnly& value) {
@@ skipping 71 matching lines @@
 
   MoveOnly oneThirty(map.take(13));
   EXPECT_EQ(130, oneThirty.value());
   iter = map.find(13);
   EXPECT_TRUE(iter == map.end());
 
   map.clear();
 }
 
 TEST(HashMapTest, MoveOnlyKeyType) {
-  // The content of this test is similar to the test above, except that the types of key and value are swapped.
+  // The content of this test is similar to the test above, except that the
+  // types of key and value are swapped.
   using TheMap = HashMap<MoveOnly, int>;
   TheMap map;
   {
     TheMap::AddResult addResult = map.add(MoveOnly(1), 10);
     EXPECT_TRUE(addResult.isNewEntry);
     EXPECT_EQ(1, addResult.storedValue->key.value());
     EXPECT_EQ(10, addResult.storedValue->value);
   }
   auto iter = map.find(MoveOnly(1));
   ASSERT_TRUE(iter != map.end());
@@ skipping 222 matching lines @@
   EXPECT_EQ(130, oneThirty);
   iter = map.find(Pair(MoveOnly(13), -13));
   EXPECT_TRUE(iter == map.end());
 
   map.clear();
 }
 
 }  // anonymous namespace
 
 }  // namespace WTF