ttcp 1.0.0

data/.gitignore

@@ -0,0 +1,13 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+
+# mac noise
+.DS_Store
+
+# ruby mine noise
+.idea/
+
+# ignore ci_reporter output from rspec tests:
+spec/reports

data/.jrubyrc

@@ -0,0 +1 @@
+compat.version=1.9

data/Gemfile

@@ -0,0 +1,10 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in ttcp-rb.gemspec
+gemspec
+
+# optional dependencies (not included in gemspec):
+group :development, :test do
+  gem 'guard'
+  gem 'guard-rspec'
+end

data/Guardfile

@@ -0,0 +1,9 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+guard :rspec, :cli => '--color --format doc' do
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/lib/#{m[1]}_spec.rb" }
+  watch(%r{^spec/.+_spec\.rb$})
+  watch('spec/spec_helper.rb')      { "spec" }
+end
+

data/LICENSE

@@ -0,0 +1,8 @@
+Copyright (c) 2012 Matthew Connolly
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+

data/README.md

@@ -0,0 +1,69 @@
+# ttcp (Test TCP) - Benchmarking Tool and Simple Network Traffic Generator
+
+This is a ruby version of the original C ttcp program.
+
+This tool aims to be a drop in replacement for the original C version, with interoperable networking and command line options. ie: you can have the C and ruby versions talk to each other.
+
+http://www.pcausa.com/Utilities/pcattcp.htm
+
+## Installation
+
+Run `$ gem install ttcp`.
+
+## Usage
+
+Similar to the original TTCP program, run a receiver on one machine and a transmitter on another, in that order:
+```machine1$ ttcp -r [-p <port>]
+```
+
+And:
+```machine2$ ttcp -t <machine1_ip_address> [-p port]
+```
+
+For more command line options run:
+```machine1$ ttcp --help
+```
+
+## Dependencies
+
+Runtime dependencies:
+
+* only ruby std libraries
+
+Development dependencies:
+
+* bundler
+* rake
+* rpsec
+* ci_reporter (for use with jenkins)
+
+Optionally:
+
+* guard
+* guard-rspec
+
+## Compatibility
+
+* MRI ruby 1.8.7
+* MRI ruby 1.9.2
+* JRuby (tested in 1.9 compatibility mode)
+
+## Contributing
+
+1. Fork
+2. Install dependencies by running `$ bundle install`
+3. Write tests and code
+4. Make sure the tests pass by running `$ rake test`
+5. Push and send a pull request on GitHub
+
+## Known issues
+
+* Tests don't seem to run in JRuby 1.6.5, but the TTCP program works itself.
+
+## Credits
+
+Special thanks to the Mike Muuss and Terry Slattery and other contributors of the original TTCP program.
+
+## Copyright
+
+Copyright © 2012 Matt Connolly. Released under the MIT license. See LICENSE.

data/Rakefile

@@ -0,0 +1,8 @@
+require "bundler/gem_tasks"
+
+require 'rspec/core/rake_task'
+require 'ci/reporter/rake/rspec'
+
+RSpec::Core::RakeTask.new(:test => ["ci:setup:rspec"]) do |t|
+  t.pattern = '**/*_spec.rb'
+end

data/bin/ttcp

