stella 0.5.4 → 0.5.5

data/support/ruby-pcap-takuma-patch.txt

@@ -1,22 +1,22 @@
-diff -ur pcap-0.6/Pcap.c pcap-working/Pcap.c
---- pcap-0.6/Pcap.c     2008-02-10 19:10:30.000000000 +0900
-+++ pcap-working/Pcap.c 2008-02-10 18:58:49.000000000 +0900
+diff -ur pcap/Pcap.c pcap-modified/Pcap.c
+--- pcap/Pcap.c	2000-08-13 01:56:31.000000000 -0400
++++ pcap-modified/Pcap.c	2009-01-02 10:55:49.000000000 -0500
 @@ -782,9 +782,9 @@
      /* define class PcapStat */
      cPcapStat = rb_funcall(rb_cStruct, rb_intern("new"), 4,
-                           Qnil,
--                          INT2NUM(rb_intern("recv")),
--                          INT2NUM(rb_intern("drop")),
--                          INT2NUM(rb_intern("ifdrop")));
-+                          ID2SYM(rb_intern("recv")),
-+                          ID2SYM(rb_intern("drop")),
-+                          ID2SYM(rb_intern("ifdrop")));
+ 			   Qnil,
+-			   INT2NUM(rb_intern("recv")),
+-			   INT2NUM(rb_intern("drop")),
+-			   INT2NUM(rb_intern("ifdrop")));
++			   ID2SYM(rb_intern("recv")),
++			   ID2SYM(rb_intern("drop")),
++			   ID2SYM(rb_intern("ifdrop")));
      rb_define_const(mPcap, "Stat", cPcapStat);
  
      /* define exception classes */
-diff -ur pcap-0.6/packet.c pcap-working/packet.c
---- pcap-0.6/packet.c   2008-02-10 19:10:30.000000000 +0900
-+++ pcap-working/packet.c       2008-02-10 18:55:13.000000000 +0900
+diff -ur pcap/packet.c pcap-modified/packet.c
+--- pcap/packet.c	2000-08-13 02:56:15.000000000 -0400
++++ pcap-modified/packet.c	2009-01-02 10:56:07.000000000 -0500
 @@ -17,8 +17,8 @@
  
  VALUE cPacket;

data/support/text/en.yaml

@@ -3,6 +3,9 @@
     :fullname: english
     :updated: 2008-12-20
     :enabled: true
+
+:stellaaahhhh: "Stellaaahhhh!"
+
 :text_available_languages: "Available languages: %s"
 
 
@@ -29,21 +32,21 @@
     
     Examples:
      
-      # Run Apache Bench with 50 users, 20 requests each. Repeat 5 times. 
-      $ stella -x 5 -w 0.5 ab -n 1000 -c 50 http://stellaaahhhh.com/
+      # Run Apache Bench with 5 users, 20 requests each. Repeat 5 times. 
+      $ stella -x 5 -w 0.5 ab -n 100 -c 5 http://stellaaahhhh.com/
   
-      # Run Siege with 100 users, 10 requests each with a Linux FireFox 3 user agent
-      $ stella --rampup=25,200 --agent=firefox-3-linux siege -c 100 -r 10 http://stellaaahhhh.com/
+      # Run Siege with 10 users ramping up to 25, 1 requests each with a Linux FireFox 3 user agent
+      $ stella --rampup=5,20 --agent=firefox-3-linux siege -c 10 -r 1 -b http://stellaaahhhh.com/
       
       # Display available user agent strings
       $ stella agents -l
     
-      # Launch a proxy to monitor HTTP traffic. Record requests to a flatfile.
-      $ stella -vv watch -W -p 3114 -r uri.txt
+      # Launch a proxy to monitor HTTP traffic. 
+      $ stella -vv watch -P -p 3114 
       
       # Monitor network traffic with packet sniffer (requires unix and root access)
-      $ stella watch -P dns 
-      $ stella watch -P -p 9000 http
+      $ stella watch -C dns 
+      $ stella watch -C -p 3456 http
         
         
     User-Agent Examples (--agent): 

data/support/text/nl.yaml

@@ -1 +1,7 @@
----
+:info:
+    :language: nl
+    :fullname: nederlands
+    :updated: 2009-01-10
+    :enabled: false
+
+:stellaaahhhh: "Stellaaahhhh!"

