sparkql 1.2.5 → 1.3.0

data/test/unit/parser_test.rb

@@ -5,10 +5,10 @@ class ParserTest < Test::Unit::TestCase
 
   def test_simple
     @parser = Parser.new
-    parse 'Test Eq 10',10.to_s
-    parse 'Test Eq 10.0',10.0.to_s
-    parse 'Test Eq true',true.to_s
-    parse "Test Eq 'false'","'false'"
+    parse 'Test Eq 10', 10.to_s
+    parse 'Test Eq 10.0', 10.0.to_s
+    parse 'Test Eq true', true.to_s
+    parse "Test Eq 'false'", "'false'"
   end
 
   def test_conjunction
@@ -26,7 +26,7 @@ class ParserTest < Test::Unit::TestCase
     assert_equal 11.to_s, expression.last[:value]
     assert_equal 'Not', expression.last[:conjunction]
   end
-  
+
   def test_tough_conjunction
     @parser = Parser.new
     expression = @parser.parse('Test Eq 10 Or Test Ne 11 And Test Ne 9')
@@ -52,50 +52,50 @@ class ParserTest < Test::Unit::TestCase
   def test_multiples
     @parser = Parser.new
     expression = @parser.parse('(Test Eq 10,11,12)').first
-    assert_equal [10.to_s,11.to_s,12.to_s], expression[:value]
+    assert_equal [10.to_s, 11.to_s, 12.to_s], expression[:value]
     assert_equal '10,11,12', expression[:condition]
   end
-    
+
   def test_invalid_syntax
     @parser = Parser.new
     expression = @parser.parse('Test Eq DERP')
     assert @parser.errors?, "Should be nil: #{expression}"
   end
-  
+
   def test_nesting
     assert_nesting(
       "City Eq 'Fargo' Or (BathsFull Eq 1 Or BathsFull Eq 2) Or City Eq 'Moorhead' Or City Eq 'Dilworth'",
-      [0,1,1,0,0]
+      [0, 1, 1, 0, 0]
     )
   end
-  
+
   def test_nesting_and_functions
     # Nesting with a function thrown in. Yes, this was a problem.
     assert_nesting(
       "City Eq 'Fargo' Or (BathsFull Eq 1 And Location Eq rectangle('35.12 -68.33, 35.13 -68.32')) Or Location Eq radius('35.12 -68.33',10.0) Or City Eq 'Dilworth'",
-      [0,1,1,0,0]
+      [0, 1, 1, 0, 0]
     )
   end
 
   def test_multilevel_nesting
     assert_nesting(
       "(City Eq 'Fargo' And (BathsFull Eq 1 Or BathsFull Eq 2)) Or City Eq 'Moorhead' Or City Eq 'Dilworth'",
-      [1,2,2,0,0]
+      [1, 2, 2, 0, 0]
     )
-    
+
     # API-629
     assert_nesting(
       "((MlsStatus Eq 'A') Or (MlsStatus Eq 'D' And CloseDate Ge 2011-05-17)) And ListPrice Ge 150000.0 And PropertyType Eq 'A'",
-      [2,2,2,0,0],
-      [2,3,3,0,0]
+      [2, 2, 2, 0, 0],
+      [2, 3, 3, 0, 0]
     )
     assert_nesting(
       "ListPrice Ge 150000.0 And PropertyType Eq 'A' And ((MlsStatus Eq 'A') Or (MlsStatus Eq 'D' And CloseDate Ge 2011-05-17))",
-      [0,0,2,2,2],
-      [0,0,2,3,3]
+      [0, 0, 2, 2, 2],
+      [0, 0, 2, 3, 3]
     )
   end
-  
+
   def test_bad_queries
     filter = "City IsLikeA 'Town'"
     @parser = Parser.new
@@ -105,8 +105,8 @@ class ParserTest < Test::Unit::TestCase
   end
 
   def test_function_months
-    dt = DateTime.new(2014, 1, 5, 0, 0, 0, 0)
-    DateTime.expects(:now).returns(dt)
+    t = Time.new(2014, 1, 5, 0, 0, 0, 0)
+    Time.expects(:now).returns(t)
     @parser = Parser.new
     expressions = @parser.parse "ExpirationDate Gt months(-3)"
     assert !@parser.errors?, "errors :( #{@parser.errors.inspect}"
