curb 0.5.8.0-x86-darwin-10

data/lib/curl.rb

@@ -0,0 +1,2 @@
+require 'curb'
+

data/tests/alltests.rb

@@ -0,0 +1,3 @@
+$: << $TESTDIR = File.expand_path(File.dirname(__FILE__))
+require 'unittests'
+Dir[File.join($TESTDIR, 'bug_*.rb')].each { |lib| require lib }

data/tests/bug_curb_easy_blocks_ruby_threads.rb

@@ -0,0 +1,52 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'helper'))
+require 'webrick'
+class ::WEBrick::HTTPServer ; def access_log(config, req, res) ; end ; end
+class ::WEBrick::BasicLog ; def log(level, data) ; end ; end
+
+class BugTestInstancePostDiffersFromClassPost < Test::Unit::TestCase
+  def test_bug
+    server = WEBrick::HTTPServer.new( :Port => 9999 )
+    server.mount_proc("/test") do|req,res|
+      sleep 0.5
+      res.body = "hi"
+      res['Content-Type'] = "text/html"
+    end
+
+    thread = Thread.new(server) do|srv|
+      srv.start
+    end
+
+    threads = []
+    timer = Time.now
+
+    5.times do |i|
+      t = Thread.new do
+        c = Curl::Easy.perform('http://localhost:9999/test')
+        c.header_str
+      end
+      threads << t
+    end
+
+    multi_responses = threads.collect do|t|
+      t.value
+    end
+
+    multi_time = (Time.now - timer)
+    puts "requested in #{multi_time}"
+
+    timer = Time.now
+    single_responses = []
+    5.times do |i|
+      c = Curl::Easy.perform('http://localhost:9999/test')
+      single_responses << c.header_str
+    end
+    
+    single_time = (Time.now - timer)
+    puts "requested in #{single_time}"
+
+    assert single_time > multi_time
+
+    server.shutdown
+    thread.join
+  end
+end

data/tests/bug_instance_post_differs_from_class_post.rb

@@ -0,0 +1,53 @@
+# From Vlad Jebelev:
+#
+# - Second thing - I think you just probably didn't have the time to update 
+# instance methods yet but when I POST with a reusal of a previous curl 
+# instance, it doesnt' work for me, e.g. when I create a curl previously and 
+# then issue:
+#  
+#   c.http_post(login_url, *fields)
+#   
+# instead of:
+#  
+#   c = Curl::Easy.http_post(login_url, *fields) do |curl|
+#     ...  
+#   end
+#    
+# then the result I am getting is quite different.
+#
+# ================
+#
+# Update:
+#
+#   It seems that class httpost is incorrectly passing arguments down to 
+#   instance httppost. This bug is intermittent, but results in an
+#   exception from the first post when it occurs.
+#   
+require File.expand_path(File.join(File.dirname(__FILE__), 'helper'))
+
+class BugTestInstancePostDiffersFromClassPost < Test::Unit::TestCase
+  def test_bug
+    5.times do |i|
+      puts "Test ##{i}"
+      do_test
+      sleep 2
+    end
+  end
+
+  def do_test
+    c = Curl::Easy.http_post('https://www.google.com/accounts/ServiceLoginAuth',
+                Curl::PostField.content('ltmpl','m_blanco'))
+    body_c, header_c = c.body_str, c.header_str
+   
+    sleep 2
+
+    c.http_post('https://www.google.com/accounts/ServiceLoginAuth',
+                Curl::PostField.content('ltmpl','m_blanco'))
+    body_i, header_i = c.body_str, c.header_str
+
+    # timestamps will differ, just check first bit. We wont get here if
+    # the bug bites anyway...
+    assert_equal header_c[0..50], header_i[0..50]
+  end
+end
+

data/tests/bug_multi_segfault.rb

@@ -0,0 +1,10 @@
+# From safis  http://github.com/taf2/curb/issues#issue/5
+# irb: require 'curb'
+# irb: multi = Curl::Multi.new
+# irb: exit
+# <main>:47140: [BUG] Bus Error
+$:.unshift File.expand_path(File.join(File.dirname(__FILE__),'..','ext'))
+$:.unshift File.expand_path(File.join(File.dirname(__FILE__),'..','lib'))
+require 'curb'
+multi = Curl::Multi.new
+exit

data/tests/bug_require_last_or_segfault.rb