data/tests/02-stella-util_test.rb

@@ -0,0 +1,42 @@
+$: << File.dirname(__FILE__)
+require 'spec-helper'
+
+#require 'stella/support'
+
+
+describe "Stella::Util" do
+  
+  before(:all) do
+    load 'stella.rb'
+    load 'stella/cli.rb'
+    Stella.debug = false
+  end
+  
+  it "knows how to convert ff-3.2-osx and ff,3.2,osx into an array" do
+    Stella::Util.expand_str("opera,3.2,linux").should.be.kind_of Array
+    Stella::Util.expand_str("ff,3.2,osx").should.equal %w{ff 3.2 osx}
+    Stella::Util.expand_str("ie-2-win").should.equal %w{ie 2 win}
+  end
+  
+  it "can read and index the useragents.txt file" do
+    ua_index = Stella::Util.process_useragents(File.join(STELLA_HOME, 'support', 'useragents.txt'))
+    ua = Stella::Util.find_agent(ua_index, :ff, 3, :linux)
+    ua.should.be.kind_of String
+    ua.should.match /Firefox\/3/i
+    ua.should.match /linux/i
+  end
+  
+  it "can capture STDOUT and STDERR output from a command" do
+    command = (Stella::SYSINFO.impl == :windows) ? "dir" : "ls"
+    Stella::Util.capture_output("#{command}") do |stdout, stderr|
+       stdout.should.be.instance_of Array
+       stdout.size.should.be > 0
+    end
+  end
+  
+  it "can generate random strings of specified length (29)" do
+    str = Stella::Util.strand(29)
+    str.should.be.kind_of String
+    str.size.should.equal 29
+  end
+end

data/tests/10-stella_test.rb

@@ -0,0 +1,104 @@
+$: << File.dirname(__FILE__)
+require 'spec-helper'
+
+
+describe 'Stella' do
+  before(:all) do
+    require 'stella'
+    Stella.debug = false
+  end
+  
+  it "determine basic system information" do
+    
+    Stella.sysinfo.should.be.instance_of Stella::SystemInfo
+    Stella.sysinfo.uptime.should.be.instance_of Float
+    Stella.sysinfo.uptime.should.be > 0
+    Stella.sysinfo.hostname.should.be.instance_of String
+    Stella.sysinfo.hostname.size.should.be > 0
+    Stella.sysinfo.ipaddress.should.be.instance_of String
+    Stella.sysinfo.ipaddress.size.should.be > 0
+  end
+  
+  it "create a working global logger" do
+    Stella::LOGGER.should.be.instance_of Stella::Logger
+    infos = capture(:stdout) do
+      Stella.info("Stella has a kind heart")
+    end
+    infos.should.be.instance_of String
+    infos.chomp.should.equal "Stella has a kind heart"
+    
+    errors = capture(:stderr) do
+      Stella.error("and loves the unexpected!", "ERROR: ")
+    end
+    errors.should.be.instance_of String
+    errors.chomp.should.equal "ERROR: and loves the unexpected!"
+  end
+
+  #it "have at least one language available" do
+  #  Stella::TEXT.available_language?('en')
+  #end
+  
+  it "provide a convenient text interface" do
+    Stella.text(:stellaaahhhh).should.equal "Stellaaahhhh!"
+  end
+  
+end
+
+
+  
+#describe 'Options' do
+#  include Sinatra::Test
+# 
+#  before do
+#    @app = Class.new(Sinatra::Base)
+#  end
+# 
+#  it 'sets options to literal values' do
+#    @app.set(:foo, 'bar')
+#    @app.should.respond_to? :foo
+#    @app.foo.should.equal 'bar'
+#  end
+#end
+
+#  it 'includes Rack::Utils' do
+#    Sinatra::Base.should.include Rack::Utils
+#  end
+
+__END__
+
+TEST-SPEC NOTES
+
+Test/Unit wrappers:
+
+assert_equal:	should.equal, ==
+assert_not_equal:	should.not.equal, should.not ==
+assert_same:	should.be
+assert_not_same:	should.not.be
+assert_nil:	should.be.nil
+assert_not_nil:	should.not.be.nil
+assert_in_delta:	should.be.close
+assert_match:	should.match, =~
+assert_no_match:	should.not.match, should.not =~
+assert_instance_of:	should.be.an.instance_of
+assert_kind_of:	should.be.a.kind_of
+assert_respond_to:	should.respond_to
+assert_raise:	should.raise
+assert_nothing_raised:	should.not.raise
+assert_throws:	should.throw
+assert_nothing_thrown:	should.not.throw
+assert_block:	should.satisfy
+
+Test/Spec convenience:
+* should.not.satisfy
+* should.include
+* a.should.predicate (works like assert a.predicate?)
+* a.should.be operator (where operator is one of >, >=, <, <= or ===)
+* should.output (require test/spec/should-output)
+
+Messaging/Blaming:
+RUBY_VERSION.should.messaging("Ruby too old.").be > "1.8.4"
+(1 + 1).should.blaming("weird math").not.equal 11
+
+Disable tests with xspecify/xit:
+When you use xspecify/xit, you also can drop the block
+