@@ -0,0 +1,138 @@
+#!/usr/bin/env ruby
+#
+# ttcp
+# ©2012 Matt Connolly
+#
+# This is a ruby implementation of the TTCP network test program.
+#
+
+
+
+require 'optparse'
+require File.expand_path('../lib/ttcp', File.dirname(__FILE__))
+
+=begin
+Usage: ttcp -t [-options] host [ < in ]\n\
+ttcp -r [-options > out]\n\
+Common options:\n\
+-l ##	length of bufs read from or written to network (default 8192)\n\
+-u	use UDP instead of TCP\n\
+-p ##	port number to send to or listen at (default 5001)\n\
+-s	-t: source a pattern to network\n\
+-r: sink (discard) all data from network\n\
+-A	align the start of buffers to this modulus (default 16384)\n\
+-O	start buffers at this offset from the modulus (default 0)\n\
+-v	verbose: print more statistics\n\
+-d	set SO_DEBUG socket option\n\
+-b ##	set socket buffer size (if supported)\n\
+-f X	format for rate: k,K = kilo{bit,byte}; m,M = mega; g,G = giga\n\
+Options specific to -t:\n\
+-n##	number of source bufs written to network (default 2048)\n\
+-D	don't buffer TCP writes (sets TCP_NODELAY socket option)\n\
+Options specific to -r:\n\
+-B	for -s, only output full blocks as specified by -l (for TAR)\n\
+-T	\"touch\": access each byte as it's read\n\
+=end
+
+#
+# defaults:
+#
+
+options = TTCP::TTCP.default_options
+
+optparse = OptionParser.new do |opts|
+  opts.banner = <<END
+Usage: ttcp.rb -t [options] host [ < in ]
+       ttcp.rb -r [options > out]
+END
+
+  opts.separator "Must choose one of:"
+  opts.on('-t', '--transmit', "Transmit data to another TTCP program") do
+    options[:transmit] = true
+  end
+
+  opts.on('-r', '--receive',  "Receive data from another TTCP program") do
+    options[:receive] = true
+  end
+
+  opts.separator ""
+  opts.separator "Other options:"
+  opts.on('-l', '--length NUM', "Length of bufs read from or written to network (default #{options[:length]})") do |length|
+    options[:length] = length.to_i if length.to_i > 0
+  end
+
+  opts.on('-u', '--udp', 'Use UDP instead of default TCP') do
+    options[:udp] = true
+    options[:tcp] = false
+  end
+
+
+  opts.on('-s', '--sink',
+          "When transmitting, source pattern to network.",
+          "When receiving, discard all incoming data") do
+    options[:sink] = !options[:sink]
+  end
+
+  opts.on('-p', '--port PORT', "Receive on port PORT / Transmit to remote port PORT") do |port|
+    options[:port] = port.to_i if port.to_i > 0
+  end
+
+  opts.on('-f', '--format F', "Format: K = K bytes, M = M bytes, G = G Bytes, k = K bits, m = M bits, g = G bits. Default = K") do |fmt|
+    options[:format] = fmt
+  end
+
+  opts.on('-v', '--verbose', "Verbose output") { options[:verbose] = true }
+  opts.on('-T', '--touch', "Touch (access) all incoming data") { options[:touch] = true }
+
+  opts.on('--version', "Output the version of TTCP") do
+    puts TTCP::VERSION
+    exit(0)
+  end
+
+  opts.on('-n', '--numbufs NUM', "Set number of buffers to send / receive (default = #{options[:num_buffers]})") do |num|
+    options[:num_buffers] = num.to_i if num.to_i > 0
+  end
+
+  opts.on_tail("-h", "--help", "Show this message") do
+    puts opts
+    exit(0)
+  end
+
+
+
+end
+
+
+begin
+  optparse.parse!
+
+  if options[:transmit]
+    #we require one argument: the host to connect to.
+    if ARGV.length < 1
+      raise "Transmit option requires a command line argument specifying the host to connect and transmit to."
+    end
+    options[:host] = ARGV[0]
+  end
+
+  unless options[:transmit] || options[:receive]
+    raise "You must select either transmit or receive option"
+  end
+
+  if options[:transmit] && options[:receive]
+    raise "You cannot select both transmit and receive options."
+  end
+
+rescue SystemExit
+  # let it go through, we've been told to exit
+  raise
+rescue Exception => x
+  $stderr.puts optparse
+  $stderr.puts x
+  exit(1)
+end
+
+exit(0) if ENV['DRY_RUN']
+
+ttcp = TTCP::TTCP.new options
+ttcp.run
+

data/lib/ttcp.rb

