Dnsruby 0.5.0

data/test/tc_soak.rb

@@ -0,0 +1,310 @@
+#--
+#Copyright 2007 Nominet UK
+#
+#Licensed under the Apache License, Version 2.0 (the "License");
+#you may not use this file except in compliance with the License. 
+#You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0 
+#
+#Unless required by applicable law or agreed to in writing, software 
+#distributed under the License is distributed on an "AS IS" BASIS, 
+#WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
+#See the License for the specific language governing permissions and 
+#limitations under the License.
+#++
+require 'rubygems'
+require 'test/unit'
+require 'Dnsruby'
+begin
+require 'test/tc_single_resolver'
+rescue Exception
+  require 'tc_single_resolver'
+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
+  
+  #  def test_many_queries_single_socket
+  # @todo@ Implement this test?
+  #  end
+  
+  
+  def test_many_asynchronous_queries_one_single_resolver
+    run_many_asynch_queries_test_single_res(1)
+  end
+  
+  def test_many_asynchronous_queries_many_single_resolvers
+    run_many_asynch_queries_test_single_res(50)
+  end
+  
+  def run_many_asynch_queries_test_single_res(num_resolvers)
+    q = Queue.new
+    resolvers = []
+    timed_out = 0
+    query_count = 0
+    num_resolvers.times do |n|
+      resolvers.push(SingleResolver.new)
+      resolvers[n].packet_timeout=4
+    end
+    res_pos = 0
+    start = Time.now
+    # @todo@ 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.
+    63.times do |i|
+      rr_count = 0
+      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)
+        #        p "Sent #{i}, #{rr_count}, Queue #{q}"
+        query_count+=1
+      end
+    end
+    query_count.times do |i|
+      id,ret, error = q.pop
+      #      p "Got response #{i}"
+      if (error.class == ResolvTimeout)
+        timed_out+=1
+      elsif (ret.class != Message)
+        p "ERROR RETURNED : #{error}"
+      end
+      
+    end
+    stop=Time.now
+    time_taken=stop-start
+    p "Query count : #{query_count}, #{timed_out} timed out. #{time_taken} time taken"
+    assert(timed_out < query_count * 0.1, "#{timed_out} of #{query_count} timed out!")
+  end
+  
+  
+  def test_many_threads_on_one_single_resolver_synchronous
+    # Test multi-threaded behaviour
+    # Check the header IDs to make sure they're all different
+    threads = Array.new
+    res = SingleResolver.new
+    ids = []
+    mutex = Mutex.new
+    timed_out = 0
+    query_count = 0
+    res.packet_timeout=4
+    start=Time.now
+    # Windows limits us to 256 sockets
+    num_times=250
+    if (/java/ =~ RUBY_PLATFORM)
+      # JRuby threads are native threads, so let's not go too mad!
+      num_times=50
+    end        
+    num_times.times do |i|
+      threads[i] = Thread.new{
+        4.times do |j|
+          Rrs.each do |data|
+            mutex.synchronize do
+              query_count+=1
+            end
+            packet=nil
+            begin
+              packet = res.query(data[:name], data[:type])
+            rescue ResolvTimeout
+              #              p "TIMEOUT for Thread #{i}, reply #{j}, type #{data[:type]}"
+              mutex.synchronize {
+                timed_out+=1
+              }
+              next
+            end
+            assert(packet)
+            ids.push(packet.header.id)
+            assert_equal(packet.question[0].qclass,    'IN',             'Class correct'           )
+          end
+        end
+      }
+    end
+    threads.each do |thread|
+      thread.join
+    end
+    stop=Time.now
+    time_taken=stop-start
+    p "Query count : #{query_count}, #{timed_out} timed out. #{time_taken} time taken"
+    #    check_ids(ids) # only do this if we expect all different IDs - e.g. if we stream over a single socket
+    assert(timed_out < query_count * 0.1, "#{timed_out} of #{query_count} timed out!")
+  end
+  
+  def check_ids(ids)
+    ids.sort!
+    count = 0
+    ids.each do |id|
+      count+=1
+      if (count < ids.length-1)
+        assert(ids[count+1] != id, "Two identical header ids used!")
+      end
+    end
+  end
+  
+  def test_many_threads_on_many_single_resolvers
+    # Test multi-threaded behaviour
+    # @todo@ Check the header IDs to make sure they're all different
+    threads = Array.new
+    mutex = Mutex.new
+    timed_out = 0
+    query_count = 0
+    start=Time.now
+    num_times=250
+    if (/java/ =~ RUBY_PLATFORM)
+      # JRuby threads are native threads, so let's not go too mad!
+      num_times=50
+    end        
+    num_times.times do |i|
+      threads[i] = Thread.new{
+        res = SingleResolver.new
+        res.packet_timeout=4
+        4.times do |j|
+          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)
+            id, packet, error = q.pop
+            if (error.class == ResolvTimeout)
+              #              p "TIMEOUT for Thread #{i}, reply #{j}, type #{data[:type]}"
+              mutex.synchronize {
+                timed_out+=1
+              }
+              next
+            elsif (packet.class!=Message)
+              p "ERROR! #{error}"
+            end
+            
+            #            p packet.to_s
+            assert(packet)
+            assert_equal(packet.question[0].qclass,    'IN',             'Class correct'           )
+          end
+        end
+      }
+    end
+    threads.each do |thread|
+      thread.join
+    end
+    stop=Time.now
+    time_taken=stop-start
+    p "Query count : #{query_count}, #{timed_out} timed out. #{time_taken} time taken"
+    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_tcp.rb