@@ -115,8 +115,8 @@ class ParserTest < Test::Unit::TestCase
   end
 
   def test_function_years
-    dt = DateTime.new(2014, 1, 5, 0, 0, 0, 0)
-    DateTime.expects(:now).returns(dt)
+    t = Time.new(2014, 1, 5, 0, 0, 0, 0)
+    Time.expects(:now).returns(t)
     @parser = Parser.new
     expressions = @parser.parse "SoldDate Lt years(2)"
     assert !@parser.errors?, "errors :( #{@parser.errors.inspect}"
@@ -125,19 +125,23 @@ class ParserTest < Test::Unit::TestCase
   end
 
   def test_function_days
-    d = Date.today
-    start = Time.utc(d.year,d.month,d.day,0,0,0)
-    filter = "OriginalEntryTimestamp Ge days(-7)"
+    t = Time.new(2021, 2, 22, 0, 0, 0, 0)
+    Time.expects(:now).returns(t)
     @parser = Parser.new
-    expressions = @parser.parse(filter)
-    assert !@parser.errors?, "errors #{@parser.errors.inspect}"
-    assert_equal 'days(-7)', expressions.first[:condition]
-
-    vals = expressions.first[:value].split('-')
+    expressions = @parser.parse "ExpirationDate Gt days(10)"
+    assert !@parser.errors?
+    assert_equal "2021-03-04", expressions.first[:value]
+    assert_equal 'days(10)', expressions.first[:condition]
+  end
 
-    test_time = Time.utc(vals[0].to_i, vals[1].to_i, vals[2].to_i)
-    
-    assert (-605000 < test_time - start && -604000 > test_time - start), "Time range off by more than five seconds #{test_time - start} '#{test_time} - #{start}'"
+  def test_function_weekdays
+    t = Time.new(2021, 2, 22, 0, 0, 0, 0)
+    Time.expects(:now).returns(t)
+    @parser = Parser.new
+    expressions = @parser.parse "ExpirationDate Gt weekdays(10)"
+    assert !@parser.errors?
+    assert_equal "2021-03-08", expressions.first[:value]
+    assert_equal 'weekdays(10)', expressions.first[:condition]
   end
 
   def test_function_now
@@ -148,8 +152,8 @@ class ParserTest < Test::Unit::TestCase
     assert !@parser.errors?, "errors #{@parser.errors.inspect}"
     assert_equal 'now()', expressions.first[:condition]
     test_time = Time.parse(expressions.first[:value])
-    assert 5 > test_time - start, "Time range off by more than five seconds #{test_time - start}"
-    assert -5 < test_time - start, "Time range off by more than five seconds #{test_time - start}"
+    assert test_time - start < 5, "Time range off by more than five seconds #{test_time - start}"
+    assert(test_time - start > -5, "Time range off by more than five seconds #{test_time - start}")
   end
 
   def test_function_range
@@ -174,7 +178,8 @@ class ParserTest < Test::Unit::TestCase
     assert_equal 'indexof', expression[:field_manipulations][:function_name]
     assert_equal :function, expression[:field_manipulations][:type]
     assert_equal :integer, expression[:field_manipulations][:return_type]
-    assert_equal ['City', '4131800000000'], expression[:field_manipulations][:args].map {|v| v[:value]}
+    assert_equal(%w[City 4131800000000],
+                 expression[:field_manipulations][:args].map { |v| v[:value] })
   end
 
   test 'add' do
@@ -307,7 +312,7 @@ class ParserTest < Test::Unit::TestCase
     assert_equal 'days(-7)', expressions.first[:condition]
     assert_equal([-7], expressions.first[:function_parameters])
   end
-  
+
   test "function rangeable " do
     filter = "OriginalEntryTimestamp Bt days(-7),days(-1)"
     @parser = Parser.new
@@ -388,10 +393,40 @@ class ParserTest < Test::Unit::TestCase
   test "invalid regex" do
     filter = "ParcelNumber Eq regex('[1234', '')"
     @parser = Parser.new
-    expressions = @parser.parse(filter)
+    @parser.parse(filter)
     assert @parser.errors?, "Parser error expected due to invalid regex"
   end
 