@@ -0,0 +1,321 @@
+require File.expand_path("ttcp/version", File.dirname(__FILE__))
+require 'socket'
+
+module TTCP
+
+  DEFAULT_OPTIONS = {
+      :transmit => false,
+      :receive => false,
+      :length => 8192,
+      :udp => false,
+      :tcp => true,
+      :port => 5001,
+      :verbose => false,
+      :socket_debug => false,
+      :format_rate => 'm',
+      :num_buffers => 2048,
+      :touch => false,
+      :sink => true,
+      :format => 'K',
+  }
+
+  def default_options
+    DEFAULT_OPTIONS
+  end
+
+
+  class TTCP
+
+    attr_reader :options
+    attr_reader :bytes_received
+    attr_accessor :stdout, :stderr
+
+    def self.default_options
+      DEFAULT_OPTIONS
+    end
+
+    #
+    # Create a TTCP test program instance. All configuration is done via the
+    # options hash passed in here.
+    #
+    def initialize(options = {})
+      @options = TTCP.default_options.merge options
+
+      if @options[:udp]
+        # enforce buffer length to be more than udp sentinel size.
+        @options[:length] = [@options[:length], 5].max
+      end
+
+      @bytes_received = 0
+
+      # by default, use the stdout and stderr.
+      @stdout = $stdout
+      @stderr = $stderr
+
+    end
+
+    #
+    # Run the TTCP test program according to the options specified with the .new call
+    #
+    def run
+      begin
+        num_bytes = 0
+        num_calls = 0
+
+        if @options[:transmit]
+          message "buflen=%d, nbuf=%d, remote port=%d" % [@options[:length], @options[:num_buffers], @options[:port]]
+
+          buf = source_buffer
+
+          @start_time = Time.now
+          @start_cpu_time = get_cpu_time
+
+          socket.write "ttcp" if @options[:udp]
+          @options[:num_buffers].times do
+            socket.write buf
+            num_bytes += buf.length
+            num_calls += 1
+          end
+          socket.write "ttcp" if @options[:udp]
+
+        elsif @options[:receive]
+          message "buflen=%d, nbuf=%d, local port=%d" % [@options[:length], @options[:num_buffers], @options[:port]]
+
+          receiving = true
+          sentinel_count = 0
+
+          if @options[:tcp]
+            receiving_socket = socket.accept
+            remote_address =
+                if receiving_socket.respond_to? :remote_address
+                  "#{receiving_socket.remote_address.ip_address}:#{receiving_socket.remote_address.ip_port}"
+                elsif receiving_socket.respond_to? :peeraddr # this is what JRuby 1.6.5 has instead
+                  "#{receiving_socket.peeraddr[2]}:#{receiving_socket.peeraddr[1]}"
+                else
+                  "<Unknown>"
+                end
+            message("accept from #{remote_address}")
+          else
+            receiving_socket = socket
+          end
+
+          @start_time = Time.now
+          @start_cpu_time = get_cpu_time
+
+          while receiving
+
+            buf = receiving_socket.recv @options[:length]
+            num_bytes += buf.length unless buf.nil?
+            num_calls += 1
+
+            if buf.nil? || (@options[:tcp] && buf.length == 0)
+              receiving = false
+            else
+              if @options[:udp]
+                if buf.length <= 4
+                  sentinel_count += 1
+                  if sentinel_count >= 2
+                    receiving = false
+                  end
+                else
+                  sink buf
+                  touch buf if @options[:touch]
+                  @bytes_received += buf.length
+                end
+              end
+            end
+          end
+
+          if @options[:tcp]
+            receiving_socket.close unless receiving_socket.closed?
+            receiving_socket = nil
+          end
+
+        end
+
+      ensure
+        @finish_time = Time.now
+        @finish_cpu_time = get_cpu_time
+        close
+      end
+
+      message("%d bytes in %.3f real seconds = %s/sec +++" % [num_bytes, duration, format_rate(num_bytes, duration)])
+
+    end
+
+
+    def duration
+      @finish_time - @start_time if @finish_time
+    end
+
+    def cpu_duration
+      @finish_cpu_time - @start_cpu_time if @finish_cpu_time
+    end
+
+    #
+    # close any sockets
+    #
+    def close
+      unless @socket.nil?
+        begin
+          @socket.shutdown Socket::SHUT_RDWR
+        rescue
+          # ignore any errors closing the socket
+        ensure
+          @socket = nil
+        end
+      end
+    end
+
+
+    #
+    # set the stdout to point to nothing
+    #
+    def stdout_to_null
+      @stdout = File.open("/dev/null", "w")
+      @stderr = File.open("/dev/null", "w")
+    end
+
+    private
+
+    # get the socket to be used for this ttcp run
+    def socket
+
+      if @socket.nil?
+
+        state = "socket"
+
+        begin
+          if @options[:transmit]
+
+            raise "Host not specified" unless @options[:host]
+
+            # create a socket to transmit to
+            if @options[:udp]
+              @socket = UDPSocket.new
+              message("socket")
+              state = "connect"
+              @socket.connect(@options[:host], @options[:port])
+              message("connect")
+            else
+              @socket = TCPSocket.new(@options[:host], @options[:port])
+              message("socket")
+              message("connect")
+            end
+
+          elsif @options[:receive]
+
+            # create a socket to receive from
+            if @options[:udp]
+              @socket = UDPSocket.new
+              message("socket")
+              state = "bind"
+              @socket.bind(@options[:host], @options[:port])
+              message("bind")
+            else
+              # create a TCPServer object
+              args = []
+              args << @options[:host] if @options[:host]
+              args << @options[:port]
+              @socket = TCPServer.new *args
+              message("socket")
+              state = "listen"
+              @socket.listen 0
+              message("listen")
+            end
+
+          else
+            raise "TTCP must be configured to transmit or receive"
+          end
+
+        rescue Exception => e
+          error(state, e)
+        end
+      end
+
+      @socket
+    end
+
+
+
+    def source_buffer
+      if @options[:sink]
+        # source for sink is random data
+        if RUBY_VERSION >= "1.9"
+          Random.new.bytes @options[:length]
+        else
+          source = ""
+          @options[:length].times { source << rand(255) }
+          source
+        end
+      else
+        # source for buffer is stdin
+        $stdin.read @options[:length]
+      end
+    end
+
+
+    #
+    # send the received buffer to the appropriate place:stdout or the sink (null)
+    def sink(buffer)
+      if @options[:sink]
+        #nothing, the sink
+      else
+        puts buffer
+      end
+    end
+
+
+    #
+    # read all the data in the buffer
+    #
+    def touch(buffer)
+      sum = 0
+      buffer.each_byte { |x| sum += x }
+    end
+
+
+    #
+    # print output, like the `mes()` function in the original C ttcp program.
+    #
+    def message(str)
+      mode = @options[:transmit] ? "t" : "r"
+      @stdout.puts "ttcp-#{mode}: #{str}"
+    end
+
+    #
+    # print output to stderr, like the `err()` function in the original C ttcp program.
+    # instead of exiting, raise an exception and let the caller exit. If no exception is passed,
+    # the error message is raised.
+    def error(str, exception=nil)
+      mode = @options[:transmit] ? "t" : "r"
+      @stderr.puts "ttcp-#{mode}: #{str}"
+      raise exception || str
+    end
+
+    # return combined user and system cpu time used by this process so far.
+    def get_cpu_time
+      tms = Process.times
+      tms.utime + tms.stime
+    end
+
+
+    UNIT_FACTOR = {
+        :k => [8 * 1024,    'Kbit'],
+        :m => [8 * 1024**2, 'Mbit'],
+        :g => [8 * 1024**3, 'Gbit'],
+        :K => [1024,        'K'],
+        :M => [1024**2,     'M'],
+        :G => [1024**3,     'G']
+    }
+
+    # genrate a string representation of the date, according to the @options[:format] setting
+    def format_rate(bytes, duration)
+      d = [0.001, duration].max
+      rate = bytes / d
+      factor, unit = UNIT_FACTOR[@options[:format].to_sym]
+      rate /= factor
+      "%0.3f %s" % [rate, unit]
+    end
+  end
+end