@@ -0,0 +1,40 @@
+# From Vlad Jebelev:
+# 
+# - if I have a require statement after "require 'curb'" and there is a 
+# POST with at least 1 field, the script will fail with a segmentation 
+# fault, e.g. the following sequence fails every time for me (Ruby 1.8.5):
+# -----------------------------------------------------------------
+# require 'curb'
+# require 'uri'
+#  
+#  url = 'https://www.google.com/accounts/ServiceLoginAuth'
+#   
+#  c = Curl::Easy.http_post(
+#         'https://www.google.com/accounts/ServiceLoginAuth',
+#               [Curl:: PostField.content('ltmpl','m_blanco')] ) do |curl|
+#  end
+#  ------------------------------------------------------------------
+#  :..dev/util$ ruby seg.rb
+#  seg.rb:6: [BUG] Segmentation fault
+#  ruby 1.8.5 (2006-08-25) [i686-linux]
+#                
+#  Aborted
+#  ------------------------------------------------------------------
+#
+require 'test/unit'
+require 'rbconfig'
+
+$rubycmd = Config::CONFIG['RUBY_INSTALL_NAME'] || 'ruby'
+
+class BugTestRequireLastOrSegfault < Test::Unit::TestCase
+  def test_bug
+    5.times do |i|
+      puts "Test ##{i}"
+
+      # will be empty string if it segfaults...
+      assert_equal 'success', `#$rubycmd #{File.dirname(__FILE__)}/require_last_or_segfault_script.rb`.chomp
+      sleep 5
+    end
+  end
+end
+

data/tests/helper.rb

@@ -0,0 +1,168 @@
+# DO NOT REMOVE THIS COMMENT - PART OF TESTMODEL.
+# Copyright (c)2006 Ross Bamford. See LICENSE.
+$CURB_TESTING = true
+require 'uri'
+
+$TOPDIR = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+$EXTDIR = File.join($TOPDIR, 'ext')
+$LIBDIR = File.join($TOPDIR, 'lib')
+$:.unshift($LIBDIR)
+$:.unshift($EXTDIR)
+
+require 'curb'
+require 'test/unit'
+
+$TEST_URL = "file://#{URI.escape(File.expand_path(__FILE__).tr('\\','/').tr(':','|'))}"
+
+require 'thread'
+require 'webrick'
+
+# set this to true to avoid testing with multiple threads
+# or to test with multiple threads set it to false
+# this is important since, some code paths will change depending
+# on the presence of multiple threads
+TEST_SINGLE_THREADED=false
+
+# keep webrick quiet
+class ::WEBrick::HTTPServer
+  def access_log(config, req, res)
+    # nop
+  end
+end
+class ::WEBrick::BasicLog
+  def log(level, data)
+    # nop
+  end
+end
+
+#
+# Simple test server to record number of times a request is sent/recieved of a specific 
+# request type, e.g. GET,POST,PUT,DELETE
+#
+class TestServlet < WEBrick::HTTPServlet::AbstractServlet
+
+  def self.port=(p)
+    @port = p
+  end
+
+  def self.port
+    (@port or 9129)
+  end
+
+  def self.path
+    '/methods'
+  end
+
+  def self.url
+    "http://127.0.0.1:#{port}#{path}"
+  end
+
+  def respond_with(method,req,res)
+    res.body = method.to_s
+    res['Content-Type'] = "text/plain"
+  end
+
+  def do_GET(req,res)
+    respond_with(:GET,req,res)
+  end
+
+  def do_HEAD(req,res)
+    res['Location'] = "/nonexistent"
+    respond_with(:HEAD, req, res)
+  end
+
+  def do_POST(req,res)
+    if req.body
+      params = {}
+      req.body.split('&').map{|s| k,v=s.split('='); params[k] = v }
+    end
+    if params and params['s'] == '500'
+      res.status = 500
+    else
+      respond_with("POST\n#{req.body}",req,res)
+    end
+  end
+
+  def do_PUT(req,res)
+    res['X-Requested-Content-Type'] = req.content_type
+    respond_with("PUT\n#{req.body}",req,res)
+  end
+
+  def do_DELETE(req,res)
+    respond_with(:DELETE,req,res)
+  end
+
+end
+
+module TestServerMethods
+  def locked_file
+    File.join(File.dirname(__FILE__),"server_lock-#{@__port}")
+  end
+
+  def server_setup(port=9129,servlet=TestServlet)
+    @__port = port
+    if @server.nil? and !File.exist?(locked_file)
+
+      File.open(locked_file,'w') {|f| f << 'locked' }
+      if TEST_SINGLE_THREADED
+        rd, wr = IO.pipe
+        @__pid = fork do
+          rd.close
+          rd = nil
+
+          # start up a webrick server for testing delete 
+          server = WEBrick::HTTPServer.new :Port => port, :DocumentRoot => File.expand_path(File.dirname(__FILE__))
+
+          server.mount(servlet.path, servlet)
+          server.mount("/ext", WEBrick::HTTPServlet::FileHandler, File.join(File.dirname(__FILE__),'..','ext'))
+
+          trap("INT") { server.shutdown }
+          GC.start
+          wr.flush
+          wr.close
+          server.start
+        end
+        wr.close
+        rd.read
+        rd.close
+      else
+        # start up a webrick server for testing delete 
+        @server = WEBrick::HTTPServer.new :Port => port, :DocumentRoot => File.expand_path(File.dirname(__FILE__))
+
+        @server.mount(servlet.path, servlet)
+        @server.mount("/ext", WEBrick::HTTPServlet::FileHandler, File.join(File.dirname(__FILE__),'..','ext'))
+        queue = Queue.new # synchronize the thread startup to the main thread
+
+        @test_thread = Thread.new { queue << 1; @server.start }
+
+        # wait for the queue
+        value = queue.pop
+        if !value
+          STDERR.puts "Failed to startup test server!"
+          exit(1)
+        end
+
+      end
+
+      exit_code = lambda do
+        begin
+          if File.exist?(locked_file)
+            File.unlink locked_file
+            if TEST_SINGLE_THREADED
+              Process.kill 'INT', @__pid
+            else
+              @server.shutdown unless @server.nil?
+            end
+          end
+          #@server.shutdown unless @server.nil?
+        rescue Object => e
+          puts "Error #{__FILE__}:#{__LINE__}\n#{e.message}"
+        end
+      end
+
+      trap("INT"){exit_code.call}
+      at_exit{exit_code.call}
+
+    end
+  end
+end