data/tests/11-stella-storable_test.rb

@@ -0,0 +1,68 @@
+$: << File.dirname(__FILE__)
+require 'spec-helper'
+
+require 'time'
+require 'date'
+require 'stella/storable'
+
+class TeaCup < Stella::Storable
+
+  field :owner => String
+  field :volume => Float
+  field :washed => TrueClass
+  field :last_used => Time
+  
+end
+
+
+describe 'Stella::Storable' do
+  FILE_PATH = File.join(STELLA_HOME, "test-spec-tmp", "tc")
+  RECORD = {
+    :owner => "stella", 
+    :volume => 97.01, 
+    :washed => true, 
+    :last_used => (Time.now-100).utc
+  }
+  
+  before(:all) do
+    FileUtil.create_dir(File.dirname(FILE_PATH), '.')
+  end
+  
+  before(:each) do
+    @generated_files ||= []
+  end
+  
+  after(:each) do
+  end
+  
+  after(:all) do
+    (@generated_files || []).each do |file| 
+      File.unlink(@file) if File.exists?(@file) 
+    end
+  end
+  
+  Stella::Storable::SUPPORTED_FORMATS.each do |format|
+	  next if format == 'json' && !::HAS_JSON
+    it "creates object from hash and saves in #{format} format" do
+      teacup = TeaCup.from_hash(RECORD)
+      path = "#{FILE_PATH}.#{format}"
+      @generated_files << path
+      teacup.to_file(path)
+      File.exists?(path).should.equal true
+    end
+  end
+  
+  Stella::Storable::SUPPORTED_FORMATS.each do |format|
+	  next if format == 'json' && !::HAS_JSON
+    it "loads object from #{format} file" do
+      teacup = TeaCup.from_file("#{FILE_PATH}.#{format}")
+      tchash = teacup.to_hash
+      tchash.should.be.instance_of Hash
+      tchash.keys.should.equal RECORD.keys
+      tchash[:volume].should.equal RECORD[:volume]
+      tchash[:last_used].to_i.should.equal RECORD[:last_used].to_i
+      tchash[:washed].should.equal RECORD[:washed]
+    end
+  end
+  
+end

data/tests/60-stella-command_test.rb