+  test "dayofyear function parses" do
+    filter = "dayofyear(DatetimeField) Eq 2012"
+    @parser = Parser.new
+    expressions = @parser.parse(filter)
+    assert !@parser.errors?, @parser.errors.inspect
+    function = expressions.first[:field_manipulations]
+    assert_equal 'dayofyear', function[:function_name]
+    assert_equal 'DatetimeField', function[:function_parameters].first
+  end
+
+  test "dayofweek function parses" do
+    filter = "dayofweek(DatetimeField) Eq 7"
+    @parser = Parser.new
+    expressions = @parser.parse(filter)
+    assert !@parser.errors?, @parser.errors.inspect
+    function = expressions.first[:field_manipulations]
+    assert_equal 'dayofweek', function[:function_name]
+    assert_equal 'DatetimeField', function[:function_parameters].first
+  end
+
+  test "weekdays function resolves" do
+    filter = "DatetimeField Eq weekdays(10)"
+    @parser = Parser.new
+    expressions = @parser.parse(filter)
+    assert !@parser.errors?, @parser.errors.inspect
+    function = expressions.first
+    assert_equal 'weekdays', function[:function_name]
+    assert_equal 10, function[:function_parameters].first
+  end
+
   test "allow timezone offsets" do
     values = [
       "2013-07-26",
@@ -418,7 +453,7 @@ class ParserTest < Test::Unit::TestCase
       assert_equal expressions.first[:value], value, "#{value} failed"
     end
   end
-  
+
   test "Location Eq polygon()" do
     filter = "Location Eq polygon('35.12 -68.33, 35.13 -68.33, 35.13 -68.32, 35.12 -68.32')"
     @parser = Parser.new
@@ -426,7 +461,7 @@ class ParserTest < Test::Unit::TestCase
     assert !@parser.errors?, "errors #{@parser.errors.inspect}"
     assert_equal "polygon('35.12 -68.33, 35.13 -68.33, 35.13 -68.32, 35.12 -68.32')", expressions.first[:condition]
     assert_equal :shape, expressions.first[:type]
-    assert_equal [[-68.33, 35.12], [-68.33, 35.13], [-68.32,35.13], [-68.32,35.12],[-68.33, 35.12]], expressions.first[:value].to_coordinates.first, "#{expressions.first[:value].inspect} "
+    assert_equal [[-68.33, 35.12], [-68.33, 35.13], [-68.32, 35.13], [-68.32, 35.12], [-68.33, 35.12]], expressions.first[:value].to_coordinates.first, "#{expressions.first[:value].inspect} "
   end
 
   test "Location Eq linestring()" do
@@ -437,7 +472,6 @@ class ParserTest < Test::Unit::TestCase
     assert_equal "linestring('35.12 -68.33, 35.13 -68.33')", expressions.first[:condition]
     assert_equal :shape, expressions.first[:type]
     assert_equal [[-68.33, 35.12], [-68.33, 35.13]], expressions.first[:value].to_coordinates, "#{expressions.first[:value].inspect} "
-
   end
 
   test "Location Eq rectangle()" do
@@ -446,7 +480,7 @@ class ParserTest < Test::Unit::TestCase
     expressions = @parser.parse(filter)
     assert !@parser.errors?, "errors #{@parser.errors.inspect}"
     assert_equal :shape, expressions.first[:type]
-    assert_equal [[-68.33,35.12], [-68.32,35.12], [-68.32,35.13], [-68.33,35.13], [-68.33,35.12]], expressions.first[:value].to_coordinates.first, "#{expressions.first[:value].inspect} "
+    assert_equal [[-68.33, 35.12], [-68.32, 35.12], [-68.32, 35.13], [-68.33, 35.13], [-68.33, 35.12]], expressions.first[:value].to_coordinates.first, "#{expressions.first[:value].inspect} "
   end
 
   test "Location Eq radius()" do
@@ -473,26 +507,26 @@ class ParserTest < Test::Unit::TestCase
   test "Location eq radius() error on invalid syntax" do
     filter = "Location Eq radius('35.12,-68.33',1.0)"
     @parser = Parser.new
-    expressions = @parser.parse(filter)
+    @parser.parse(filter)
     assert @parser.errors?, "Parser error expected due to comma between radius points"
   end
-  
+
   test "Location ALL TOGETHER NOW" do
     filter = "Location Eq linestring('35.12 -68.33, 35.13 -68.33') And Location Eq radius('35.12 -68.33',1.0) And Location Eq rectangle('35.12 -68.33, 35.13 -68.32') And Location Eq polygon('35.12 -68.33, 35.13 -68.33, 35.13 -68.32, 35.12 -68.32')"
     @parser = Parser.new
     expressions = @parser.parse(filter)
     assert !@parser.errors?, "errors #{@parser.errors.inspect}"
-    assert_equal [:shape,:shape,:shape,:shape], expressions.map{|e| e[:type]}
+    assert_equal(%i[shape shape shape shape], expressions.map { |e| e[:type] })
   end
-  
+
   def test_for_reserved_words_first_literals_second
     ["OrOrOr Eq true", "Equador Eq true", "Oregon Ge 10"].each do |filter|
       @parser = Parser.new
-      expressions = @parser.parse(filter)
+      @parser.parse(filter)
       assert !@parser.errors?, "Filter '#{filter}' errors: #{@parser.errors.inspect}"
     end
   end
-  
+
   def test_custom_fields
     filter = '"General Property Description"."Taxes" Lt 500.0'
     @parser = Parser.new
@@ -502,48 +536,46 @@ class ParserTest < Test::Unit::TestCase
     assert expressions.first[:custom_field], "Custom field expression #{expressions.inspect}"
     assert_equal '500.0', expressions.first[:value], "Custom field expression #{expressions.inspect}"
   end
-  
+
   def test_valid_custom_field_filters
     ['"General Property Description"."Taxes$" Lt 500.0',
-      '"General Property Desc\'"."Taxes" Lt 500.0',
-      '"General Property Description"."Taxes" Lt 500.0',
-      '"General \'Property\' Description"."Taxes" Lt 500.0',
-      '"General Property Description"."Taxes #" Lt 500.0',
-      '"General$Description"."Taxes" Lt 500.0',
-      '"Garage Type"."1" Eq true',
-      '" a "." b " Lt 500.0'
-    ].each do |filter|
+     '"General Property Desc\'"."Taxes" Lt 500.0',
+     '"General Property Description"."Taxes" Lt 500.0',
+     '"General \'Property\' Description"."Taxes" Lt 500.0',
+     '"General Property Description"."Taxes #" Lt 500.0',
+     '"General$Description"."Taxes" Lt 500.0',
+     '"Garage Type"."1" Eq true',
+     '" a "." b " Lt 500.0'].each do |filter|
       @parser = Parser.new