data/tests/require_last_or_segfault_script.rb

@@ -0,0 +1,36 @@
+# From Vlad Jebelev:
+# 
+# - if I have a require statement after "require 'curb'" and there is a 
+# POST with at least 1 field, the script will fail with a segmentation 
+# fault, e.g. the following sequence fails every time for me (Ruby 1.8.5):
+# -----------------------------------------------------------------
+# require 'curb'
+# require 'uri'
+#  
+#  url = 'https://www.google.com/accounts/ServiceLoginAuth'
+#   
+#  c = Curl::Easy.http_post(
+#         'https://www.google.com/accounts/ServiceLoginAuth',
+#               [Curl:: PostField.content('ltmpl','m_blanco')] ) do |curl|
+#  end
+#  ------------------------------------------------------------------
+#  :..dev/util$ ruby seg.rb
+#  seg.rb:6: [BUG] Segmentation fault
+#  ruby 1.8.5 (2006-08-25) [i686-linux]
+#                
+#  Aborted
+#  ------------------------------------------------------------------
+#
+$:.unshift(File.expand_path(File.join(File.dirname(__FILE__), '..', 'ext')))
+$:.unshift(File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib')))
+require 'curb'
+require 'uri'
+ 
+url = 'https://www.google.com/accounts/ServiceLoginAuth'
+ 
+c = Curl::Easy.http_post('https://www.google.com/accounts/ServiceLoginAuth',
+                         Curl:: PostField.content('ltmpl','m_blanco')) #do
+#                         end
+
+puts "success"
+

data/tests/tc_curl_download.rb

@@ -0,0 +1,32 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'helper'))
+
+class TestCurbCurlDownload < Test::Unit::TestCase
+  include TestServerMethods 
+
+  def setup
+    server_setup
+  end
+  
+  def test_download_url_to_file
+    dl_url = "http://127.0.0.1:9129/ext/curb_easy.c"
+    dl_path = File.join(Dir::tmpdir, "dl_url_test.file")
+
+    curb = Curl::Easy.download(dl_url, dl_path)
+    assert File.exist?(dl_path)
+    assert_equal File.read(File.join(File.dirname(__FILE__), '..','ext','curb_easy.c')), File.read(dl_path)
+  ensure
+    File.unlink(dl_path) if File.exist?(dl_path)
+  end
+
+  def test_download_bad_url_gives_404
+    dl_url = "http://127.0.0.1:9129/this_file_does_not_exist.html"
+    dl_path = File.join(Dir::tmpdir, "dl_url_test.file")
+
+    curb = Curl::Easy.download(dl_url, dl_path)
+    assert_equal Curl::Easy, curb.class
+    assert_equal 404, curb.response_code
+  ensure
+    File.unlink(dl_path) if File.exist?(dl_path)
+  end
+
+end