@@ -0,0 +1,35 @@
+#--
+#Copyright 2007 Nominet UK
+#
+#Licensed under the Apache License, Version 2.0 (the "License");
+#you may not use this file except in compliance with the License. 
+#You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0 
+#
+#Unless required by applicable law or agreed to in writing, software 
+#distributed under the License is distributed on an "AS IS" BASIS, 
+#WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
+#See the License for the specific language governing permissions and 
+#limitations under the License.
+#++
+require 'rubygems'
+require 'test/unit'
+require 'Dnsruby'
+class TestTcp < Test::Unit::TestCase
+  def test_TCP
+    res = Dnsruby::Resolver.new()
+    res.use_tcp = true
+    ret=res.query("example.com")
+    assert(ret.is_a?(Dnsruby::Message))
+  end
+  def test_TCP_port
+    #@TODO@ Need a test server so we can tell what port this message was actually sent on!
+    res = Dnsruby::Resolver.new()
+    res.use_tcp = true
+    res.src_port=5379
+    ret=res.query("example.com")
+    assert(ret.is_a?(Dnsruby::Message))
+  end
+  #@TODO@ Check stuff like persistent sockets
+end

data/test/tc_tkey.rb

@@ -0,0 +1,106 @@
+#--
+#Copyright 2007 Nominet UK
+#
+#Licensed under the Apache License, Version 2.0 (the "License");
+#you may not use this file except in compliance with the License. 
+#You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0 
+#
+#Unless required by applicable law or agreed to in writing, software 
+#distributed under the License is distributed on an "AS IS" BASIS, 
+#WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
+#See the License for the specific language governing permissions and 
+#limitations under the License.
+#++
+require 'rubygems'
+require 'test/unit'
+require 'dnsruby'
+require "digest/md5"
+class TestTKey < Test::Unit::TestCase
+  def is_empty(string)
+    return (string == "; no data" || string == "; rdlength = 0")
+  end
+  
+  def test_tkey
+    
+    
+    #------------------------------------------------------------------------------
+    # Canned data.
+    #------------------------------------------------------------------------------
+    
+    zone	= "example.com"
+    name	= "123456789-test"
+    klass	= "IN"
+    type	= Dnsruby::Types.TKEY
+    algorithm   = "fake.algorithm.example.com"
+    key         = "fake key"
+    inception   = 100000 # use a strange fixed inception time to give a fixed
+    # checksum
+    expiration  = inception + 24*60*60
+    
+    rr = nil
+    
+    #------------------------------------------------------------------------------
+    # Packet creation.
+    #------------------------------------------------------------------------------
+    
+    rr = Dnsruby::RR.create(
+      :name       => name,
+      :type       => "TKEY",
+      :ttl        => 0,
+      :klass      => "ANY",
+      :algorithm  => algorithm,
+      :inception  => inception,
+      :expiration => expiration,
+      :mode       => 3, # GSSAPI
+      :key        => "fake key",
+      :other_data => ""
+    )
+    
+    packet = Dnsruby::Message.new(name, Dnsruby::Types.TKEY, "IN")
+    packet.add_answer(rr)
+    
+    z = (packet.zone)[0]
+    
+    assert(packet,                                'new() returned packet')  #2
+    assert_equal(Dnsruby::OpCode.QUERY,       packet.header.opcode, 'header opcode correct')  #3 
+    assert_equal(name,                      z.zname.to_s,  'zname correct')          #4
+    assert_equal(Dnsruby::Classes.IN,                       z.zclass, 'zclass correct')         #5
+    assert_equal(Dnsruby::Types.TKEY,                     z.ztype,  'ztype correct')          #6       
+    
+    
+  end
+  
+  def test_tsig
+    
+    name="example.com."
+    key = "1234"
+    print key.to_s + "\n"
+    tsig = Dnsruby::RR.create({
+        :name        => name,
+        :type        => "TSIG",
+        :ttl         => 0,
+        :klass       => "ANY",
+        :algorithm   => "HMAC-MD5.SIG-ALG.REG.INT.",
+        :time_signed => 1189686346,
+        :fudge       => 300,
+        :key         => key,
+        :error       => 0
+      })
+
+
+    message = Dnsruby::Message.new
+    message.header.id=(1234)
+    tsig.apply(message)
+    
+    mac_string = Base64.encode64(message.additional[0].mac)
+    print mac_string + "\n"
+    
+    assert_equal("S8w22c0nlOhC9wNwwHPY7g==", mac_string, "MAC wrong")
+        
+    res = Dnsruby::Resolver.new
+    response = res.send_message(message)
+    print response+"\n"
+  end
+end