-      expressions = @parser.parse(filter)
+      @parser.parse(filter)
       assert !@parser.errors?, "errors '#{filter}'\n#{@parser.errors.inspect}"
     end
   end
-  
+
   def test_invalid_custom_field_filters
     ['"$General Property Description"."Taxes" Lt 500.0',
-      '"General Property Description"."$Taxes" Lt 500.0',
-      '"General Property Description"."Tax.es" Lt 500.0',
-      '"General Property Description".".Taxes" Lt 500.0',
-      '"General Property Description".".Taxes"."SUB" Lt 500.0',
-      '"General.Description"."Taxes" Lt 500.0',
-      '""."" Lt 500.0'
-    ].each do |filter|
+     '"General Property Description"."$Taxes" Lt 500.0',
+     '"General Property Description"."Tax.es" Lt 500.0',
+     '"General Property Description".".Taxes" Lt 500.0',
+     '"General Property Description".".Taxes"."SUB" Lt 500.0',
+     '"General.Description"."Taxes" Lt 500.0',
+     '""."" Lt 500.0'].each do |filter|
       @parser = Parser.new
-      expressions = @parser.parse(filter)
+      @parser.parse(filter)
       assert @parser.errors?, "No errors? '#{filter}'\n#{@parser.inspect}"
     end
   end
 
   def test_case_insensitve_ops_and_conjunctions
     @parser = Parser.new
-    parse 'Test EQ 10',10.to_s
-    parse 'Test eq 10.0',10.0.to_s
-    parse 'Test eQ true',true.to_s
+    parse 'Test EQ 10', 10.to_s
+    parse 'Test eq 10.0', 10.0.to_s
+    parse 'Test eQ true', true.to_s
     parse 'Test EQ 10 AND Test NE 11', 10.to_s
     parse 'Test eq 10 or Test ne 11', 10.to_s
     parse 'Test eq 10 NOT Test ne 11', 10.to_s
   end
-  
+
   def test_null
     @parser = Parser.new
     parse 'Test Eq NULL', "NULL"