data/lib/ttcp/version.rb

@@ -0,0 +1,3 @@
+module TTCP
+  VERSION = "1.0.0"
+end

data/spec/spec_helper.rb

@@ -0,0 +1,48 @@
+require 'ttcp'
+require 'ttcp/version'
+require 'socket'
+
+
+class Class
+  def publicize_methods
+    saved_private_instance_methods = self.private_instance_methods
+    self.class_eval { public *saved_private_instance_methods }
+    yield
+    self.class_eval { private *saved_private_instance_methods }
+  end
+end
+
+
+class ThreadSocket
+
+  attr_reader :socket
+
+  def initialize(&block)
+    @thread = Thread.new do
+      begin
+        @socket = nil
+        instance_eval(&block)
+      rescue Exception => x
+        puts "Exception in ThreadSocket: #{x}"
+      ensure
+        begin
+          @socket.shutdown(Socket::SHUT_RDWR) if @socket && @socket.is_a?(BasicSocket)
+        rescue
+          # ignore errors shutting down the socket
+        end
+        @socket = nil
+      end
+    end
+  end
+
+  # forward not implemented method calls to the thread
+  def method_missing(method_name, *args, &block)
+    if @thread && @thread.respond_to?(method_name)
+      @thread.__send__(method_name, *args, &block)
+    else
+      super(method_name, *args, &block)
+    end
+  end
+
+
+end

