Dnsruby 0.5.0 → 0.6.0

data/test/tc_resolver.rb

@@ -25,6 +25,8 @@ include Dnsruby
 class TestResolver < Test::Unit::TestCase
   include Dnsruby
   Thread::abort_on_exception = true
+  PORT = 42138
+  @@port = PORT
   def setup
     Dnsruby::Config.reset
   end
@@ -62,10 +64,10 @@ class TestResolver < Test::Unit::TestCase
     assert(error==nil)
   end
 
-# @TODO@ Implement!!  
-#  def test_many_threaded_clients
-#    assert(false, "IMPLEMENT!")
-#  end
+  # @TODO@ Implement!!  
+  #  def test_many_threaded_clients
+  #    assert(false, "IMPLEMENT!")
+  #  end
   
   def test_reverse_lookup
     m = Message.new("210.251.121.214", Types.PTR)
@@ -81,7 +83,7 @@ class TestResolver < Test::Unit::TestCase
         assert(answer.domainname.to_s=~/ruby-lang/)      
       end
     end
-      assert(!no_pointer)
+    assert(!no_pointer)
   end
   
   def test_bad_host
@@ -95,13 +97,13 @@ class TestResolver < Test::Unit::TestCase
     assert(id==q)
     assert(m == nil)
     print err.class
-    assert(err.kind_of?(OtherResolvError))
+    assert(err.kind_of?(OtherResolvError) || err.kind_of?(IOError), "OtherResolvError or IOError expected : got #{err.class}")
   end
   
   def test_nxdomain
     res=Resolver.new
     q = Queue.new
-    res.send_async(Message.new("dklfjhdFHFHDVVUIEWRFDSAJKVCNASDLFJHN.com", Types.A), 1, q)
+    res.send_async(Message.new("dklfjhdFHFHDVVUIEWRFDSAJKVCNASDLFJHN.com", Types.A), q, 1)
     id, m, err = q.pop
     assert(id==1)
     assert(m.header.rcode == RCode.NXDOMAIN)
@@ -109,69 +111,75 @@ class TestResolver < Test::Unit::TestCase
   end
   
   def test_timeouts
-    #@TODO@ test timeout behaviour for different retry, retrans, total timeout etc.
+    #test timeout behaviour for different retry, retrans, total timeout etc.
     #Problem here is that many sockets will be created for queries which time out. 
     # Run a query which will not respond, and check that the timeout works
-    start=stop=0
-    retry_times = 3
-    retry_delay=1
-    packet_timeout=2
-    # Work out what time should be, then time it to check
-    expected = ((2**(retry_times-1))*retry_delay) + packet_timeout
-    begin
-      res = Resolver.new({:nameserver => "10.0.1.128"})
-      #      res = Resolver.new({:nameserver => "213.248.199.17"})
-      res.packet_timeout=packet_timeout
-      res.retry_times=retry_times
-      res.retry_delay=retry_delay
-      start=Time.now
-      m = res.send_message(Message.new("a.t.dnsruby.validation-test-servers.nominet.org.uk", Types.A))
-      fail
-    rescue ResolvTimeout
-      stop=Time.now
-      time = stop-start
-      assert(time <= expected *1.2 && time >= expected *0.9, "Wrong time take, expected #{expected}, took #{time}")        
-    end
+    if (!RUBY_PLATFORM=~/darwin/)
+      start=stop=0
+      retry_times = 3
+      retry_delay=1
+      packet_timeout=2
+      # Work out what time should be, then time it to check
+      expected = ((2**(retry_times-1))*retry_delay) + packet_timeout
+      begin
+        res = Resolver.new({:nameserver => "10.0.1.128"})
+        #      res = Resolver.new({:nameserver => "213.248.199.17"})
+        res.packet_timeout=packet_timeout
+        res.retry_times=retry_times
+        res.retry_delay=retry_delay
+        start=Time.now
+        m = res.send_message(Message.new("a.t.dnsruby.validation-test-servers.nominet.org.uk", Types.A))
+        fail
+      rescue ResolvTimeout
+        stop=Time.now
+        time = stop-start
+        assert(time <= expected *1.2 && time >= expected *0.9, "Wrong time take, expected #{expected}, took #{time}")        
+      end
+  end
   end
   
   def test_packet_timeout