@@ -557,7 +589,7 @@ class ParserTest < Test::Unit::TestCase
       end
     end
   end
-  
+
   def test_not_expression
     @parser = Parser.new
     expressions = @parser.parse('Test Lt 10 Not Test Eq 2')
@@ -578,7 +610,7 @@ class ParserTest < Test::Unit::TestCase
     assert_equal "And", expression[:conjunction]
     assert_equal expression[:level], expression[:unary_level]
   end
-  
+
   def test_not_expression_group
     @parser = Parser.new
     expressions = @parser.parse('Not (Test Eq 10 Or Test Eq 11)')
@@ -603,7 +635,7 @@ class ParserTest < Test::Unit::TestCase
 
   def test_not_not_expression
     @parser = Parser.new
-    filter = "Not (Not ListPrice Eq 1) Not (Not BathsTotal Eq 2) And " +
+    filter = "Not (Not ListPrice Eq 1) Not (Not BathsTotal Eq 2) And " \
              "(Not TotalRooms Eq 3) Or (HasPool Eq true)"
 
     expressions = @parser.parse(filter)
@@ -672,7 +704,6 @@ class ParserTest < Test::Unit::TestCase
     assert_equal 1, e2[:level]
     assert_equal "Not", e2[:conjunction]
     assert_equal 1, e2[:conjunction_level]
-
   end
 
   def test_expression_conditions_attribute
@@ -704,7 +735,7 @@ class ParserTest < Test::Unit::TestCase
     ]
     conditions.each do |condition|
       @parser = Parser.new
-      expressions = @parser.parse("Test Eq #{condition}")
+      @parser.parse("Test Eq #{condition}")
       assert @parser.errors?, @parser.inspect
     end
   end
@@ -714,12 +745,12 @@ class ParserTest < Test::Unit::TestCase
      "DateTimeField Bt 2013-07-26T10:22:15,2013-07-26T10:22:16",
      "DateTimeField Bt 2013-07-26T10:22:15.422804-0300,2013-07-26T10:22:15.422805-0300",
      "DateTimeField Bt 2013-07-26T10:22:15+0400,2013-07-26T10:22:16+0400"].each do |filter|
-      @parser = Parser.new
-      expression = @parser.parse filter
-      assert !@parser.errors?, "Filter '#{filter}' failed: #{@parser.errors.first.inspect}"
+       @parser = Parser.new
+       @parser.parse filter
+       assert !@parser.errors?, "Filter '#{filter}' failed: #{@parser.errors.first.inspect}"
      end
   end
-  
+
   def test_coercible_types
     @parser = Parser.new
     assert_equal :datetime, @parser.coercible_types(:date, :datetime)
@@ -780,7 +811,6 @@ class ParserTest < Test::Unit::TestCase
     parser_errors("Field Eq -'Stringval'")
   end
 
-
   test "field negation" do
     @parser = Parser.new
     expressions = @parser.parse('-Test Eq 10')
@@ -827,7 +857,8 @@ class ParserTest < Test::Unit::TestCase
 
     assert_equal 'round', expression[:field_manipulations][:function_name]
     assert_equal :function, expression[:field_manipulations][:type]
-    assert_equal ['ListPrice'], expression[:field_manipulations][:args].map {|v| v[:value]}
+    assert_equal(['ListPrice'],
+                 expression[:field_manipulations][:args].map { |v| v[:value] })
   end
 
   def test_ceiling_with_literal
@@ -887,7 +918,8 @@ class ParserTest < Test::Unit::TestCase
 
     assert_equal 'floor', expression[:field_manipulations][:function_name]
     assert_equal :function, expression[:field_manipulations][:type]
-    assert_equal ['ListPrice'], expression[:field_manipulations][:args].map {|v| v[:value]}
+    assert_equal(['ListPrice'],
+                 expression[:field_manipulations][:args].map { |v| v[:value] })
   end
 
   def test_concat_with_field
@@ -898,12 +930,13 @@ class ParserTest < Test::Unit::TestCase
 
     assert_equal :character, expression[:type]
     assert_equal 'concat', expression[:field_function]
-    assert_equal(["City", 'b'], expression[:args])
+    assert_equal(%w[City b], expression[:args])
     assert_equal("City", expression[:field])
 
     assert_equal 'concat', expression[:field_manipulations][:function_name]
     assert_equal :function, expression[:field_manipulations][:type]
