VM: Re-format to use at most one newline between functions

runtime/vm/flow_graph_range_analysis_test.cc

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/flow_graph_range_analysis.h"
 #include "vm/unit_test.h"
 
 namespace dart {
 
 TEST_CASE(RangeTests) {
@@ skipping 76 matching lines @@
   TEST_RANGE_OP(Range::Shr, -16, -8, 1, 2, RangeBoundary(-8),
                 RangeBoundary(-2));
   TEST_RANGE_OP(Range::Shr, 2, 4, -1, 1, RangeBoundary(1), RangeBoundary(4));
   TEST_RANGE_OP(Range::Shr, kMaxInt64, kMaxInt64, 0, 1,
                 RangeBoundary(kMaxInt64 >> 1), RangeBoundary(kMaxInt64));
   TEST_RANGE_OP(Range::Shr, kMinInt64, kMinInt64, 0, 1,
                 RangeBoundary(kMinInt64), RangeBoundary(kMinInt64 >> 1));
 #undef TEST_RANGE_OP
 }
 
-
 TEST_CASE(RangeTestsInfinity) {
   // +/- inf overflowed.
   EXPECT(RangeBoundary::NegativeInfinity().OverflowedSmi());
   EXPECT(RangeBoundary::PositiveInfinity().OverflowedSmi());
 
   EXPECT(RangeBoundary::NegativeInfinity().OverflowedMint());
   EXPECT(RangeBoundary::PositiveInfinity().OverflowedMint());
 
   Range* all = new Range(RangeBoundary::NegativeInfinity(),
                          RangeBoundary::PositiveInfinity());
@@ skipping 37 matching lines @@
 
   Range* unsatisfiable_right = new Range(RangeBoundary::PositiveInfinity(),
                                          RangeBoundary::FromConstant(0));
   EXPECT(unsatisfiable_right->IsUnsatisfiable());
 
   Range* unsatisfiable_left = new Range(RangeBoundary::FromConstant(0),
                                         RangeBoundary::NegativeInfinity());
   EXPECT(unsatisfiable_left->IsUnsatisfiable());
 }
 
-
 TEST_CASE(RangeUtils) {
   // [-inf, +inf].
   const Range& range_0 = *(new Range(RangeBoundary::NegativeInfinity(),
                                      RangeBoundary::PositiveInfinity()));
   // [-inf, -1].
   const Range& range_a = *(new Range(RangeBoundary::NegativeInfinity(),
                                      RangeBoundary::FromConstant(-1)));
   // [-inf, 0].
   const Range& range_b = *(new Range(RangeBoundary::NegativeInfinity(),
                                      RangeBoundary::FromConstant(0)));
@@ skipping 65 matching lines @@
   EXPECT(!RangeBoundary::NegativeInfinity().Equals(
       RangeBoundary::PositiveInfinity()));
   EXPECT(!RangeBoundary::FromConstant(1).Equals(
       RangeBoundary::NegativeInfinity()));
   EXPECT(!RangeBoundary::FromConstant(1).Equals(
       RangeBoundary::NegativeInfinity()));
   EXPECT(!RangeBoundary::FromConstant(2).Equals(
       RangeBoundary::PositiveInfinity()));
 }
 
-
 TEST_CASE(RangeBinaryOp) {
   Range* range_a = new Range(RangeBoundary::FromConstant(-1),
                              RangeBoundary::PositiveInfinity());
   range_a->Clamp(RangeBoundary::kRangeBoundaryInt64);
   EXPECT(range_a->min().ConstantValue() == -1);
   EXPECT(range_a->max().ConstantValue() == RangeBoundary::kMax);
   Range* range_b = new Range(RangeBoundary::NegativeInfinity(),
                              RangeBoundary::FromConstant(1));
   range_b->Clamp(RangeBoundary::kRangeBoundaryInt64);
   EXPECT(range_b->min().ConstantValue() == RangeBoundary::kMin);
@@ skipping 28 matching lines @@
                              RangeBoundary::FromConstant(0xf));
   {
     Range result;
     Range::BinaryOp(Token::kBIT_AND, range_e, range_f, NULL, &result);
     ASSERT(!Range::IsUnknown(&result));
     EXPECT(result.min().ConstantValue() == 0x0);
     EXPECT(result.max().ConstantValue() == 0xf);
   }
 }
 
