Keep two empty lines between declarations for cpp files

test/cctest/test-object-observe.cc

 // Copyright 2012 the V8 project authors. 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
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 36 matching lines @@
     isolate_->Dispose();
   }
 
   Isolate* GetIsolate() const { return isolate_; }
 
  private:
   Isolate* isolate_;
 };
 }
 
+
 TEST(PerIsolateState) {
   HarmonyIsolate isolate;
   HandleScope scope(isolate.GetIsolate());
   LocalContext context1;
   CompileRun(
       "var count = 0;"
       "var calls = 0;"
       "var observer = function(records) { count = records.length; calls++ };"
       "var obj = {};"
       "Object.observe(obj, observer);");
@@ skipping 20 matching lines @@
     context4->Global()->Set(String::New("observer"), observer);
     context4->Global()->Set(String::New("fun1"), notify_fun1);
     context4->Global()->Set(String::New("fun2"), notify_fun2);
     context4->Global()->Set(String::New("fun3"), notify_fun3);
     CompileRun("fun1(); fun2(); fun3(); Object.deliverChangeRecords(observer)");
   }
   CHECK_EQ(1, CompileRun("calls")->Int32Value());
   CHECK_EQ(3, CompileRun("count")->Int32Value());
 }
 
+
 TEST(EndOfMicrotaskDelivery) {
   HarmonyIsolate isolate;
   HandleScope scope(isolate.GetIsolate());
   LocalContext context;
   CompileRun(
       "var obj = {};"
       "var count = 0;"
       "var observer = function(records) { count = records.length };"
       "Object.observe(obj, observer);"
       "obj.foo = 'bar';");
   CHECK_EQ(1, CompileRun("count")->Int32Value());
 }
 
+
 TEST(DeliveryOrdering) {
   HarmonyIsolate isolate;
   HandleScope scope(isolate.GetIsolate());
   LocalContext context;
   CompileRun(
       "var obj1 = {};"
       "var obj2 = {};"
       "var ordering = [];"
       "function observer2() { ordering.push(2); };"
       "function observer1() { ordering.push(1); };"
@@ skipping 11 matching lines @@
       "Object.observe(obj2, observer3);"
       "Object.observe(obj2, observer2);"
       "Object.observe(obj2, observer1);"
       "obj2.foo = 'baz'");
   CHECK_EQ(3, CompileRun("ordering.length")->Int32Value());
   CHECK_EQ(1, CompileRun("ordering[0]")->Int32Value());
   CHECK_EQ(2, CompileRun("ordering[1]")->Int32Value());
   CHECK_EQ(3, CompileRun("ordering[2]")->Int32Value());
 }
 