-    res = Resolver.new({:nameserver => "10.0.1.128"})
-    start=stop=0
-    retry_times = retry_delay = packet_timeout= 10
-    query_timeout=1
-    begin
-      res.packet_timeout=packet_timeout
-      res.retry_times=retry_times
-      res.retry_delay=retry_delay
-      res.query_timeout=query_timeout
-      # Work out what time should be, then time it to check
-      expected = query_timeout
-      start=Time.now
-      m = res.send_message(Message.new("a.t.dnsruby.validation-test-servers.nominet.org.uk", Types.A))
-      fail
-    rescue ResolvTimeout
-      stop=Time.now
-      time = stop-start
-      assert(time <= expected *1.1 && time >= expected *0.9, "Wrong time take, expected #{expected}, took #{time}")        
-    end    
+    if (!RUBY_PLATFORM=~/darwin/)
+      res = Resolver.new({:nameserver => "10.0.1.128"})
+      start=stop=0
+      retry_times = retry_delay = packet_timeout= 10
+      query_timeout=1
+      begin
+        res.packet_timeout=packet_timeout
+        res.retry_times=retry_times
+        res.retry_delay=retry_delay
+        res.query_timeout=query_timeout
+        # Work out what time should be, then time it to check
+        expected = query_timeout
+        start=Time.now
+        m = res.send_message(Message.new("a.t.dnsruby.validation-test-servers.nominet.org.uk", Types.A))
+        fail
+      rescue ResolvTimeout
+        stop=Time.now
+        time = stop-start
+        assert(time <= expected *1.1 && time >= expected *0.9, "Wrong time take, expected #{expected}, took #{time}")        
+      end    #
+  end
   end
   
   def test_queue_packet_timeout
-    res = Resolver.new({:nameserver => "10.0.1.128"})
-    bad = SingleResolver.new("localhost")
-    res.add_resolver(bad)
-    expected = 1
-    res.query_timeout=expected    
-    q = Queue.new
-    start = Time.now
-    m = res.send_async(Message.new("a.t.dnsruby.validation-test-servers.nominet.org.uk", Types.A), q, q)
-    id,ret,err = q.pop
-    stop = Time.now
-    assert(id=q)
-    assert(ret==nil)
-    assert(err.class == ResolvTimeout, "#{err.class}, #{err}")
-    time = stop-start
-    assert(time <= expected *1.2 && time >= expected *0.9, "Wrong time take, expected #{expected}, took #{time}")            
+    if (!RUBY_PLATFORM=~/darwin/)
+      res = Resolver.new({:nameserver => "10.0.1.128"})
+      bad = SingleResolver.new("localhost")
+      res.add_resolver(bad)
+      expected = 1
+      res.query_timeout=expected    
+      q = Queue.new
+      start = Time.now
+      m = res.send_async(Message.new("a.t.dnsruby.validation-test-servers.nominet.org.uk", Types.A), q, q)
+      id,ret,err = q.pop
+      stop = Time.now
+      assert(id=q)
+      assert(ret==nil)
+      assert(err.class == ResolvTimeout, "#{err.class}, #{err}")
+      time = stop-start
+      assert(time <= expected *1.2 && time >= expected *0.9, "Wrong time take, expected #{expected}, took #{time}")            
+    end
   end
-    
+  
 end

data/test/tc_single_resolver.rb

@@ -20,33 +20,34 @@ include Dnsruby
 class TestSingleResolver < Test::Unit::TestCase
   # @todo@ Test udppacketsize
   Thread::abort_on_exception = true