data/spec/ttcp_options_spec.rb

@@ -0,0 +1,42 @@
+require "rspec"
+require 'spec_helper.rb'
+
+TTCP_EXECUTABLE = File.expand_path('../../bin/ttcp', __FILE__)
+
+
+def test_ttcp(options = '')
+  `DRY_RUN=YES #{TTCP_EXECUTABLE} #{options} 2>&1`
+end
+
+describe "Command Line Option Parsing" do
+
+  it "ttcp fails without -t or -r" do
+    test_ttcp
+    $?.should_not == 0
+  end
+
+  it "ttcp fails with both -t and -r" do
+    test_ttcp '-t -r'
+    $?.should_not == 0
+  end
+
+  it "ttcp fails without a host with -t" do
+    test_ttcp '-t'
+    $?.should_not == 0
+  end
+
+  it "ttcp is ok with a host and -t" do
+    test_ttcp '-t HOST'
+    $?.should == 0
+  end
+
+  it "ttcp is ok with -r and no host" do
+    test_ttcp '-r'
+    $?.should == 0
+  end
+
+  specify "ttcp prints out the version" do
+    version = test_ttcp '--version'
+    version.chomp.should == TTCP::VERSION
+  end
+end

data/spec/ttcp_spec.rb

@@ -0,0 +1,219 @@
+require "rspec"
+require 'spec_helper'
+require "stringio"
+
+
+describe "TTCP Sockets" do
+
+  after() do
+    # ensure the ttcp instance is closed and destroyed
+    if @ttcp.is_a? TTCP::TTCP
+      @ttcp.close
+    end
+    @ttcp = nil
+  end
+
+  ##
+  ## Setting up ttcp socket
+  ##
+
+  specify "ttcp in transmit tcp makes a tcp socket" do
+    @ttcp = TTCP::TTCP.new :transmit => true, :tcp => true, :host => 'www.google.com', :port => 80
+    @ttcp.stdout_to_null
+    TTCP::TTCP.publicize_methods do
+      @ttcp.socket.should be_a(TCPSocket)
+    end
+  end
+
+  specify "ttcp in transmit udp makes a udp socket" do
+    @ttcp = TTCP::TTCP.new :transmit => true, :tcp => false, :udp => true, :host => 'localhost'
+    @ttcp.stdout_to_null
+    TTCP::TTCP.publicize_methods do
+      @ttcp.socket.should be_a(UDPSocket)
+    end
+  end
+
+  specify "ttcp in receive tcp makes a tcp socket" do
+    @ttcp = TTCP::TTCP.new :receive => true, :tcp => true, :host => 'localhost'
+    @ttcp.stdout_to_null
+    TTCP::TTCP.publicize_methods do
+      @ttcp.socket.should be_a(TCPSocket)
+    end
+  end
+
+  specify "ttcp in receive udp makes a udp socket" do
+    @ttcp = TTCP::TTCP.new :receive => true, :tcp => false, :udp => true, :host => 'localhost'
+    @ttcp.stdout_to_null
+    TTCP::TTCP.publicize_methods do
+      @ttcp.socket.should be_a(UDPSocket)
+    end
+  end
+
+  specify "ttcp in udp has a minimum buffer length greater than 4" do
+    @ttcp = TTCP::TTCP.new :transmit => true, :udp => true, :host => 'localhost', :length => 3
+    @ttcp.stdout_to_null
+    @ttcp.options[:length].should > 4
+  end
+
+  specify "ttcp without options raises exception because neither transmit nor receive is specified" do
+    lambda do
+      @ttcp = TTCP::TTCP.new
+      @ttcp.stdout_to_null
+      @ttcp.socket
+    end.should raise_error
+  end
+end
+
+
+describe "TTCP Transmitting" do
+
+  TEST_PORT = 5003
+
+  specify "TTCP transmit over TCP to no server fails" do
+    @ttcp = TTCP::TTCP.new :transmit => true, :tcp => true, :host => 'localhost', :port => TEST_PORT+1
+    @ttcp.stdout_to_null
+    lambda { @ttcp.run }.should raise_error
+  end
+
+  specify "TTCP transmits over TCP, closing the connection when it's done" do
+
+    thread = ThreadSocket.new do
+      TCPServer.open TEST_PORT do |server|
+        @socket = server.accept
+        until @socket.eof?
+          @socket.read 1000
+        end
+      end
+    end
+
+    sleep(0.2)
+
+    thread.alive?.should be_true
+    thread.socket.should be_nil
+
+    @ttcp = TTCP::TTCP.new :transmit => true, :tcp => true, :host => 'localhost', :port => TEST_PORT
+    @ttcp.stdout_to_null
+    lambda { @ttcp.run }.should_not raise_error
+    @ttcp.duration.should_not be_nil
+    @ttcp.duration.should > 0
+
+    thread.join
+
+    # connection has closed in server
+    thread.socket.should be_nil
+
+    # thread should have finished
+    thread.alive?.should be_false
+  end
+
+
+  specify "TTCP transmit over UDP" do
+
+    thread = ThreadSocket.new do
+      @socket = UDPSocket.new
+      @socket.bind('localhost', TEST_PORT)
+      sentinel_count = 0
+      until sentinel_count >= 2
+        b = @socket.recv 2000
+        sentinel_count += 1 if b.length <= 4
+      end
+    end
+
+    sleep(0.2)
+
+    thread.alive?.should be_true
+    thread.socket.should_not be_nil
+
+    @ttcp = TTCP::TTCP.new :transmit => true, :tcp => false, :udp => true, :host => 'localhost', :port => TEST_PORT
+    @ttcp.stdout_to_null
+    lambda { @ttcp.run }.should_not raise_error
+    @ttcp.duration.should_not be_nil
+    @ttcp.duration.should > 0
+
+    thread.join
+
+    # connection has closed in server
+    thread.socket.should be_nil
+
+    # thread should have finished
+    thread.alive?.should be_false
+  end
+
+  specify "TTCP receives over TCP from another TTCP sending to TCP" do
+
+    thread = Thread.new do
+
+      sleep 0.3
+
+      ttcp2 = TTCP::TTCP.new :transmit => true, :tcp => true, :host => 'localhost', :port =>TEST_PORT
+      ttcp2.stdout_to_null
+      ttcp2.run
+
+    end
+
+    sleep 0.1
+
+    thread.alive?.should be_true
+
+    @ttcp = TTCP::TTCP.new :receive=> true, :tcp => true, :host => 'localhost', :port =>TEST_PORT
+    @ttcp.stdout_to_null
+    @ttcp.run
+
+    @ttcp.duration.should_not be_nil
+    @ttcp.duration.should > 0
+
+    thread.join
+    thread.alive?.should be_false
+  end
+
+
+  specify "TTCP receives over UDP from another TTCP sending to UDP" do
+
+    thread = Thread.new do
+
+      sleep 0.3
+
+      ttcp2 = TTCP::TTCP.new :transmit => true, :tcp => false, :udp => true, :host => 'localhost', :port =>TEST_PORT
+      ttcp2.stdout_to_null
+      ttcp2.run
+
+    end
+
+    sleep 0.1
+
+    thread.alive?.should be_true
+
+    @ttcp = TTCP::TTCP.new :receive=> true, :tcp => false, :udp => true, :host => 'localhost', :port =>TEST_PORT
+    @ttcp.stdout_to_null
+    @ttcp.run
+
+    @ttcp.duration.should_not be_nil
+    @ttcp.duration.should > 0
+
+    thread.join
+    thread.alive?.should be_false
+  end
+
+
+end
+
+describe "Output formatting" do
+
+  [
+      [ 'Kilobytes', 'K', 1.5*1024, 2.0, "0.750 K" ],
+      [ 'Kilobits', 'k', 16*1024, 2.0, "1.000 Kbit" ],
+      [ 'Megabytes', 'M', 1.5*1024**2, 2.0, "0.750 M" ],
+      [ 'Gigabytes', 'G', 4.5*1024**3, 2.0, "2.250 G" ],
+      [ 'Megabits', 'm', 16*1024**2, 2.0, "1.000 Mbit" ],
+      [ 'Gigabits', 'g', 16*1024**3, 2.0, "1.000 Gbit" ]
+  ].each do |spec|
+
+    it "Calculates #{spec[0]} / sec correctly" do
+      @ttcp = TTCP::TTCP.new :format => spec[1]
+      result = @ttcp.instance_eval { format_rate(spec[2], spec[3]) }
+      result.should == spec[4]
+    end
+  end
+
+
+end