@@ -0,0 +1,248 @@
+$: << File.dirname(__FILE__)
+
+require 'spec-helper'
+require 'stella'
+require 'mongrel'
+require 'uri'
+require 'net/http'
+
+class TestHandler < Mongrel::HttpHandler
+  attr_reader :ran_test
+  attr_accessor :server
+  def process(request, response)
+    @ran_test = true
+    response.start do |head,out|
+      head["Content-Type"] = "text/plain"
+      results = "Stellaaahhhh!#{$/}"
+      results << 'X'*1000 # Pump up the volume (1KB)
+      out << results
+    end
+    
+  end
+end
+
+def get(uri)
+  uri = URI.parse(uri) unless uri.kind_of? URI
+  Net::HTTP.get(uri)
+end
+
+at_exit do
+  @server.stop(true) if @server
+end
+
+describe "Stella::Command::LoadTest" do
+  WORKDIR = File.join(STELLA_HOME, 'test-spec-tmp')
+  HOST = '127.0.0.1'
+  PORT = 3114 + $$ % 1000
+  TVUSERS = 10
+  TCOUNT = 120 # This needs to be divisible evenly by TVUSERS
+  TREPS = 3
+  TMSG = "This is a build test"
+  
+  
+  before(:all) do
+    Stella.debug = false  
+  end
+  
+  
+  after(:all) do
+	  # remove_dir does not seem to work on Windows
+    FileUtils.remove_entry(WORKDIR, true) if File.exists? WORKDIR
+  end
+  
+  it "start a local test server" do
+    begin
+      capture(:stdout) do
+        @server = Mongrel::HttpServer.new(HOST, PORT)
+        @handler = TestHandler.new
+        @server.register("/test", @handler)
+        @server.run
+        res = get("http://#{HOST}:#{PORT}/test")
+        res.should.be.kind_of String
+        res.split($/).first.should.equal "Stellaaahhhh!" # We can ignore the other content
+      end
+    rescue Interrupt
+      @server.stop(true) if @server
+      exit 1
+    end
+    
+  end
+  
+  it "run a local performance test with Apache Bench" do
+    puts 
+    testdef = Stella::Test::Definition.new
+    adapter = Stella::Adapter::ApacheBench.new(["-c", "#{TVUSERS}", "-n", "#{TCOUNT}", "http://#{HOST}:#{PORT}/test"])
+    lt = Stella::LocalTest.new
+    files = %w{ab-percentiles.log ab-requests.log}
+    execute_load_test(lt, testdef, adapter, files)
+    lt.test_stats.transactions_total.should.equal TCOUNT * TREPS
+  end
+  
+  
+  it "run a local performance test with Siege (unix only)" do
+    return if Stella.sysinfo.impl == :windows
+    puts 
+    testdef = Stella::Test::Definition.new
+    adapter = Stella::Adapter::Siege.new(["-c", "#{TVUSERS}", "-r", "#{TCOUNT / TVUSERS}", "--benchmark", "http://#{HOST}:#{PORT}/test"])
+    lt = Stella::LocalTest.new
+    files = %w{siege.log siegerc}
+    execute_load_test(lt, testdef, adapter, files)
+    lt.test_stats.transactions_total.should.equal TCOUNT * TREPS
+  end
+  
+  
+  it "run a local performance test with Httperf (unix only)" do
+    return if Stella.sysinfo.impl == :windows
+    puts 
+    testdef = Stella::Test::Definition.new
+    adapter = Stella::Adapter::Httperf.new(
+      ["--wsess=#{(TCOUNT / TVUSERS).to_i},#{TVUSERS},0", "--rate=#{TCOUNT / TVUSERS}", "--uri=/test", "--server=#{HOST}", "--port=#{PORT}"]
+    )
+    lt = Stella::LocalTest.new
+    files = %w{}
+    execute_load_test(lt, testdef, adapter, files)
+    lt.test_stats.transactions_total.should.equal TCOUNT * TREPS
+  end
+  
+  it "create a symlink to the latest test directory (unix only)" do
+    return if Stella.sysinfo.impl == :windows
+    puts 
+    testdef = Stella::Test::Definition.new
+    adapter = Stella::Adapter::ApacheBench.new(["-c", TVUSERS.to_s, "-n", TCOUNT.to_s, "http://#{HOST}:#{PORT}/test"])
+    lt = Stella::LocalTest.new
+    execute_load_test(lt, testdef, adapter)
+    File.symlink?(lt.test_path_symlink).should.equal true
+    lt.test_stats.transactions_total.should.equal TREPS * TCOUNT
+  end
+  
+  it "run in quiet mode" do
+    puts 
+    testdef = Stella::Test::Definition.new
+    adapter = Stella::Adapter::ApacheBench.new(["-c", TVUSERS.to_s, "-n", TCOUNT.to_s, "http://#{HOST}:#{PORT}/test"])
+    lt = Stella::LocalTest.new
+    lt.quiet = true
+    output = capture(:stdout) do
+      execute_load_test(lt, testdef, adapter)
+    end
+    output.split($/).size.should.equal 2
+    lt.test_stats.transactions_total.should.equal TREPS * TCOUNT
+  end
+  
+  Stella::Storable::SUPPORTED_FORMATS.each do |format|
+	  next if format == 'json' && !HAS_JSON
+    it "create summaries in #{format}" do
+      puts 
+      testdef = Stella::Test::Definition.new
+      adapter = Stella::Adapter::ApacheBench.new(["-c", TVUSERS.to_s, "-n", TCOUNT.to_s, "http://#{HOST}:#{PORT}/test"])
+      lt = Stella::LocalTest.new
+      lt.format = format
+      execute_load_test(lt, testdef, adapter)
+      File.exists?(File.join(lt.test_path, "STATS.#{format}")).should.equal true
+      lt.test_stats.transactions_total.should.equal TREPS * TCOUNT
+    end
+  end
+  
+  it "run with a warmup with a 50% load factor" do
+    puts
+    testdef = Stella::Test::Definition.new
+    adapter = Stella::Adapter::ApacheBench.new(["-c", TVUSERS.to_s, "-n", TCOUNT.to_s, "http://#{HOST}:#{PORT}/test"])
+    lt = Stella::LocalTest.new
+    testdef.warmup = 0.5  # this means half of the number of requests
+    execute_load_test(lt, testdef, adapter)
+    File.exists?(File.join(lt.test_path, "STATS.yaml")).should.equal true
+    
+    summary_file = File.join(lt.test_path, "warmup", "SUMMARY.yaml")
+    File.exists?(summary_file).should.blaming("Summary file").equal true
+    summary = Stella::Test::Run::Summary.from_file(summary_file)
+    summary.transactions.should.blaming("Warmup transaction count").equal(TCOUNT * 0.5)
+    lt.test_stats.transactions_total.should.equal TREPS * TCOUNT
+  end
+  
+  it "run with a rampup" do  
+    puts
+    testdef = Stella::Test::Definition.new
+    adapter = Stella::Adapter::ApacheBench.new(["-c", TVUSERS.to_s, "-n", TCOUNT.to_s, "http://#{HOST}:#{PORT}/test"])
+    lt = Stella::LocalTest.new
+    testdef.rampup = [TVUSERS,TVUSERS*2]
+    execute_load_test(lt, testdef, adapter)
+    File.exists?(File.join(lt.test_path, "STATS.yaml")).should.equal true
+    lt.rampup_test_stats.transactions_total.should.equal TREPS * (TCOUNT) + (TREPS * TCOUNT*2)
+  end
+  
+  xit "accept a sleep period between test runs"
+  xit "run with specified agents"   
+  
+  
+  # +lt+ is an instance of Stella::Command::LoadTest
+  # +adapter+ is a Stella::Adapter object
+  # +files+ (optional) is a list of filenames that should exist in the 
+  # testrun/2009-01-01/run01 directory after a test. When files is empty
+  # we return without running any tests. Note that when adding file names
+  # you don't need to include the standard files (STDOUT.txt, etc...).
+  # Return value is the Stella::Command::LoadTest instance
+  def execute_load_test(lt, testdef, adapter, files=nil)
+    testdef.message = TMSG
+    testdef.repetitions = TREPS
+    
+    lt.working_directory = WORKDIR
+    lt.adapter = adapter
+    lt.testdef = testdef
+    
+    files.push(%w{COMMAND.txt STDERR.txt STDOUT.txt}).flatten! unless files.nil?
+    
+    begin
+      
+      lt.run
+      
+      lt.test_stats.should.be.instance_of Stella::Test::Stats
+      
+      %w{
+        elapsed_time_avg throughput_avg response_time_avg 
+        response_time_avg transaction_rate_avg vusers_avg
+        data_transferred_total transactions_total elapsed_time_total
+      }.each do |field|
+        lt.test_stats.send(field).should.blaming("Field: #{field}").be > 0
+      end
+      
+      %w{
+        elapsed_time_sdev throughput_sdev transaction_rate_sdev
+        vusers_sdev response_time_sdev
+      }.each do |field|
+        lt.test_stats.send(field).should.blaming("Field: #{field}").be >= 0
+      end
+
+      total_check = lt.test_stats.failed_total + lt.test_stats.successful_total
+      total = lt.test_stats.transactions_total
+      
+      total.should.blaming("Successful and Failed transaction count").equal total_check
+      lt.test_stats.availability.should.blaming("Field: availability").equal 100
+      
+      unless files.nil? 
+        # The test directory was created
+        File.exists?(lt.test_path).should.equal true
+
+        # The message was recorded
+        msg_path = File.join(lt.test_path, "MESSAGE.txt")
+        File.exists?(msg_path).should.equal true
+        File.read(msg_path).chomp.should.equal TMSG
+
+        # And all run output files were created
+        runnum = "00"
+        TREPS.times do
+          runnum = runnum.succ
+          files.each do |file|
+            file_short = File.join("run#{runnum}", file)
+            file_path = File.join(lt.test_path, file_short)
+            File.exists?(file_path).should.blaming("Cannot find: #{file_short}").equal true
+          end
+        end
+      end
+      
+    rescue Interrupt
+      @server.stop(true) if @server
+    end
+    
+    lt
+  end
+end
+