data/tests/tc_curl_easy.rb

@@ -0,0 +1,664 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'helper'))
+
+class TestCurbCurlEasy < Test::Unit::TestCase
+  def test_class_perform_01   
+    assert_instance_of Curl::Easy, c = Curl::Easy.perform($TEST_URL)
+    assert_match(/^# DO NOT REMOVE THIS COMMENT/, c.body_str)
+    assert_equal "", c.header_str
+  end    
+
+  def test_class_perform_02
+    data = ""
+    assert_instance_of Curl::Easy, c = Curl::Easy.perform($TEST_URL) { |curl| curl.on_body { |d| data << d; d.length } }    
+
+    assert_nil c.body_str
+    assert_equal "", c.header_str
+    assert_match(/^# DO NOT REMOVE THIS COMMENT/, data)
+  end    
+
+  def test_class_perform_03
+    assert_raise(Curl::Err::CouldntReadError) { c = Curl::Easy.perform($TEST_URL + "nonexistent") }
+  end    
+  
+  def test_new_01
+    c = Curl::Easy.new
+    assert_equal Curl::Easy, c.class
+    assert_nil c.url
+    assert_nil c.body_str
+    assert_nil c.header_str
+  end
+
+  def test_new_02
+    c = Curl::Easy.new($TEST_URL)
+    assert_equal $TEST_URL, c.url
+  end
+  
+  def test_new_03
+    blk = lambda { |i| i.length }
+    
+    c = Curl::Easy.new do |curl|
+      curl.on_body(&blk)
+    end
+    
+    assert_nil c.url    
+    assert_equal blk, c.on_body   # sets handler nil, returns old handler
+    assert_equal nil, c.on_body
+  end
+    
+  def test_new_04
+    blk = lambda { |i| i.length }
+    
+    c = Curl::Easy.new($TEST_URL) do |curl|
+      curl.on_body(&blk)
+    end
+    
+    assert_equal $TEST_URL, c.url
+    assert_equal blk, c.on_body   # sets handler nil, returns old handler
+    assert_equal nil, c.on_body
+  end
+
+  class Foo < Curl::Easy
+  end
+  def test_new_05
+    # can use Curl::Easy as a base class
+    c = Foo.new
+    assert_equal Foo, c.class
+    c.url = $TEST_URL
+    c.perform
+    assert_match(/^# DO NOT REMOVE THIS COMMENT/, c.body_str)
+  end
+
+  # test invalid use of new
+  def test_new_06
+    Curl::Easy.new(TestServlet.url) do|curl|
+      curl.http_post
+      assert_equal "POST\n", curl.body_str
+    end
+  end
+
+  def test_escape
+    c = Curl::Easy.new
+    
+    assert_equal "one%20two", c.escape('one two')
+    assert_equal "one%00two%20three", c.escape("one\000two three")    
+  end
+  
+  def test_unescape
+    c = Curl::Easy.new
+    
+    assert_equal "one two", c.unescape('one%20two')
+    
+    # prior to 7.15.4 embedded nulls cannot be unescaped
+    if Curl::VERNUM >= 0x070f04
+      assert_equal "one\000two three", c.unescape("one%00two%20three")
+    end
+  end
+  
+  def test_headers
+    c = Curl::Easy.new($TEST_URL)
+    
+    assert_equal({}, c.headers)
+    c.headers = "Expect:"
+    assert_equal "Expect:", c.headers
+    c.headers = ["Expect:", "User-Agent: myapp-0.0.0"]
+    assert_equal ["Expect:", "User-Agent: myapp-0.0.0"], c.headers
+  end    
+
+  def test_get_01   
+    c = Curl::Easy.new($TEST_URL)    
+    assert_equal true, c.http_get
+    assert_match(/^# DO NOT REMOVE THIS COMMENT/, c.body_str)
+    assert_equal "", c.header_str
+  end    
+
+  def test_get_02
+    data = ""
+    c = Curl::Easy.new($TEST_URL) do |curl|
+      curl.on_body { |d| data << d; d.length }
+    end
+    
+    assert_equal true, c.http_get    
+    
+    assert_nil c.body_str
+    assert_equal "", c.header_str
+    assert_match(/^# DO NOT REMOVE THIS COMMENT/, data)
+  end    
+
+  def test_get_03
+    c = Curl::Easy.new($TEST_URL + "nonexistent")        
+    assert_raise(Curl::Err::CouldntReadError) { c.http_get }
+    assert_equal "", c.body_str
+    assert_equal "", c.header_str
+  end    
+
+
+  def test_last_effective_url_01
+    c = Curl::Easy.new($TEST_URL)
+    
+    assert_equal $TEST_URL, c.url
+    assert_nil c.last_effective_url
+    
+    assert c.http_get
+    
+    assert_equal c.url, c.last_effective_url
+    c.url = "file://some/new.url"
+    
+    assert_not_equal c.last_effective_url, c.url
+  end
+
+  def test_http_get_block
+    curl = Curl::Easy.http_get(TestServlet.url) do|c|
+      c.follow_location = true
+      c.max_redirects = 3
+    end
+    assert_equal curl.url, curl.last_effective_url
+    assert_equal 'GET', curl.body_str
+  end
+  
+  def test_local_port_01
+    c = Curl::Easy.new($TEST_URL)
+    
+    assert_nil c.local_port    
+    assert_nil c.local_port_range
+    assert_nil c.proxy_port
+    
+    c.local_port = 88
+
+    assert_equal 88, c.local_port  
+    assert_nil c.local_port_range
+    assert_nil c.proxy_port
+    
+    c.local_port = nil
+
+    assert_nil c.local_port  
+    assert_nil c.local_port_range
+    assert_nil c.proxy_port
+  end
+  
+  def test_local_port_02
+    c = Curl::Easy.new($TEST_URL)
+    
+    assert_nil c.local_port    
+    assert_raise(ArgumentError) { c.local_port = 0 }
+    assert_raise(ArgumentError) { c.local_port = 65536 }
+    assert_raise(ArgumentError) { c.local_port = -1 }
+  end
+  
+  def test_local_port_range_01
+    c = Curl::Easy.new($TEST_URL)
+    
+    assert_nil c.local_port_range
+    assert_nil c.local_port
+    assert_nil c.proxy_port
+
+    c.local_port_range = 88
+    assert_equal 88, c.local_port_range
+    assert_nil c.local_port
+    assert_nil c.proxy_port
+    
+    c.local_port_range = nil
+    
+    assert_nil c.local_port_range
+    assert_nil c.local_port
+    assert_nil c.proxy_port
+  end
+  
+  def test_local_port_range_02
+    c = Curl::Easy.new($TEST_URL)
+    
+    assert_nil c.local_port_range    
+    assert_raise(ArgumentError) { c.local_port_range = 0 }
+    assert_raise(ArgumentError) { c.local_port_range = 65536 }
+    assert_raise(ArgumentError) { c.local_port_range = -1 }
+  end
+  
+  def test_proxy_url_01
+    c = Curl::Easy.new($TEST_URL)
+    
+    assert_equal $TEST_URL, c.url
+    assert_nil c.proxy_url
+    
+    c.proxy_url = "http://some.proxy"    
+
+    assert_equal $TEST_URL, c.url
+    assert_equal "http://some.proxy", c.proxy_url
+    
+    c.proxy_url = nil
+    assert_equal $TEST_URL, c.url
+    assert_nil c.proxy_url
+  end
+  
+  def test_proxy_port_01
+    c = Curl::Easy.new($TEST_URL)
+    
+    assert_nil c.local_port
+    assert_nil c.local_port_range    
+    assert_nil c.proxy_port    
+    
+    c.proxy_port = 88
+
+    assert_equal 88, c.proxy_port  
+    assert_nil c.local_port
+    assert_nil c.local_port_range
+    
+    c.proxy_port = nil
+    assert_nil c.proxy_port  
+    assert_nil c.local_port
+    assert_nil c.local_port_range
+  end
+  
+  def test_proxy_port_02
+    c = Curl::Easy.new($TEST_URL)
+    
+    assert_nil c.proxy_port    
+    assert_raise(ArgumentError) { c.proxy_port = 0 }
+    assert_raise(ArgumentError) { c.proxy_port = 65536 }
+    assert_raise(ArgumentError) { c.proxy_port = -1 }
+  end
+  
+  def test_proxy_type_01
+    c = Curl::Easy.new($TEST_URL)
+    
+    assert_nil c.proxy_type
+    
+    c.proxy_type = 3
+    assert_equal 3, c.proxy_type
+    
+    c.proxy_type = nil
+    assert_nil c.proxy_type
+  end
+  
+  def test_http_auth_types_01
+    c = Curl::Easy.new($TEST_URL)
+    
+    assert_nil c.http_auth_types
+    
+    c.http_auth_types = 3
+    assert_equal 3, c.http_auth_types
+    
+    c.http_auth_types = nil
+    assert_nil c.http_auth_types
+  end
+  
+  def test_proxy_auth_types_01
+    c = Curl::Easy.new($TEST_URL)
+    
+    assert_nil c.proxy_auth_types
+    
+    c.proxy_auth_types = 3
+    assert_equal 3, c.proxy_auth_types
+    
+    c.proxy_auth_types = nil
+    assert_nil c.proxy_auth_types
+  end
+  
+  def test_max_redirects_01
+    c = Curl::Easy.new($TEST_URL)
+    
+    assert_nil c.max_redirects
+    
+    c.max_redirects = 3
+    assert_equal 3, c.max_redirects
+    
+    c.max_redirects = nil
+    assert_nil c.max_redirects
+  end
+  
+  def test_timeout_01
+    c = Curl::Easy.new($TEST_URL)
+    
+    assert_nil c.timeout
+    
+    c.timeout = 3
+    assert_equal 3, c.timeout
+    
+    c.timeout = nil
+    assert_nil c.timeout
+  end
+  
+  def test_connect_timeout_01
+    c = Curl::Easy.new($TEST_URL)
+    
+    assert_nil c.connect_timeout
+    
+    c.connect_timeout = 3
+    assert_equal 3, c.connect_timeout
+    
+    c.connect_timeout = nil
+    assert_nil c.connect_timeout
+  end
+  
+  def test_ftp_response_timeout_01
+    c = Curl::Easy.new($TEST_URL)
+    
+    assert_nil c.ftp_response_timeout
+    
+    c.ftp_response_timeout = 3
+    assert_equal 3, c.ftp_response_timeout
+    
+    c.ftp_response_timeout = nil
+    assert_nil c.ftp_response_timeout
+  end
+  
+  def test_dns_cache_timeout_01
+    c = Curl::Easy.new($TEST_URL)
+    
+    assert_equal 60, c.dns_cache_timeout
+    
+    c.dns_cache_timeout = nil
+    assert_nil c.dns_cache_timeout
+    
+    c.dns_cache_timeout = 30
+    assert_equal 30, c.dns_cache_timeout
+  end
+  
+  def test_on_body
+    blk = lambda { |i| i.length }
+    
+    c = Curl::Easy.new    
+    c.on_body(&blk)
+    
+    assert_equal blk, c.on_body   # sets handler nil, returns old handler
+    assert_equal nil, c.on_body
+  end
+  
+  def test_on_header
+    blk = lambda { |i| i.length }
+    
+    c = Curl::Easy.new    
+    c.on_header(&blk)
+    
+    assert_equal blk, c.on_header   # sets handler nil, returns old handler
+    assert_equal nil, c.on_header
+  end
+  
+  def test_on_progress
+    blk = lambda { |*args| true }
+    
+    c = Curl::Easy.new    
+    c.on_progress(&blk)
+    
+    assert_equal blk, c.on_progress   # sets handler nil, returns old handler
+    assert_equal nil, c.on_progress
+  end
+  
+  def test_on_debug
+    blk = lambda { |*args| true }
+    
+    c = Curl::Easy.new    
+    c.on_debug(&blk)
+    
+    assert_equal blk, c.on_debug   # sets handler nil, returns old handler
+    assert_equal nil, c.on_debug
+  end
+  
+  def test_proxy_tunnel
+    c = Curl::Easy.new    
+    assert !c.proxy_tunnel?
+    assert c.proxy_tunnel = true
+    assert c.proxy_tunnel?
+  end
+  
+  def test_fetch_file_time
+    c = Curl::Easy.new    
+    assert !c.fetch_file_time?
+    assert c.fetch_file_time = true
+    assert c.fetch_file_time?
+  end
+  
+  def test_ssl_verify_peer
+    c = Curl::Easy.new    
+    assert c.ssl_verify_peer?
+    assert !c.ssl_verify_peer = false
+    assert !c.ssl_verify_peer?
+  end
+  
+  def test_ssl_verify_host
+    c = Curl::Easy.new    
+    assert c.ssl_verify_host?
+    assert !c.ssl_verify_host = false
+    assert !c.ssl_verify_host?
+  end
+  
+  def test_header_in_body
+    c = Curl::Easy.new    
+    assert !c.header_in_body?
+    assert c.header_in_body = true
+    assert c.header_in_body?
+  end
+  
+  def test_use_netrc
+    c = Curl::Easy.new    
+    assert !c.use_netrc?
+    assert c.use_netrc = true
+    assert c.use_netrc?
+  end
+  
+  def test_follow_location
+    c = Curl::Easy.new    
+    assert !c.follow_location?
+    assert c.follow_location = true
+    assert c.follow_location?
+  end
+  
+  def test_unrestricted_auth
+    c = Curl::Easy.new    
+    assert !c.unrestricted_auth?
+    assert c.unrestricted_auth = true
+    assert c.unrestricted_auth?
+  end  
+  
+  def test_multipart_form_post
+    c = Curl::Easy.new
+    assert !c.multipart_form_post?
+    assert c.multipart_form_post = true
+    assert c.multipart_form_post?
+  end
+
+  def test_enable_cookies
+    c = Curl::Easy.new
+    assert !c.enable_cookies?
+    assert c.enable_cookies = true
+    assert c.enable_cookies?
+  end
+
+  def test_cookies_option
+    c = Curl::Easy.new
+    assert_nil c.cookies
+    assert_equal "name1=content1; name2=content2;", c.cookies = "name1=content1; name2=content2;"
+    assert_equal "name1=content1; name2=content2;", c.cookies
+  end
+
+  def test_cookiefile
+    c = Curl::Easy.new
+    assert_nil c.cookiefile
+    assert_equal "some.file", c.cookiefile = "some.file"
+    assert_equal "some.file", c.cookiefile       
+  end
+
+  def test_cookiejar
+    c = Curl::Easy.new
+    assert_nil c.cookiejar
+    assert_equal "some.file", c.cookiejar = "some.file"
+    assert_equal "some.file", c.cookiejar        
+  end
+
+  def test_on_success
+    curl = Curl::Easy.new($TEST_URL)    
+    on_success_called = false
+    curl.on_success {|c|
+      on_success_called = true
+      assert_not_nil c.body_str
+      assert_equal "", c.header_str
+      assert_match(/^# DO NOT REMOVE THIS COMMENT/, c.body_str)
+    }
+    curl.perform
+    assert on_success_called, "Success handler not called" 
+  end
+
+  def test_on_success_with_on_failure
+    curl = Curl::Easy.new("#{$TEST_URL.gsub(/file:\/\//,'')}/not_here")
+    on_failure_called = false
+    curl.on_success {|c| } # make sure we get the failure call even though this handler is defined
+    curl.on_failure {|c,code| on_failure_called = true }
+    curl.perform
+    assert on_failure_called, "Failure handler not called" 
+  end
+  
+  def test_get_remote
+    curl = Curl::Easy.new(TestServlet.url)
+    curl.http_get
+    assert_equal 'GET', curl.body_str
+  end
+  
+  def test_post_remote
+    curl = Curl::Easy.new(TestServlet.url)
+    curl.http_post
+    assert_equal "POST\n", curl.body_str
+  end
+
+  def test_post_remote_is_easy_handle
+    # see: http://pastie.org/560852 and
+    # http://groups.google.com/group/curb---ruby-libcurl-bindings/browse_thread/thread/216bb2d9b037f347?hl=en
+    [:post, :get,:head,:delete].each do |method|
+      count = 0
+      curl = Curl::Easy.send("http_#{method}", TestServlet.url) do|c|
+        count += 1
+        assert_equal Curl::Easy, c.class
+      end
+      assert_equal 1, count, "For request method: #{method.to_s.upcase}"
+    end
+  end
+  
+  def test_post_with_body_remote
+    curl = Curl::Easy.new(TestServlet.url)
+    curl.post_body = 'foo=bar&encoded%20string=val'
+    
+    curl.perform
+    
+    assert_equal "POST\nfoo=bar&encoded%20string=val", curl.body_str
+    assert_equal 'foo=bar&encoded%20string=val', curl.post_body
+  end
+  
+  def test_form_post_body_remote
+    curl = Curl::Easy.new(TestServlet.url)
+    curl.http_post('foo=bar', 'encoded%20string=val')
+    
+    assert_equal "POST\nfoo=bar&encoded%20string=val", curl.body_str
+    assert_equal 'foo=bar&encoded%20string=val', curl.post_body
+  end
+
+  def test_delete_remote
+    curl = Curl::Easy.new(TestServlet.url)
+    curl.http_delete
+    assert_equal 'DELETE', curl.body_str
+  end
+
+  def test_head_remote
+    curl = Curl::Easy.new(TestServlet.url)
+    curl.http_head
+
+    redirect = curl.header_str.match(/Location: (.*)/)
+
+    assert_equal '', curl.body_str
+    assert_match '/nonexistent', redirect[1]
+  end
+
+  def test_head_accessor
+    curl = Curl::Easy.new(TestServlet.url)
+    curl.head = true
+    curl.perform
+
+    redirect = curl.header_str.match(/Location: (.*)/)
+
+    assert_equal '', curl.body_str
+    assert_match '/nonexistent', redirect[1]
+    curl.head = false
+    curl.perform
+    assert_equal 'GET', curl.body_str
+  end
+
+  def test_put_remote
+    curl = Curl::Easy.new(TestServlet.url)
+    curl.headers['Content-Type'] = 'application/json'
+    assert curl.http_put("message")
+    assert_match /^PUT/, curl.body_str
+    assert_match /message$/, curl.body_str
+    assert_match /application\/json/, curl.header_str
+  end 
+  
+  def test_put_data
+    curl = Curl::Easy.new(TestServlet.url)
+    curl.put_data = 'message'
+    
+    curl.perform
+    
+    assert_match /^PUT/, curl.body_str
+    assert_match /message$/, curl.body_str
+  end
+
+  def test_put_remote_file
+    curl = Curl::Easy.new(TestServlet.url)
+    File.open(__FILE__,'r') do|f|
+      assert curl.http_put(f)
+    end
+    assert_equal "PUT\n#{File.read(__FILE__)}", curl.body_str
+  end
+  
+  def test_put_class_method
+    count = 0
+    curl = Curl::Easy.http_put(TestServlet.url,File.open(__FILE__,'rb')) do|c|
+      count += 1
+      assert_equal Curl::Easy, c.class
+    end
+    assert_equal 1, count
+    assert_equal "PUT\n#{File.read(__FILE__)}", curl.body_str
+  end
+
+  # Generate a self-signed cert with
+  # openssl req -new -newkey rsa:1024 -days 365 -nodes -x509 \
+  #   -keyout tests/cert.pem  -out tests/cert.pem
+  def test_cert
+    curl = Curl::Easy.new(TestServlet.url)
+    curl.cert= File.join(File.dirname(__FILE__),"cert.pem")
+    assert /cert.pem$/,curl.cert
+  end
+
+  def test_cert_with_password
+    curl = Curl::Easy.new(TestServlet.url)
+    curl.cert= File.join(File.dirname(__FILE__),"cert.pem:password")
+    assert /cert.pem$/,curl.cert
+  end
+
+  def test_cert_type
+    curl = Curl::Easy.new(TestServlet.url)
+    curl.certtype= "DER"
+    assert "DER", curl.certtype
+  end
+
+  def test_default_certtype
+    curl = Curl::Easy.new(TestServlet.url)
+    assert "PEM", curl.certtype
+  end
+
+  # Generate a CA cert with instructions at
+  # http://technocage.com/~caskey/openssl/
+  def test_ca_cert
+    curl = Curl::Easy.new(TestServlet.url)
+    curl.cacert= File.join(File.dirname(__FILE__),"cacert.pem")
+    assert /cacert.pem$/, curl.cacert
+  end
+
+  def test_user_agent
+    curl = Curl::Easy.new(TestServlet.url)
+    curl.useragent= "Curb-Easy/Ruby"
+    assert /ScrubDog$/,curl.useragent
+  end
+
+  include TestServerMethods 
+
+  def setup
+    server_setup
+  end
+
+end