+  #  Dnsruby::TheLog.level=Logger::DEBUG
   
   def setup
     Dnsruby::Config.reset
   end
   
   Rrs = [
-  {
-    :type   		=> Types.A,
-    :name   		=> 'a.t.dnsruby.validation-test-servers.nominet.org.uk',
-    :address 	=> '10.0.1.128'
-  },
-  {
-    :type		=> Types::MX,
-    :name		=> 'mx.t.dnsruby.validation-test-servers.nominet.org.uk',
-    :exchange	=> 'a.t.dnsruby.validation-test-servers.nominet.org.uk',
-    :preference 	=> 10
-  },
-  {
-    :type		=> 'CNAME',
-    :name		=> 'cname.t.dnsruby.validation-test-servers.nominet.org.uk',
-    :domainname		=> 'a.t.dnsruby.validation-test-servers.nominet.org.uk'
-  },
-  {
-    :type		=> Types.TXT,
-    :name		=> 'txt.t.dnsruby.validation-test-servers.nominet.org.uk',
-    :strings		=> ['Net-DNS']
-  }		
+    {
+      :type   		=> Types.A,
+      :name   		=> 'a.t.dnsruby.validation-test-servers.nominet.org.uk',
+      :address 	=> '10.0.1.128'
+    },
+    {
+      :type		=> Types::MX,
+      :name		=> 'mx.t.dnsruby.validation-test-servers.nominet.org.uk',
+      :exchange	=> 'a.t.dnsruby.validation-test-servers.nominet.org.uk',
+      :preference 	=> 10
+    },
+    {
+      :type		=> 'CNAME',
+      :name		=> 'cname.t.dnsruby.validation-test-servers.nominet.org.uk',
+      :domainname		=> 'a.t.dnsruby.validation-test-servers.nominet.org.uk'
+    },
+    {
+      :type		=> Types.TXT,
+      :name		=> 'txt.t.dnsruby.validation-test-servers.nominet.org.uk',
+      :strings		=> ['Net-DNS']
+    }		
   ]		
   
   def test_simple
@@ -55,26 +56,34 @@ class TestSingleResolver < Test::Unit::TestCase
   end
   
   def test_timeout
-    # Run a query which will not respond, and check that the timeout works
-    begin
-      res = SingleResolver.new("10.0.1.128")
-      res.packet_timeout=1
-      m = res.query("a.t.dnsruby.validation-test-servers.nominet.org.uk")
-      fail
-    rescue ResolvTimeout
+    if (!RUBY_PLATFORM=~/darwin/)
+      # Run a query which will not respond, and check that the timeout works
+      begin
+        res = SingleResolver.new("10.0.1.128")
+        res.port = port
+        res.packet_timeout=1
+        m = res.query("a.t.dnsruby.validation-test-servers.nominet.org.uk")
+        fail
+      rescue ResolvTimeout
+      end
     end
   end
   
   def test_queue_timeout
-    res = SingleResolver.new("10.0.1.128")
-    res.packet_timeout=1
-    q = Queue.new
-    msg = Message.new("a.t.dnsruby.validation-test-servers.nominet.org.uk")
-    m = res.send_async(msg, msg, q)
-    id,ret, error = q.pop
-    assert(id=msg)
-    assert(ret==nil)
-    assert(error.class == ResolvTimeout)
+    port = 46129
+    if (!RUBY_PLATFORM=~/darwin/)
+      res = SingleResolver.new("10.0.1.128")
+      res.port = port
+      res.packet_timeout=1
+      q = Queue.new
+      msg = Message.new("a.t.dnsruby.validation-test-servers.nominet.org.uk")
+      res.send_async(msg, q, msg)
+      id,ret, error = q.pop
+      assert(id==msg)
+      assert(ret==nil)
+      p error
+      assert(error.class == ResolvTimeout)
+    end
   end
   
   def test_queries
@@ -117,22 +126,22 @@ class TestSingleResolver < Test::Unit::TestCase
       end
     end # do
   end # test_queries
-
-# @TODO@ Although the test_thread_stopped test runs in isolation, it won't run as part
-# of the whole test suite (ts_dnsruby.rb). Commented out until I can figure out how to 
-# get Test::Unit to run this one sequentially...  
-#  def test_thread_stopped
-#    res=SingleResolver.new
-#    # Send a query, and check select_thread running.
-#    m = res.query("example.com")
-#    assert(Dnsruby::SelectThread.instance.select_thread_alive?)
-#    # Wait a second, and check select_thread stopped.
-#    sleep(2)
-#    assert(!Dnsruby::SelectThread.instance.select_thread_alive?)
-#    # Send another query, and check select_thread running.
-#    m = res.query("example.com")
-#    assert(Dnsruby::SelectThread.instance.select_thread_alive?)
-#  end
+  
+  # @TODO@ Although the test_thread_stopped test runs in isolation, it won't run as part
+  # of the whole test suite (ts_dnsruby.rb). Commented out until I can figure out how to 
+  # get Test::Unit to run this one sequentially...  
+  #  def test_thread_stopped
+  #    res=SingleResolver.new
+  #    # Send a query, and check select_thread running.
+  #    m = res.query("example.com")
+  #    assert(Dnsruby::SelectThread.instance.select_thread_alive?)
+  #    # Wait a second, and check select_thread stopped.
+  #    sleep(2)
+  #    assert(!Dnsruby::SelectThread.instance.select_thread_alive?)
+  #    # Send another query, and check select_thread running.
+  #    m = res.query("example.com")
+  #    assert(Dnsruby::SelectThread.instance.select_thread_alive?)
+  #  end
   
   def test_persistent_socket
     #@TODO@ Really need a test server for this one!