data/test/tc_update.rb

@@ -0,0 +1,215 @@
+#--
+#Copyright 2007 Nominet UK
+#
+#Licensed under the Apache License, Version 2.0 (the "License");
+#you may not use this file except in compliance with the License. 
+#You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0 
+#
+#Unless required by applicable law or agreed to in writing, software 
+#distributed under the License is distributed on an "AS IS" BASIS, 
+#WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
+#See the License for the specific language governing permissions and 
+#limitations under the License.
+#++
+require 'rubygems'
+require 'test/unit'
+require 'dnsruby'
+include Dnsruby
+class TestUpdate < Test::Unit::TestCase
+  def is_empty(string)
+    return true if string == nil || string.length == 0
+    
+    return (string == "; no data" || string == "; rdlength = 0");
+  end
+  
+  def test_update
+    #------------------------------------------------------------------------------
+    # Canned data.
+    #------------------------------------------------------------------------------
+    
+    zone	= "example.com";
+    name	= "foo.example.com";
+    klass	= "HS";
+    klass2  = Classes.CH;
+    type	= Types.A;
+    ttl	    = 43200;
+    rdata	= "10.1.2.3";
+    rr      = nil;
+    
+    #------------------------------------------------------------------------------
+    # Packet creation.
+    #------------------------------------------------------------------------------
+    
+    update = Dnsruby::Update.new(zone, klass);
+    z = (update.zone)[0];
+    
+    assert(update,                                'new() returned packet');  #2
+    assert_equal(update.header.opcode, OpCode.UPDATE,      'header opcode correct');  #3 
+    assert_equal(z.zname.to_s,  zone,                      'zname correct');          #4
+    assert_equal(z.zclass.to_s, klass,                     'zclass correct');         #5
+    assert_equal(z.ztype,  Types.SOA,                      'ztype correct');          #6       
+    
+    #------------------------------------------------------------------------------
+    # RRset exists (value-independent).
+    #------------------------------------------------------------------------------
+    
+    rr = update.present(name, type);
+    
+    assert(rr,                                    'yxrrset() returned RR');  #7
+    assert_equal(name,                      rr.name.to_s,  'yxrrset - right name');   #8
+    assert_equal(0,                          rr.ttl,   'yxrrset - right TTL');    #9
+    assert_equal('ANY',                      rr.klass.string, 'yxrrset - right class');  #10
+    assert_equal(type,                      rr.type,  'yxrrset - right type');   #11
+    assert(is_empty(rr.rdata),                "yxrrset - data empty (#{rr.rdata})");   #12
+    
+    rr = nil
+    
+    #------------------------------------------------------------------------------
+    # RRset exists (value-dependent).
+    #------------------------------------------------------------------------------
+    
+    rr = update.present(name, type, rdata, klass);
+    
+    assert(rr,                                    'yxrrset() returned RR');  #13
+    assert_equal(name,                   rr.name.to_s,     'yxrrset - right name');   #14
+    assert_equal(0,                       rr.ttl,      'yxrrset - right TTL');    #15
+    assert_equal(klass,                  rr.klass.string,    'yxrrset - right class');  #16
+    assert_equal(type,                   rr.type,     'yxrrset - right type');   #17
+    assert_equal(rdata,                  rr.rdata, 'yxrrset - right data');   #18
+    
+    rr=nil
+    
+    #------------------------------------------------------------------------------
+    # RRset does not exist.
+    #------------------------------------------------------------------------------
+    
+    rr = update.absent(name, type);
+    
+    assert(rr,                                    'nxrrset() returned RR');  #19
+    assert_equal(name,                      rr.name.to_s,  'nxrrset - right name');   #20
+    assert_equal(0,                          rr.ttl,   'nxrrset - right ttl');    #21
+    assert_equal('NONE',                     rr.klass.string, 'nxrrset - right class');  #22
+    assert_equal(type,                      rr.type,  'nxrrset - right type');   #23
+    assert(is_empty(rr.rdata),                'nxrrset - data empty');   #24
+    
+    rr = nil
+    
+    #------------------------------------------------------------------------------
+    # Name is in use.
+    #------------------------------------------------------------------------------
+    
+    rr = update.present(name);
+    
+    assert(rr,                                    'yxdomain() returned RR'); #25
+    assert_equal(rr.name.to_s,  name,                      'yxdomain - right name');  #26
+    assert_equal(rr.ttl,   0,                          'yxdomain - right ttl');   #27
+    assert_equal(rr.klass.string, 'ANY',                      'yxdomain - right class'); #28
+    assert_equal(rr.type.string,  'ANY',                      'yxdomain - right type');  #29
+    assert(is_empty(rr.rdata),                'yxdomain - data empty');  #30
+    
+    rr = nil
+    
+    #------------------------------------------------------------------------------
+    # Name is not in use. (No Class)
+    #------------------------------------------------------------------------------
+    
+    rr = update.absent(name);
+    
+    assert(rr,                                    'nxdomain() returned RR'); #31
+    assert_equal(rr.name.to_s,  name,                      'nxdomain - right name');  #32
+    assert_equal(rr.ttl,   0,                          'nxdomain - right ttl');   #33
+    assert_equal(rr.klass.string, 'NONE',                     'nxdomain - right class'); #34
+    assert_equal(rr.type.string,  'ANY',                      'nxdomain - right type');  #35
+    assert(is_empty(rr.rdata),                'nxdomain - data empty');  #36
+    
+    rr = nil
+    
+    
+    
+    #------------------------------------------------------------------------------
+    # Add to an RRset.
+    #------------------------------------------------------------------------------
+    
+    rr = update.add(name, type, ttl, rdata);
+    
+    assert(rr,                                    'rr_add() returned RR');   #37
+    assert_equal(rr.name.to_s,     name,                   'rr_add - right name');    #38
+    assert_equal(rr.ttl,      ttl,                    'rr_add - right ttl');     #39
+    assert_equal(rr.klass,    klass,                  'rr_add - right class');   #40
+    assert_equal(rr.type,     type,                   'rr_add - right type');    #41
+    assert_equal(rr.rdata, rdata,                  'rr_add - right data');    #42
+    
+    rr = nil
+    
+    #------------------------------------------------------------------------------
+    # Delete an RRset.
+    #------------------------------------------------------------------------------
+    
+    rr = update.delete(name, type);
+    
+    assert(rr,                                    'rr_del() returned RR');   #43
+    assert_equal(name,                      rr.name.to_s,  'rr_del - right name');    #44
+    assert_equal(0,                          rr.ttl,   'rr_del - right ttl');     #45
+    assert_equal('ANY',                      rr.klass.string, 'rr_del - right class');   #46
+    assert_equal(type,                      rr.type,  'rr_del - right type');    #47
+    assert(is_empty(rr.rdata),                'rr_del - data empty');    #48
+    
+    rr = nil
+    
+    #------------------------------------------------------------------------------
+    # Delete All RRsets From A Name.
+    #------------------------------------------------------------------------------
+    
+    rr = update.delete(name);
+    
+    assert(rr,                                    'rr_del() returned RR');   #49
+    assert_equal(name,                      rr.name.to_s,  'rr_del - right name');    #50
+    assert_equal(0,                          rr.ttl,   'rr_del - right ttl');     #51
+    assert_equal(Classes.ANY,                      rr.klass, 'rr_del - right class');   #52
+    assert_equal(Classes.ANY,                      rr.type,  'rr_del - right type');    #53
+    assert(is_empty(rr.rdata),                'rr_del - data empty');    #54
+    
+    rr = nil
+    
+    #------------------------------------------------------------------------------
+    # Delete An RR From An RRset.
+    #------------------------------------------------------------------------------
+    
+    rr = update.delete(name, type, rdata);
+    
+    assert(rr,                                    'rr_del() returned RR');   #55
+    assert_equal(name,                   rr.name.to_s,     'rr_del - right name');    #56
+    assert_equal(0,                       rr.ttl,      'rr_del - right ttl');     #57
+    assert_equal('NONE',                  rr.klass.string,    'rr_del - right class');   #58
+    assert_equal(type,                   rr.type,     'rr_del - right type');    #59
+    assert_equal(rdata,                  rr.rdata, 'rr_del - right data');    #60
+    
+    rr = nil
+    
+    #------------------------------------------------------------------------------
+    # Make sure RRs in an update packet have the same class as the zone, unless
+    # the class is NONE or ANY.
+    #------------------------------------------------------------------------------
+    
+    update = Dnsruby::Update.new(zone, klass);
+    assert(update,                               'packet created');          #61
+    
+    
+    update.present(name, type, rdata);
+    
+    update.present(name, type, rdata);
+
+    update.present(name, type);
+
+    update.absent(name, type);
+
+    pre = update.pre;
+    
+    assert_equal(3,                     pre.size, 'pushed inserted correctly'); #62
+    assert_equal(klass,              pre[0].klass.string, 'first class right');         #63
+    assert_equal(Classes.ANY,               pre[1].klass, 'third class right');         #65
+    assert_equal(Classes.NONE,              pre[2].klass, 'forth class right');         #66
+  end
+end

data/test/ts_dnsruby.rb

@@ -0,0 +1,17 @@
+#--
+#Copyright 2007 Nominet UK
+#
+#Licensed under the Apache License, Version 2.0 (the "License");
+#you may not use this file except in compliance with the License. 
+#You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0 
+#
+#Unless required by applicable law or agreed to in writing, software 
+#distributed under the License is distributed on an "AS IS" BASIS, 
+#WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
+#See the License for the specific language governing permissions and 
+#limitations under the License.
+#++
+require "test/ts_online.rb"
+require "test/ts_offline.rb"