-
 TEST_CASE(RangeAdd) {
 #define TEST_RANGE_ADD(l_min, l_max, r_min, r_max, result_min, result_max)     \
   {                                                                            \
     RangeBoundary min, max;                                                    \
     Range* left_range = new Range(RangeBoundary::FromConstant(l_min),          \
                                   RangeBoundary::FromConstant(l_max));         \
     Range* right_range = new Range(RangeBoundary::FromConstant(r_min),         \
                                    RangeBoundary::FromConstant(r_max));        \
     EXPECT(left_range->min().ConstantValue() == l_min);                        \
     EXPECT(left_range->max().ConstantValue() == l_max);                        \
@@ skipping 60 matching lines @@
 
   // [kMaxInt64, kMaxInt64] + [1, 1] = [-inf, +inf].
   TEST_RANGE_ADD(static_cast<int64_t>(kMaxInt64),
                  static_cast<int64_t>(kMaxInt64), static_cast<int64_t>(1),
                  static_cast<int64_t>(1), RangeBoundary::NegativeInfinity(),
                  RangeBoundary::PositiveInfinity());
 
 #undef TEST_RANGE_ADD
 }
 
-
 TEST_CASE(RangeSub) {
 #define TEST_RANGE_SUB(l_min, l_max, r_min, r_max, result_min, result_max)     \
   {                                                                            \
     RangeBoundary min, max;                                                    \
     Range* left_range = new Range(RangeBoundary::FromConstant(l_min),          \
                                   RangeBoundary::FromConstant(l_max));         \
     Range* right_range = new Range(RangeBoundary::FromConstant(r_min),         \
                                    RangeBoundary::FromConstant(r_max));        \
     EXPECT(left_range->min().ConstantValue() == l_min);                        \
     EXPECT(left_range->max().ConstantValue() == l_max);                        \
@@ skipping 30 matching lines @@
       RangeBoundary::NegativeInfinity(), RangeBoundary::PositiveInfinity());
 
   // [kMaxInt32 + 10, kMaxInt32 + 20] - [-20, -20] =
   //     [kMaxInt32 + 30, kMaxInt32 + 40].
   TEST_RANGE_SUB(static_cast<int64_t>(kMaxInt32) + 10,
                  static_cast<int64_t>(kMaxInt32) + 20,
                  static_cast<int64_t>(-20), static_cast<int64_t>(-20),
                  RangeBoundary(static_cast<int64_t>(kMaxInt32) + 30),
                  RangeBoundary(static_cast<int64_t>(kMaxInt32) + 40));
 
-
 #undef TEST_RANGE_SUB
 }
 
-
 TEST_CASE(RangeAnd) {
 #define TEST_RANGE_AND(l_min, l_max, r_min, r_max, result_min, result_max)     \
   {                                                                            \
     RangeBoundary min, max;                                                    \
     Range* left_range = new Range(RangeBoundary::FromConstant(l_min),          \
                                   RangeBoundary::FromConstant(l_max));         \
     Range* right_range = new Range(RangeBoundary::FromConstant(r_min),         \
                                    RangeBoundary::FromConstant(r_max));        \
     EXPECT(left_range->min().ConstantValue() == l_min);                        \
     EXPECT(left_range->max().ConstantValue() == l_max);                        \
@@ skipping 34 matching lines @@
                  RangeBoundary(static_cast<int64_t>(0xffffffff)));
 
   // Test that [-20, 20] & [-20, 20] = [-32, 31].
   TEST_RANGE_AND(static_cast<int64_t>(-20), static_cast<int64_t>(20),
                  static_cast<int64_t>(-20), static_cast<int64_t>(20),
                  RangeBoundary(-32), RangeBoundary(31));
 
 #undef TEST_RANGE_AND
 }
 
-
 TEST_CASE(RangeIntersectionMinMax) {
   // Test IntersectionMin and IntersectionMax methods which for constants are
   // simply defined as Max/Min respectively.
 
   // Constants.
   // MIN(0, 1) == 0
   EXPECT(RangeBoundary::IntersectionMax(RangeBoundary::FromConstant(0),
                                         RangeBoundary::FromConstant(1))
              .ConstantValue() == 0);
   // MIN(0, -1) == -1
@@ skipping 59 matching lines @@
 
   EXPECT(
       RangeBoundary::IntersectionMax(RangeBoundary::FromConstant(1), p_infinity)
           .ConstantValue() == 1);
 
   EXPECT(
       RangeBoundary::IntersectionMax(p_infinity, RangeBoundary::FromConstant(1))
           .ConstantValue() == 1);
 }
 
-
 TEST_CASE(RangeJoinMinMax) {
   // Test IntersectionMin and IntersectionMax methods which for constants are
   // simply defined as Min/Max respectively.
   const RangeBoundary::RangeSize size = RangeBoundary::kRangeBoundarySmi;
 
   // Constants.
   EXPECT(RangeBoundary::JoinMax(RangeBoundary::FromConstant(0),
                                 RangeBoundary::FromConstant(1), size)
              .ConstantValue() == 1);
   EXPECT(RangeBoundary::JoinMax(RangeBoundary::FromConstant(0),
@@ skipping 49 matching lines @@
   EXPECT(
       RangeBoundary::JoinMax(RangeBoundary::FromConstant(1), p_infinity, size)
           .IsMaximumOrAbove(size));
 
   EXPECT(
       RangeBoundary::JoinMax(p_infinity, RangeBoundary::FromConstant(1), size)
           .IsMaximumOrAbove(size));
 }
 
 }  // namespace dart