@@ -150,4 +159,13 @@ class TestSingleResolver < Test::Unit::TestCase
     ip = res.server
     assert_equal(ip, '10.0.1.128', 'nameserver() looks up cname.')
   end
+  
+  def test_truncated_response
+    res = SingleResolver.new
+    res.server=('ns0.validation-test-servers.nominet.org.uk')
+    res.packet_timeout = 15
+    m = res.query("overflow.dnsruby.validation-test-servers.nominet.org.uk", 'txt')
+    assert(m.header.ancount == 61, "61 answer records expected, got #{m.header.ancount}")
+    assert(!m.header.tc, "Message was truncated!")
+  end
 end

data/test/tc_soak.rb

@@ -18,16 +18,21 @@ require 'test/unit'
 require 'Dnsruby'
 begin
 require 'test/tc_single_resolver'
-rescue Exception
+rescue LoadError
   require 'tc_single_resolver'
 end
+begin
+require 'test/tc_soak_base'
+rescue LoadError
+  require 'tc_soak_base'
+end
 include Dnsruby
 # This class tries to soak test the Dnsruby library.
 # It can't do this very well, owing to the small number of sockets allowed to be open simultaneously. 
 # @TODO@ Future versions of dnsruby will allow random streaming over a fixed number of (cycling) random sockets,
 # so this test can be beefed up considerably at that point.
 # @todo@ A test DNS server running on localhost is really needed here
-class TestSingleResolverSoak < TestSingleResolver
+class TestSingleResolverSoak < Test::Unit::TestCase
   
   #  def test_many_queries_single_socket
   # @todo@ Implement this test?
@@ -58,14 +63,14 @@ class TestSingleResolverSoak < TestSingleResolver
     # We run four queries per iteration, so we're limited to 64 runs.
     63.times do |i|
       rr_count = 0
-      Rrs.each do |data|
+      TestSoakBase::Rrs.each do |data|
         rr_count+=1
         res = resolvers[res_pos]
         res_pos=+1
         if (res_pos >= num_resolvers)
           res_pos = 0
         end
-        res.send_async(Message.new(data[:name], data[:type]), [i,rr_count], q)
+        res.send_async(Message.new(data[:name], data[:type]), q, [i,rr_count])
         #        p "Sent #{i}, #{rr_count}, Queue #{q}"
         query_count+=1
       end