data/tests/80-stella-cli_test.rb

@@ -0,0 +1,45 @@
+$: << File.dirname(__FILE__)
+require 'spec-helper'
+
+#require 'stella/cli'
+
+describe "Stella::CLI" do
+  
+  before(:all) do
+    Stella.debug = false
+  end
+  
+  before(:each) do
+    ARGV.clear
+  end
+
+  it "auto-require CLI classes" do
+    cli_count = Dir.glob(File.join(STELLA_HOME, 'lib', 'stella', 'cli', "*.rb")).size - 1 # Minus base class 
+    app = Stella::CLI.new(ARGV, STDIN)
+    app.commands.size.should.be >= cli_count  # There can be multiple command aliases per class
+  end
+  
+  xit "process STDIN"
+  
+  it "split ARGV into global options, command name, and command-specific arguments" do
+    ARGV.push *%w{ -vv sysinfo -h --list localhost}
+    app = Stella::CLI.new(ARGV, STDIN)
+    app.should.be.kind_of Stella::CLI
+    app.options.verbose.should.equal 2
+    app.command_name.should.equal "sysinfo"
+    app.command_arguments.size.should.equal 3
+  end
+  
+  it "run command and write to STDOUT" do
+    ARGV << "lang"
+    words = capture(:stdout) do
+      app = Stella::CLI.new(ARGV, STDIN)
+      app.should.be.kind_of Stella::CLI
+      app.command_name.should.equal "lang"
+      app.run
+    end
+    words.should.be.kind_of String
+    words.should.match "Available languages"
+  end
+  
+end