+
 TEST(DeliveryOrderingReentrant) {
   HarmonyIsolate isolate;
   HandleScope scope(isolate.GetIsolate());
   LocalContext context;
   CompileRun(
       "var obj = {};"
       "var reentered = false;"
       "var ordering = [];"
       "function observer1() { ordering.push(1); };"
       "function observer2() {"
@@ skipping 11 matching lines @@
   CHECK_EQ(5, CompileRun("ordering.length")->Int32Value());
   CHECK_EQ(1, CompileRun("ordering[0]")->Int32Value());
   CHECK_EQ(2, CompileRun("ordering[1]")->Int32Value());
   CHECK_EQ(3, CompileRun("ordering[2]")->Int32Value());
   // Note that we re-deliver to observers 1 and 2, while observer3
   // already received the second record during the first round.
   CHECK_EQ(1, CompileRun("ordering[3]")->Int32Value());
   CHECK_EQ(2, CompileRun("ordering[1]")->Int32Value());
 }
 
+
 TEST(DeliveryOrderingDeliverChangeRecords) {
   HarmonyIsolate isolate;
   HandleScope scope(isolate.GetIsolate());
   LocalContext context;
   CompileRun(
       "var obj = {};"
       "var ordering = [];"
       "function observer1() { ordering.push(1); if (!obj.b) obj.b = true };"
       "function observer2() { ordering.push(2); };"
       "Object.observe(obj, observer1);"
       "Object.observe(obj, observer2);"
       "obj.a = 1;"
       "Object.deliverChangeRecords(observer2);");
   CHECK_EQ(4, CompileRun("ordering.length")->Int32Value());
   // First, observer2 is called due to deliverChangeRecords
   CHECK_EQ(2, CompileRun("ordering[0]")->Int32Value());
   // Then, observer1 is called when the stack unwinds
   CHECK_EQ(1, CompileRun("ordering[1]")->Int32Value());
   // observer1's mutation causes both 1 and 2 to be reactivated,
   // with 1 having priority.
   CHECK_EQ(1, CompileRun("ordering[2]")->Int32Value());
   CHECK_EQ(2, CompileRun("ordering[3]")->Int32Value());
 }
 
+
 TEST(ObjectHashTableGrowth) {
   HarmonyIsolate isolate;
   HandleScope scope(isolate.GetIsolate());
   // Initializing this context sets up initial hash tables.
   LocalContext context;
   Handle<Value> obj = CompileRun("obj = {};");
   Handle<Value> observer = CompileRun(
       "var ran = false;"
       "(function() { ran = true })");
   {
     // As does initializing this context.
     LocalContext context2;
     context2->Global()->Set(String::New("obj"), obj);
     context2->Global()->Set(String::New("observer"), observer);
     CompileRun(
         "var objArr = [];"
         // 100 objects should be enough to make the hash table grow
         // (and thus relocate).
         "for (var i = 0; i < 100; ++i) {"
         "  objArr.push({});"
         "  Object.observe(objArr[objArr.length-1], function(){});"
         "}"
         "Object.observe(obj, observer);");
   }
   // obj is now marked "is_observed", but our map has moved.
   CompileRun("obj.foo = 'bar'");
   CHECK(CompileRun("ran")->BooleanValue());
 }
 
+
 TEST(GlobalObjectObservation) {
   HarmonyIsolate isolate;
   LocalContext context;
   HandleScope scope(isolate.GetIsolate());
   Handle<Object> global_proxy = context->Global();
   Handle<Object> inner_global = global_proxy->GetPrototype().As<Object>();
   CompileRun(
       "var records = [];"
       "var global = this;"
       "Object.observe(global, function(r) { [].push.apply(records, r) });"
@@ skipping 48 matching lines @@
 }
 
 
 struct RecordExpectation {
   Handle<Value> object;
   const char* type;
   const char* name;
   Handle<Value> old_value;
 };
 
+
 // TODO(adamk): Use this helper elsewhere in this file.
 static void ExpectRecords(Handle<Value> records,
                           const RecordExpectation expectations[],
                           int num) {
   CHECK(records->IsArray());
   Handle<Array> recordArray = records.As<Array>();
   CHECK_EQ(num, static_cast<int>(recordArray->Length()));
   for (int i = 0; i < num; ++i) {
     Handle<Value> record = recordArray->Get(i);
     CHECK(record->IsObject());
@@ skipping 50 matching lines @@
     { obj, "updated", "1", Number::New(2) },
     { obj, "updated", "1", Number::New(4) },
     { obj, "new", "1.1", Handle<Value>() },
     { obj, "deleted", "foo", Number::New(3) },
     { obj, "deleted", "1", Number::New(5) },
     { obj, "deleted", "1.1", Number::New(6) }
   };
   EXPECT_RECORDS(CompileRun("records"), expected_records);
 }
 
+
 TEST(HiddenPrototypeObservation) {
   HarmonyIsolate isolate;
   HandleScope scope(isolate.GetIsolate());
   LocalContext context;
   Handle<FunctionTemplate> tmpl = FunctionTemplate::New();
   tmpl->SetHiddenPrototype(true);
   tmpl->InstanceTemplate()->Set(String::New("foo"), Number::New(75));
   Handle<Object> proto = tmpl->GetFunction()->NewInstance();
   Handle<Object> obj = Object::New();
   obj->SetPrototype(proto);
@@ skipping 57 matching lines @@
       i::Handle<i::JSWeakMap>::cast(
           i::GetProperty(observation_state, "notifierTargetMap"));
   CHECK_EQ(1, NumberOfElements(observerInfoMap));
   CHECK_EQ(1, NumberOfElements(objectInfoMap));
   CHECK_EQ(1, NumberOfElements(notifierTargetMap));
   HEAP->CollectAllGarbage(i::Heap::kAbortIncrementalMarkingMask);
   CHECK_EQ(0, NumberOfElements(observerInfoMap));
   CHECK_EQ(0, NumberOfElements(objectInfoMap));
   CHECK_EQ(0, NumberOfElements(notifierTargetMap));
 }