@@ -107,7 +112,7 @@ class TestSingleResolverSoak < TestSingleResolver
     num_times.times do |i|
       threads[i] = Thread.new{
         4.times do |j|
-          Rrs.each do |data|
+          TestSoakBase::Rrs.each do |data|
             mutex.synchronize do
               query_count+=1
             end
@@ -167,12 +172,12 @@ class TestSingleResolverSoak < TestSingleResolver
         res = SingleResolver.new
         res.packet_timeout=4
         4.times do |j|
-          Rrs.each do |data|
+          TestSoakBase::Rrs.each do |data|
             mutex.synchronize do
               query_count+=1
             end
             q = Queue.new
-            res.send_async(Message.new(data[:name], data[:type]), [i,j], q)
+            res.send_async(Message.new(data[:name], data[:type]), q, [i,j])
             id, packet, error = q.pop
             if (error.class == ResolvTimeout)
               #              p "TIMEOUT for Thread #{i}, reply #{j}, type #{data[:type]}"
@@ -200,111 +205,5 @@ class TestSingleResolverSoak < TestSingleResolver
     assert(timed_out < query_count * 0.1, "#{timed_out} of #{query_count} timed out!")
   end
   
-  def test_continuous_queries_asynch_single_res
-    # Have two threads looping, with one sending, and one receiving queries.
-    # Never exceed more than 250 concurrent queries, but make sure they're always running.
-    num_loops = 2000
-    num_sent = 0
-    q = Queue.new
-    timed_out = 0
-    mutex = Mutex.new
-    start = Time.now
-    num_in_progress = 0
-    sender = Thread.new{
-      res = SingleResolver.new
-      res.packet_timeout=5
-      # On windows, MAX_FILES is 256. This means that we have to limit
-      # this test while we're not using single sockets.
-      # We run four queries per iteration, so we're limited to 64 runs.
-      num_loops.times do |i|
-        rr_count = 0
-        Rrs.each do |data|
-          rr_count+=1
-          while (mutex.synchronize{num_in_progress> 250}) do
-            sleep(0.01)
-          end
-          res.send_async(Message.new(data[:name], data[:type]), [i,rr_count], q)
-          num_sent+=1
-          mutex.synchronize {
-            num_in_progress+=1
-          }
-        end
-      end
-      
-    }
-    receiver = Thread.new{
-     (num_loops*4).times do |i|
-        id,ret, error = q.pop
-        mutex.synchronize {
-          num_in_progress-=1
-        }
-        if (error.class == ResolvTimeout)
-          timed_out+=1
-          #        p "Number #{i} timed out!"
-        elsif (ret.class != Message)
-          TheLog.debug("tc_single_resolver : Query #{i} ERROR RETURNED : #{error.class}, #{error}")
-        end
-      end
-    }
-    sender.join
-    receiver.join
-    assert(num_in_progress==0)
-    stop=Time.now
-    time_taken=stop-start
-    p "Query count : #{num_sent}, #{timed_out} timed out. #{time_taken} time taken"
-    assert(timed_out < num_sent * 0.1, "#{timed_out} of #{num_sent} timed out!")
-  end
-  
-  def test_continuous_queries_asynch_resolver
-    # Have two threads looping, with one sending, and one receiving queries.
-    # Never exceed more than 250 concurrent queries, but make sure they're always running.
-    num_loops = 1000
-    num_sent = 0
-    q = Queue.new
-    timed_out = 0
-    mutex = Mutex.new
-    start = Time.now
-    num_in_progress = 0
-    sender = Thread.new{
-      res = Resolver.new
-      # On windows, MAX_FILES is 256. This means that we have to limit
-      # this test while we're not using single sockets.
-      # We run four queries per iteration, so we're limited to 64 runs.
-      num_loops.times do |i|
-        while (mutex.synchronize{num_in_progress> 50}) do # One query has several sockets in Resolver
-          sleep(0.01)
-        end
-        res.send_async(Message.new("example.com", Types.A), [i,1], q)
-        num_sent+=1
-        mutex.synchronize {
-          num_in_progress+=1
-        }
-      end
-    }
-    error_count=0
-    receiver = Thread.new{
-     (num_loops).times do |i|
-        id,ret, error = q.pop
-        mutex.synchronize {
-          num_in_progress-=1
-        }
-        if (error.class == ResolvTimeout)
-          timed_out+=1
-          #        p "Number #{i} timed out!"
-        elsif (ret.class != Message)
-          error_count+=1
-          TheLog.error("tc_single_resolver : Query #{i} ERROR RETURNED : #{error.class}, #{error}")
-        end
-      end
-    }
-    sender.join
-    receiver.join
-    assert(num_in_progress==0)
-    stop=Time.now
-    time_taken=stop-start
-    p "Query count : #{num_sent}, #{timed_out} timed out, #{error_count} other errors. #{time_taken} time taken"
-    assert(timed_out < num_sent * 0.1, "#{timed_out} of #{num_sent} timed out!")
-    assert(error_count == 0)
-  end
   
 end

data/test/tc_soak_base.rb

@@ -0,0 +1,136 @@
+require 'rubygems'
+require 'test/unit'
+require 'Dnsruby'
+
+class TestSoakBase # < Test::Unit::TestCase
+  include Dnsruby
+  Rrs = [
+  {
+    :type   		=> Types.A,
+    :name   		=> 'a.t.dnsruby.validation-test-servers.nominet.org.uk',
+    :address 	=> '10.0.1.128'
+  },
+  {
+    :type		=> Types::MX,
+    :name		=> 'mx.t.dnsruby.validation-test-servers.nominet.org.uk',
+    :exchange	=> 'a.t.dnsruby.validation-test-servers.nominet.org.uk',
+    :preference 	=> 10
+  },
+  {
+    :type		=> 'CNAME',
+    :name		=> 'cname.t.dnsruby.validation-test-servers.nominet.org.uk',
+    :domainname		=> 'a.t.dnsruby.validation-test-servers.nominet.org.uk'
+  },
+  {
+    :type		=> Types.TXT,
+    :name		=> 'txt.t.dnsruby.validation-test-servers.nominet.org.uk',
+    :strings		=> ['Net-DNS']
+  }		
+  ]		
+
+  def TestSoakBase.test_continuous_queries_asynch_single_res
+    # Have two threads looping, with one sending, and one receiving queries.
+    # Never exceed more than 200 concurrent queries, but make sure they're always running.
+    outstanding_limit = 1
+    num_loops = 2000
+    num_sent = 0
+    q = Queue.new
+    timed_out = 0
+    mutex = Mutex.new
+    start = Time.now
+    num_in_progress = 0
+    sender = Thread.new{
+      res = SingleResolver.new
+      res.packet_timeout=5
+      num_loops.times do |i|
+        rr_count = 0
+        Rrs.each do |data|
+          rr_count+=1
+          while (mutex.synchronize{num_in_progress> outstanding_limit}) do
+            sleep(0.01)
+          end
+          res.send_async(Message.new(data[:name], data[:type]), q, [i,rr_count])
+          puts num_sent
+          num_sent+=1
+          mutex.synchronize {
+            num_in_progress+=1
+          }
+        end
+      end
+      
+    }
+    receiver = Thread.new{
+     (num_loops*4).times do |i|
+        id,ret, error = q.pop
+        mutex.synchronize {
+          num_in_progress-=1
+        }
+        if (error.class == ResolvTimeout)
+          timed_out+=1
+          #        p "Number #{i} timed out!"
+        elsif (ret.class != Message)
+          TheLog.debug("tc_single_resolver : Query #{i} ERROR RETURNED : #{error.class}, #{error}")
+        end
+      end
+    }
+    sender.join
+    receiver.join
+    assert(num_in_progress==0)
+    stop=Time.now
+    time_taken=stop-start
+    p "Query count : #{num_sent}, #{timed_out} timed out. #{time_taken} time taken"
+    assert(timed_out < num_sent * 0.1, "#{timed_out} of #{num_sent} timed out!")
+  end
+  
+  def TestSoakBase.test_continuous_queries_asynch_resolver
+    # Have two threads looping, with one sending, and one receiving queries.
+    # Never exceed more than 250 concurrent queries, but make sure they're always running.
+    num_loops = 1000
+    num_sent = 0
+    q = Queue.new
+    timed_out = 0
+    mutex = Mutex.new
+    start = Time.now
+    num_in_progress = 0
+    sender = Thread.new{
+      res = Resolver.new
+      # On windows, MAX_FILES is 256. This means that we have to limit
+      # this test while we're not using single sockets.
+      # We run four queries per iteration, so we're limited to 64 runs.
+      num_loops.times do |i|
+        while (mutex.synchronize{num_in_progress> 50}) do # One query has several sockets in Resolver
+          sleep(0.01)
+        end
+        res.send_async(Message.new("example.com", Types.A), q, [i,1])
+        num_sent+=1
+        mutex.synchronize {
+          num_in_progress+=1
+        }
+      end
+    }
+    error_count=0
+    receiver = Thread.new{
+     (num_loops).times do |i|
+        id,ret, error = q.pop
+        mutex.synchronize {
+          num_in_progress-=1
+        }
+        if (error.class == ResolvTimeout)
+          timed_out+=1
+          #        p "Number #{i} timed out!"
+        elsif (ret.class != Message)
+          error_count+=1
+          TheLog.error("tc_single_resolver : Query #{i} ERROR RETURNED : #{error.class}, #{error}")
+        end
+      end
+    }
+    sender.join
+    receiver.join
+    assert(num_in_progress==0)
+    stop=Time.now
+    time_taken=stop-start
+    p "Query count : #{num_sent}, #{timed_out} timed out, #{error_count} other errors. #{time_taken} time taken"
+    assert(timed_out < num_sent * 0.1, "#{timed_out} of #{num_sent} timed out!")
+    assert(error_count == 0)
+  end
+end