data/ttcp.gemspec

@@ -0,0 +1,27 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "ttcp/version"
+
+Gem::Specification.new do |s|
+  s.name        = "ttcp"
+  s.version     = TTCP::VERSION
+  s.authors     = ["Matt Connolly"]
+  s.email       = ["matt@soundevolution.com.au"]
+  s.homepage    = ""
+  s.summary     = %q{A ruby implementation of the TTCP network test program.}
+  s.description = %q{Based on the C command line tool at http://www.pcausa.com/Utilities/pcattcp.htm}
+
+  s.rubyforge_project = "ttcp-rb"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  # specify any dependencies here; for example:
+  s.add_development_dependency "bundler"
+  s.add_development_dependency "rake"
+  s.add_development_dependency "rspec"
+  s.add_development_dependency "ci_reporter"
+  # s.add_runtime_dependency "rest-client"
+end

metadata

@@ -0,0 +1,108 @@
+--- !ruby/object:Gem::Specification
+name: ttcp
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+  prerelease: 
+platform: ruby
+authors:
+- Matt Connolly
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-02-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: &70279976951600 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70279976951600
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &70279976951160 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70279976951160
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &70279976950640 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70279976950640
+- !ruby/object:Gem::Dependency
+  name: ci_reporter
+  requirement: &70279984658600 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70279984658600
+description: Based on the C command line tool at http://www.pcausa.com/Utilities/pcattcp.htm
+email:
+- matt@soundevolution.com.au
+executables:
+- ttcp
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .jrubyrc
+- Gemfile
+- Guardfile
+- LICENSE
+- README.md
+- Rakefile
+- bin/ttcp
+- lib/ttcp.rb
+- lib/ttcp/version.rb
+- spec/spec_helper.rb
+- spec/ttcp_options_spec.rb
+- spec/ttcp_spec.rb
+- ttcp.gemspec
+homepage: ''
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: ttcp-rb
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: A ruby implementation of the TTCP network test program.
+test_files:
+- spec/spec_helper.rb
+- spec/ttcp_options_spec.rb
+- spec/ttcp_spec.rb
+has_rdoc: