curb 0.4.4.0 → 0.4.8.0

data/Rakefile

@@ -63,6 +63,11 @@ end
 desc "Compile the shared object"
 task :compile => [CURB_SO]
 
+desc "Create the markdown file"
+task :markdown do
+  cp "README", "README.markdown"
+end
+
 desc "Install to your site_ruby directory"
 task :install => :alltests do
   m = make 'install' 

data/ext/curb.h

@@ -20,20 +20,21 @@
 #include "curb_macros.h"
 
 // These should be managed from the Rake 'release' task.
-#define CURB_VERSION   "0.4.4"
-#define CURB_VER_NUM   440
+#define CURB_VERSION   "0.4.8.0"
+#define CURB_VER_NUM   480
 #define CURB_VER_MAJ   0
 #define CURB_VER_MIN   4
-#define CURB_VER_MIC   4
+#define CURB_VER_MIC   8
 #define CURB_VER_PATCH 0
 
 
 // Maybe not yet defined in Ruby
 #ifndef RSTRING_LEN
-#define RSTRING_LEN(x) RSTRING(x)->len
+  #define RSTRING_LEN(x) RSTRING(x)->len
 #endif
+
 #ifndef RSTRING_PTR
-#define RSTRING_PTR(x) RSTRING(x)->ptr
+  #define RSTRING_PTR(x) RSTRING(x)->ptr
 #endif
 
 #ifdef HAVE_RUBY19_HASH

data/ext/curb_easy.c

@@ -8,6 +8,7 @@
 #include "curb_errors.h"
 #include "curb_postfield.h"
 #include "curb_upload.h"
+#include "curb_multi.h"
 
 #include <errno.h>
 #include <string.h>
@@ -1716,147 +1717,16 @@ VALUE ruby_curl_easy_cleanup( VALUE self, ruby_curl_easy *rbce, VALUE bodybuf, V
  */
 static VALUE handle_perform(VALUE self, ruby_curl_easy *rbce) {
 
-  CURLcode result = -1;
-  struct curl_slist *headers = NULL;
-  VALUE bodybuf = Qnil, headerbuf = Qnil;
-//  char errors[CURL_ERROR_SIZE*2];
+  VALUE multi = ruby_curl_multi_new(cCurlMulti);
+  ruby_curl_multi_add(multi, self);
+  VALUE ret = ruby_curl_multi_perform(multi);
 
-  ruby_curl_easy_setup(rbce, &bodybuf, &headerbuf, &headers);
-//  curl_easy_setopt(rbce->curl, CURLOPT_ERRORBUFFER, errors);
-//  curl_easy_setopt(rbce->curl, CURLOPT_VERBOSE, 1);
-
-  if( rb_thread_alone() ) {
-    result = curl_easy_perform(rbce->curl);
+  /* check for errors in the easy response and raise exceptions if anything went wrong and their is no on_failure handler */
+  if( rbce->last_result != 0 && rbce->failure_proc == Qnil ) {
+    raise_curl_easy_error_exception(rbce->last_result);
   }
-  else {
-    int msgs;
-    int still_running = 1;
-    CURLMcode mcode = -1;
-    CURLM *multi_handle = curl_multi_init();
-    long timeout;
-    struct timeval tv = {0, 0};
-    int rc; /* select() return code */
-    int maxfd;
-
-    /* NOTE:
-     * We create an Curl multi handle here and use rb_thread_select allowing other ruby threads to
-     * perform actions... ideally we'd have just 1 shared multi handle per all curl easy handles globally
-     */
-    mcode = curl_multi_add_handle(multi_handle, rbce->curl);
-    if (mcode != CURLM_CALL_MULTI_PERFORM && mcode != CURLM_OK) {
-      raise_curl_multi_error_exception(mcode);
-    }
-
-    while(CURLM_CALL_MULTI_PERFORM == (mcode=curl_multi_perform(multi_handle, &still_running)) ) ;
-
-    if (mcode != CURLM_CALL_MULTI_PERFORM && mcode != CURLM_OK) {
-      raise_curl_multi_error_exception(mcode);
-    }
-
-
-    while(still_running) {
-
-      fd_set fdread;
-      fd_set fdwrite;
-      fd_set fdexcep;
-
-      FD_ZERO(&fdread);
-      FD_ZERO(&fdwrite);
-      FD_ZERO(&fdexcep);
-
-      //time_t timer = time(NULL);
-      /* get file descriptors from the transfers */
-      mcode = curl_multi_fdset(multi_handle, &fdread, &fdwrite, &fdexcep, &maxfd);
-      if (mcode != CURLM_CALL_MULTI_PERFORM && mcode != CURLM_OK) {
-        raise_curl_multi_error_exception(mcode);
-      }
-
-#ifdef HAVE_CURL_MULTI_TIMEOUT
-      /* get the curl suggested time out */
-      mcode = curl_multi_timeout(multi_handle, &timeout);
-      if (mcode != CURLM_OK) {
-        raise_curl_multi_error_exception(mcode);
-      }
-#else
-      /* libcurl doesn't have a timeout method defined... make a wild guess */
-      timeout = 1; /* wait a second */
-#endif
-
-      if (timeout == 0) { /* no delay */
-        while(CURLM_CALL_MULTI_PERFORM == (mcode=curl_multi_perform(multi_handle, &still_running)) );
-        continue;
-      }
-      else if (timeout == -1) {
-        timeout = 1; /* wait a second */
-      }
-
-      /* set a suitable timeout to play around with - ruby seems to be greedy about this and won't necessarily yield so the timeout is small.. */
-      tv.tv_sec = timeout / 1000;
-      tv.tv_usec = (timeout * 1000) % 1000000;
-      rc = rb_thread_select(maxfd+1, &fdread, &fdwrite, &fdexcep, &tv);
-      if (rc < 0) {
-        rb_raise(rb_eRuntimeError, "select(): %s", strerror(errno));
-      }
 
-      if( rc >= 0 ) {
-        switch(rc) {
-        case 0:
-          //printf("timeout(%.6f) :", difftime(time(NULL), timer) );
-        default:
-          //printf("readable/writable: %d\n", rc);
-          /* timeout or readable/writable sockets */
-          while(CURLM_CALL_MULTI_PERFORM == (mcode=curl_multi_perform(multi_handle, &still_running)) );
-          break;
-        }
-      }
-      else {
-        // error
-      }
-
-      if (mcode != CURLM_CALL_MULTI_PERFORM && mcode != CURLM_OK) {
-        raise_curl_multi_error_exception(mcode);
-      }
-
-    }
-
-    /* check for errors */
-    CURLMsg *msg = curl_multi_info_read(multi_handle, &msgs);
-    if (msg && msg->msg == CURLMSG_DONE) {
-      result = msg->data.result;
-    }
-
-    curl_multi_remove_handle(multi_handle, rbce->curl);
-    curl_multi_cleanup(multi_handle);
-  }
-
-  ruby_curl_easy_cleanup(self, rbce, bodybuf, headerbuf, headers);
-
-  if (rbce->complete_proc != Qnil) {
-    rb_funcall( rbce->complete_proc, idCall, 1, self );
-  }
-
-  /* check the request status and determine if on_success or on_failure should be called */
-  long response_code = -1;
-  curl_easy_getinfo(rbce->curl, CURLINFO_RESPONSE_CODE, &response_code);
-  if (result != 0) {
-//    printf("error: %s\n", errors);
-    if (rbce->failure_proc != Qnil) {
-      rb_funcall( rbce->failure_proc, idCall, 2, rbce->self, rb_curl_easy_error(result) );
-    } else {
-      raise_curl_easy_error_exception(result);
-    }
-  }
-  else if (rbce->success_proc != Qnil &&
-           /* NOTE: we allow response_code == 0, in the case the file is being read from disk */
-           ((response_code >= 200 && response_code < 300) || response_code == 0)) {
-    rb_funcall( rbce->success_proc, idCall, 1, self );
-  }
-  else if (rbce->failure_proc != Qnil &&
-           (response_code >= 300 && response_code <= 999)) {
-    rb_funcall( rbce->failure_proc, idCall, 2, rbce->self, rb_curl_easy_error(result) );
-  }
-
-  return Qtrue;
+  return ret;
 }
 
 /*

data/ext/curb_easy.h

@@ -89,6 +89,8 @@ typedef struct {
   VALUE self; /* pointer to self, used by multi interface */
   VALUE upload; /* pointer to an active upload otherwise Qnil */
 
+  int last_result; /* last result code from multi loop */
+
 } ruby_curl_easy;
 
 extern VALUE cCurlEasy;

data/ext/curb_multi.c

@@ -6,9 +6,11 @@
 
 #include "curb_config.h"
 #ifdef HAVE_RUBY19_ST_H
-#include <ruby/st.h>
+  #include <ruby.h>
+  #include <ruby/st.h>
 #else
-#include <st.h>
+  #include <ruby.h>
+  #include <st.h>
 #endif
 #include "curb_easy.h"
 #include "curb_errors.h"
@@ -26,7 +28,6 @@ static VALUE idCall;
 
 VALUE cCurlMulti;
 
-static VALUE ruby_curl_multi_remove(VALUE , VALUE );
 static void rb_curl_multi_remove(ruby_curl_multi *rbcm, VALUE easy);
 static void rb_curl_multi_read_info(VALUE self, CURLM *mptr);
 
@@ -76,7 +77,7 @@ static void curl_multi_free(ruby_curl_multi *rbcm) {
  *
  * Create a new Curl::Multi instance
  */
-static VALUE ruby_curl_multi_new(VALUE klass) {
+VALUE ruby_curl_multi_new(VALUE klass) {
   VALUE new_curlm;
 
   ruby_curl_multi *rbcm = ALLOC(ruby_curl_multi);
@@ -93,6 +94,51 @@ static VALUE ruby_curl_multi_new(VALUE klass) {
   return new_curlm;
 }
 
+// Hash#foreach callback for ruby_curl_multi_requests
+static int ruby_curl_multi_requests_callback(VALUE key, VALUE value, VALUE result_array) {
+  rb_ary_push(result_array, value);
+  
+  return ST_CONTINUE;
+}
+
+/*
+ * call-seq:
+ *   multi.requests                                   => [#&lt;Curl::Easy...&gt;, ...]
+ * 
+ * Returns an array containing all the active requests on this Curl::Multi object.
+ */
+static VALUE ruby_curl_multi_requests(VALUE self) {
+  ruby_curl_multi *rbcm;
+  
+  Data_Get_Struct(self, ruby_curl_multi, rbcm);
+  
+  VALUE result_array = rb_ary_new();
+  
+  // iterate over the requests hash, and stuff references into the array.
+  rb_hash_foreach( rbcm->requests, ruby_curl_multi_requests_callback, result_array );
+  
+  return result_array;
+}
+
+/*
+ * call-seq:
+ *   multi.idle?                                      => true or false
+ * 
+ * Returns whether or not this Curl::Multi handle is processing any requests.  E.g. this returns
+ * true when multi.requests.length == 0.
+ */
+static VALUE ruby_curl_multi_idle(VALUE self) {
+  ruby_curl_multi *rbcm;
+  
+  Data_Get_Struct(self, ruby_curl_multi, rbcm);
+  
+  if ( FIX2INT( rb_funcall(rbcm->requests, rb_intern("length"), 0) ) == 0 ) {
+    return Qtrue;
+  } else {
+    return Qfalse;
+  }
+}
+
 /*
  * call-seq:
  * multi = Curl::Multi.new
@@ -141,7 +187,7 @@ static VALUE ruby_curl_multi_pipeline(VALUE self, VALUE onoff) {
  *
  * Add an easy handle to the multi stack
  */
-static VALUE ruby_curl_multi_add(VALUE self, VALUE easy) {
+VALUE ruby_curl_multi_add(VALUE self, VALUE easy) {
   CURLMcode mcode;
   ruby_curl_easy *rbce;
   ruby_curl_multi *rbcm;
@@ -185,11 +231,11 @@ static VALUE ruby_curl_multi_add(VALUE self, VALUE easy) {
  * # sometime later
  * multi.remove(easy)
  *
- * Remove an easy handle from a multi stack
+ * Remove an easy handle from a multi stack.
  *
  * Will raise an exception if the easy handle is not found
  */
-static VALUE ruby_curl_multi_remove(VALUE self, VALUE easy) {
+VALUE ruby_curl_multi_remove(VALUE self, VALUE easy) {
   ruby_curl_multi *rbcm;
 
   Data_Get_Struct(self, ruby_curl_multi, rbcm);
@@ -226,6 +272,30 @@ static void rb_curl_multi_remove(ruby_curl_multi *rbcm, VALUE easy) {
   }
 }
 
+// Hash#foreach callback for ruby_curl_multi_cancel
+static int ruby_curl_multi_cancel_callback(VALUE key, VALUE value, ruby_curl_multi *rbcm) {
+  rb_curl_multi_remove(rbcm, value);
+  
+  return ST_CONTINUE;
+}
+
+/*
+ * call-seq:
+ *   multi.cancel!
+ * 
+ * Cancels all requests currently being made on this Curl::Multi handle.  
+ */
+static VALUE ruby_curl_multi_cancel(VALUE self) {
+  ruby_curl_multi *rbcm;
+
+  Data_Get_Struct(self, ruby_curl_multi, rbcm);
+  
+  rb_hash_foreach( rbcm->requests, ruby_curl_multi_cancel_callback, (VALUE)rbcm );
+  
+  // for chaining
+  return self;
+}
+
 static void rb_curl_multi_read_info(VALUE self, CURLM *multi_handle) {
   int msgs_left, result;
   CURLMsg *msg;
@@ -247,6 +317,7 @@ static void rb_curl_multi_read_info(VALUE self, CURLM *multi_handle) {
       if (ecode != 0) {
         raise_curl_easy_error_exception(ecode);
       }
+      rbce->last_result = result; // save the last easy result code
       ruby_curl_multi_remove( self, rbce->self );
 
       if (rbce->complete_proc != Qnil) {
@@ -308,7 +379,7 @@ static void rb_curl_multi_run(VALUE self, CURLM *multi_handle, int *still_runnin
  *
  * Run multi handles, looping selecting when data can be transfered
  */
-static VALUE ruby_curl_multi_perform(VALUE self) {
+VALUE ruby_curl_multi_perform(VALUE self) {
   CURLMcode mcode;
   ruby_curl_multi *rbcm;
   int maxfd, rc;
@@ -368,7 +439,7 @@ static VALUE ruby_curl_multi_perform(VALUE self) {
 
   }
 
-  return Qnil;
+  return Qtrue;
 }
 
 /* =================== INIT LIB =====================*/
@@ -379,11 +450,16 @@ void init_curb_multi() {
 
   /* Class methods */
   rb_define_singleton_method(cCurlMulti, "new", ruby_curl_multi_new, 0);
-
+  
+  /* "Attributes" */
+  rb_define_method(cCurlMulti, "requests", ruby_curl_multi_requests, 0);
+  rb_define_method(cCurlMulti, "idle?", ruby_curl_multi_idle, 0);
+  
   /* Instnace methods */
   rb_define_method(cCurlMulti, "max_connects=", ruby_curl_multi_max_connects, 1);
   rb_define_method(cCurlMulti, "pipeline=", ruby_curl_multi_pipeline, 1);
   rb_define_method(cCurlMulti, "add", ruby_curl_multi_add, 1);
   rb_define_method(cCurlMulti, "remove", ruby_curl_multi_remove, 1);
+  rb_define_method(cCurlMulti, "cancel!", ruby_curl_multi_cancel, 0);
   rb_define_method(cCurlMulti, "perform", ruby_curl_multi_perform, 0);
 }

data/ext/curb_multi.h

@@ -20,6 +20,10 @@ typedef struct {
 
 extern VALUE cCurlMulti;
 void init_curb_multi();
+VALUE ruby_curl_multi_new(VALUE klass);
+VALUE ruby_curl_multi_perform(VALUE self);
+VALUE ruby_curl_multi_add(VALUE self, VALUE easy);
+VALUE ruby_curl_multi_remove(VALUE self, VALUE easy);
 
 
 #endif

data/ext/curb_upload.c

@@ -6,6 +6,10 @@
 extern VALUE mCurl;
 VALUE cCurlUpload;
 
+#ifdef RDOC_NEVER_DEFINED
+  mCurl = rb_define_module("Curl");
+#endif
+
 static void curl_upload_mark(ruby_curl_upload *rbcu) {
   if (rbcu->stream) rb_gc_mark(rbcu->stream);
 }
@@ -13,6 +17,10 @@ static void curl_upload_free(ruby_curl_upload *rbcu) {
   free(rbcu);
 }
 
+/*
+ * call-seq:
+ *   internal class for sending large file uploads
+ */
 VALUE ruby_curl_upload_new(VALUE klass) {
   VALUE upload;
   ruby_curl_upload *rbcu = ALLOC(ruby_curl_upload);
@@ -22,23 +30,39 @@ VALUE ruby_curl_upload_new(VALUE klass) {
   return upload;
 }
 
+/*
+ * call-seq:
+ *   internal class for sending large file uploads
+ */
 VALUE ruby_curl_upload_stream_set(VALUE self, VALUE stream) {
   ruby_curl_upload *rbcu;
   Data_Get_Struct(self, ruby_curl_upload, rbcu);
   rbcu->stream = stream;
   return stream;
 }
+/*
+ * call-seq:
+ *   internal class for sending large file uploads
+ */
 VALUE ruby_curl_upload_stream_get(VALUE self) {
   ruby_curl_upload *rbcu;
   Data_Get_Struct(self, ruby_curl_upload, rbcu);
   return rbcu->stream;
 }
+/*
+ * call-seq:
+ *   internal class for sending large file uploads
+ */
 VALUE ruby_curl_upload_offset_set(VALUE self, VALUE offset) {
   ruby_curl_upload *rbcu;
   Data_Get_Struct(self, ruby_curl_upload, rbcu);
   rbcu->offset = FIX2INT(offset);
   return offset;
 }
+/*
+ * call-seq:
+ *   internal class for sending large file uploads
+ */
 VALUE ruby_curl_upload_offset_get(VALUE self) {
   ruby_curl_upload *rbcu;
   Data_Get_Struct(self, ruby_curl_upload, rbcu);

data/lib/curb.rb

@@ -75,11 +75,51 @@ module Curl
           easy_options.each do|k,v|
             c.send("#{k}=",v)
           end
-          c.on_complete {|curl| blk.call curl }
+          c.on_complete {|curl| blk.call curl } if blk
           m.add(c)
         end
         m.perform
       end
+
+      # call-seq:
+      #
+      #   Curl::Multi.post([{:url => 'url1', :post_fields => {'field1' => 'value1', 'field2' => 'value2'}},
+      #                     {:url => 'url2', :post_fields => {'field1' => 'value1', 'field2' => 'value2'}},
+      #                     {:url => 'url3', :post_fields => {'field1' => 'value1', 'field2' => 'value2'}}],
+      #                    { :follow_location => true, :multipart_form_post => true },
+      #                    {:pipeline => true }) do|easy|
+      #     easy_handle_on_request_complete
+      #   end
+      # 
+      # Blocking call to POST multiple form's in parallel.
+      # 
+      # urls_with_config: is a hash of url's pointing to the postfields to send 
+      # easy_options: are a set of common options to set on all easy handles
+      # multi_options: options to set on the Curl::Multi handle
+      #
+      def post(urls_with_config, easy_options, multi_options, &blk)
+        m = Curl::Multi.new
+        # configure the multi handle
+        multi_options.each do|k,v|
+          m.send("#{k}=", v)
+        end
+
+        urls_with_config.each do|conf|
+          c = conf.dup # avoid being destructive to input
+          url    = c.delete(:url)
+          fields = c.delete(:post_fields)
+          easy   = Curl::Easy.new(url)
+          # set the post post using the url fields
+          easy.post_body = fields.map{|f,k| "#{easy.escape(f)}=#{easy.escape(k)}"}.join('&')
+          # configure the easy handle
+          easy_options.each do|k,v|
+            easy.send("#{k}=",v)
+          end
+          easy.on_complete {|curl| blk.call curl } if blk
+          m.add(easy)
+        end
+        m.perform
+      end
     end
   end
 end

data/tests/helper.rb

@@ -21,7 +21,7 @@ require 'webrick'
 # 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=true
+TEST_SINGLE_THREADED=false
 
 # keep webrick quiet
 class ::WEBrick::HTTPServer

data/tests/tc_curl_multi.rb

@@ -100,6 +100,50 @@ class TestCurbCurlMulti < Test::Unit::TestCase
     m = nil
 
   end
+  
+  def test_idle_check
+    m = Curl::Multi.new
+    e = Curl::Easy.new($TEST_URL)
+    
+    assert(m.idle?, 'A new Curl::Multi handle should be idle')
+    
+    m.add(e)
+    
+    assert((not m.idle?), 'A Curl::Multi handle with a request should not be idle')
+    
+    m.perform
+    
+    assert(m.idle?, 'A Curl::Multi handle should be idle after performing its requests')
+  end
+  
+  def test_requests
+    m = Curl::Multi.new
+    
+    assert_equal([], m.requests, 'A new Curl::Multi handle should have no requests')
+    
+    10.times do
+      m.add(Curl::Easy.new($TEST_URL))
+    end
+    
+    assert_equal(10, m.requests.length, 'multi.requests should contain all the active requests')
+    
+    m.perform
+    
+    assert_equal([], m.requests, 'A new Curl::Multi handle should have no requests after a perform')
+  end
+  
+  def test_cancel
+    m = Curl::Multi.new
+    m.cancel! # shouldn't raise anything
+    
+    10.times do
+      m.add(Curl::Easy.new($TEST_URL))
+    end
+    
+    m.cancel!
+    
+    assert_equal([], m.requests, 'A new Curl::Multi handle should have no requests after being canceled')
+  end
 
   def test_with_success
     c1 = Curl::Easy.new($TEST_URL)
@@ -260,6 +304,23 @@ class TestCurbCurlMulti < Test::Unit::TestCase
     end
   end
 
+  def test_multi_easy_post_01
+    urls = [
+      { :url => TestServlet.url + '?q=1', :post_fields => {'field1' => 'value1', 'k' => 'j'}},
+      { :url => TestServlet.url + '?q=2', :post_fields => {'field2' => 'value2', 'foo' => 'bar', 'i' => 'j' }},
+      { :url => TestServlet.url + '?q=3', :post_fields => {'field3' => 'value3', 'field4' => 'value4'}}
+    ]
+    Curl::Multi.post(urls, {:follow_location => true, :multipart_form_post => true}, {:pipeline => true}) do|easy|
+      str = easy.body_str
+      assert_match /POST/, str
+      fields = {}
+      str.gsub(/POST\n/,'').split('&').map{|sv| k, v = sv.split('='); fields[k] = v }
+      expected = urls.find{|s| s[:url] == easy.last_effective_url }
+      assert_equal expected[:post_fields], fields
+      #puts "#{easy.last_effective_url} #{fields.inspect}"
+    end
+  end
+
   include TestServerMethods 
 
   def setup

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: curb
 version: !ruby/object:Gem::Version 
-  version: 0.4.4.0
+  version: 0.4.8.0
 platform: ruby
 authors: 
 - Ross Bamford
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-07-12 00:00:00 -04:00
+date: 2009-07-21 00:00:00 -04:00
 default_executable: 
 dependencies: []
 
@@ -32,19 +32,19 @@ files:
 - lib/curb.rb
 - lib/curl.rb
 - ext/curb.c
-- ext/curb_postfield.c
-- ext/curb_multi.c
-- ext/curb_errors.c
 - ext/curb_easy.c
+- ext/curb_errors.c
+- ext/curb_multi.c
+- ext/curb_postfield.c
 - ext/curb_upload.c
+- ext/curb.h
+- ext/curb_config.h
 - ext/curb_easy.h
 - ext/curb_errors.h
-- ext/curb_upload.h
 - ext/curb_macros.h
-- ext/curb.h
-- ext/curb_postfield.h
-- ext/curb_config.h
 - ext/curb_multi.h
+- ext/curb_postfield.h
+- ext/curb_upload.h
 has_rdoc: true
 homepage: http://curb.rubyforge.org/
 licenses: []
@@ -76,14 +76,14 @@ signing_key:
 specification_version: 3
 summary: Ruby libcurl bindings
 test_files: 
-- tests/tc_curl_multi.rb
-- tests/tc_curl_postfield.rb
+- tests/alltests.rb
 - tests/bug_curb_easy_blocks_ruby_threads.rb
-- tests/unittests.rb
-- tests/bug_require_last_or_segfault.rb
 - tests/bug_instance_post_differs_from_class_post.rb
-- tests/tc_curl_download.rb
-- tests/alltests.rb
+- tests/bug_require_last_or_segfault.rb
 - tests/helper.rb
-- tests/tc_curl_easy.rb
 - tests/require_last_or_segfault_script.rb
+- tests/tc_curl_download.rb
+- tests/tc_curl_easy.rb
+- tests/tc_curl_multi.rb
+- tests/tc_curl_postfield.rb
+- tests/unittests.rb