-    assert_equal ['City', 'b'], expression[:field_manipulations][:args].map {|v| v[:value]}
+    assert_equal(%w[City b],
+                 expression[:field_manipulations][:args].map { |v| v[:value] })
   end
 
   def test_concat_with_literal
@@ -915,7 +948,7 @@ class ParserTest < Test::Unit::TestCase
     assert_equal 'concat', expression[:function_name]
     assert_equal :character, expression[:type]
     assert_equal "'ab'", expression[:value]
-    assert_equal ["a", "b"], expression[:function_parameters]
+    assert_equal %w[a b], expression[:function_parameters]
   end
 
   def test_cast_with_field
@@ -930,7 +963,8 @@ class ParserTest < Test::Unit::TestCase
 
     assert_equal 'cast', expression[:field_manipulations][:function_name]
     assert_equal :function, expression[:field_manipulations][:type]
-    assert_equal ['ListPrice', 'character'], expression[:field_manipulations][:args].map {|v| v[:value]}
+    assert_equal(%w[ListPrice character],
+                 expression[:field_manipulations][:args].map { |v| v[:value] })
   end
 
   def test_cast_with_invalid_type
@@ -1131,7 +1165,7 @@ class ParserTest < Test::Unit::TestCase
     function2 = function1[:args].first
     assert_equal :function, function2[:type]
     assert_equal 'toupper', function2[:function_name]
-    assert_equal({:type=>:field, :value=>"City"}, function2[:args].first)
+    assert_equal({ type: :field, value: "City" }, function2[:args].first)
   end
 
   test 'nested functions with multiple params' do
@@ -1142,12 +1176,12 @@ class ParserTest < Test::Unit::TestCase
     function1 = expression[:field_manipulations]
     assert_equal :function, function1[:type]
     assert_equal 'concat', function1[:function_name]
-    assert_equal({type: :character, value: 'b'}, function1[:args].last)
+    assert_equal({ type: :character, value: 'b' }, function1[:args].last)
 
     function2 = function1[:args].first
     assert_equal :function, function2[:type]
     assert_equal 'tolower', function2[:function_name]
-    assert_equal({:type=>:field, :value=>"City"}, function2[:args].first)
+    assert_equal({ type: :field, value: "City" }, function2[:args].first)
   end
 
   test 'parse error with no field' do
@@ -1200,30 +1234,30 @@ class ParserTest < Test::Unit::TestCase
 
   private
 
-  def parser_errors(filter)  
+  def parser_errors(filter)
     @parser = Parser.new
     expression = @parser.parse(filter)
     assert @parser.errors?, "Should find errors for '#{filter}': #{expression}"
   end
 
-  def parse(q,v)
-    expressions = @parser.parse(q)
-    assert !@parser.errors?, "Unexpected error parsing #{q} #{@parser.errors.inspect}"
-    assert_equal v, expressions.first[:value], "Expression #{expressions.inspect}"
+  def parse(query, value)
+    expressions = @parser.parse(query)
+    assert !@parser.errors?, "Unexpected error parsing #{query} #{@parser.errors.inspect}"
+    assert_equal value, expressions.first[:value], "Expression #{expressions.inspect}"
     assert !expressions.first[:custom_field], "Unexepected custom field #{expressions.inspect}"
   end
 
   # verify each expression in the query is at the right nesting level and group
-  def assert_nesting(sparkql, levels=[], block_groups=nil)
+  def assert_nesting(sparkql, levels = [], block_groups = nil)
     block_groups = levels.clone if block_groups.nil?
     parser = Parser.new
     expressions = parser.parse(sparkql)
     assert !parser.errors?, "Unexpected error parsing #{sparkql}: #{parser.errors.inspect}"
     count = 0
     expressions.each do |ex|
-      assert_equal levels[count],  ex[:level], "Nesting level wrong for #{ex.inspect}"
-      assert_equal(block_groups[count],  ex[:block_group], "Nesting block group wrong for #{ex.inspect}")
-      count +=1
+      assert_equal levels[count], ex[:level], "Nesting level wrong for #{ex.inspect}"
+      assert_equal(block_groups[count], ex[:block_group], "Nesting block group wrong for #{ex.inspect}")
+      count += 1
     end
   end
 end