data/tests/spec-helper.rb

@@ -0,0 +1,31 @@
+
+require 'rubygems'
+require 'test/spec'
+require 'fileutils'
+
+unless defined? STELLA_HOME
+  STELLA_HOME = File.expand_path(File.join(File.dirname(__FILE__), '..')) 
+  $:.unshift(File.join(STELLA_HOME, 'lib')) # Make sure our local lib is first in line
+end
+
+# Stolen from http://github.com/wycats/thor
+def capture(stream)
+  begin
+    stream = stream.to_s
+    eval "$#{stream} = StringIO.new"
+    yield
+    result = eval("$#{stream}").string
+  ensure
+    eval("$#{stream} = #{stream.upcase}")
+  end
+
+  result
+end
+
+begin
+	require 'json'
+rescue LoadError
+	::HAS_JSON = false
+else
+	::HAS_JSON = true
+end

data/vendor/{frylock/README.textile → drydock/LICENSE.txt}

@@ -1,54 +1,4 @@
-h1. Frylock - Easy Command line apps
-
-Inspired by "github-gem":http://github.com/defunkt/github-gem
-
-*Install:*
-
-gem install bmizerany-sinatra
-
-*Example:*
-
-Let's say we want to run our app like this:
-
-<pre><code>ruby script.rb hello</pre></code>
-
-Then we write this:
-
-<pre><code>require 'rubygems'
-require 'bmizerany-frylock'
-
-command :hello do
-  puts "Hello!"
-end</pre></code>
-
-If we want and optional name:
-
-<pre><code>ruby script.rb hello Blake</pre></code>
-
-Add a command with proc that has an arity of 1 and it will be matched instead of the first command
-
-<pre><code>require 'rubygems'
-require 'bmizerany-frylock'
-
-command :hello do
-  puts "Hello!"
-end
-
-command :hello do |name|
-  puts "Hello #{name}!"
-end</pre></code>
-
-
-For further examples see: bin/example
-
-
-*Contribute:*
-
-I'm very open to patches!  Please fork and send a pull request.
-
-*LICENSE*
-
-Copyright (c) 2008 Blake Mizerany
+Copyright (c) 2008 Delano Mandelbaum
 
 Permission is hereby granted, free of charge, to any person
 obtaining a copy of this software and associated documentation
@@ -69,4 +19,4 @@ 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.
+OTHER DEALINGS IN THE SOFTWARE.