do() will now allow a task to (i.e. it no longer will just free tasks when it is run).

libgearman/client.cc

@@ -562,7 +562,9 @@ gearman_return_t gearman_client_echo(gearman_client_st *client,
 void gearman_client_task_free_all(gearman_client_st *client)
 {
   while (client->task_list)
+  {
     gearman_task_free(client->task_list);
+  }
 }
 
 void gearman_client_set_task_context_free_fn(gearman_client_st *client,
@@ -1135,7 +1137,6 @@ static void *_client_do(gearman_client_st *client, gearman_command_t command,
                         size_t *result_size, gearman_return_t *ret_ptr)
 {
   gearman_task_st do_task, *do_task_ptr;
-  gearman_client_task_free_all(client);
   gearman_string_t function= { gearman_string_param_cstr(function_name) };
   gearman_unique_t local_unique= gearman_unique_make(unique, unique ? strlen(unique) : 0);
   gearman_string_t workload= { static_cast<const char*>(workload_str), workload_size };

libgearman/do.cc

@@ -50,7 +50,6 @@ void *client_do(gearman_client_st *client, gearman_command_t command,
                 size_t *result_size, gearman_return_t *ret_ptr)
 {
   gearman_task_st do_task;
-  gearman_client_task_free_all(client);
   gearman_string_t function= { gearman_string_param_cstr(function_name) };
   gearman_unique_t local_unique= gearman_unique_make(unique, unique ? strlen(unique) : 0);
   gearman_string_t workload= { static_cast<const char*>(workload_str), workload_size };

tests/client_test.cc

@@ -958,6 +958,7 @@ test_st unique_tests[] ={
 
 test_st gearman_client_do_tests[] ={
   {"gearman_client_do() fail huge unique", 0, gearman_client_do_huge_unique },
+  {"gearman_client_do() with active background task", 0, gearman_client_do_with_active_background_task },
   {0, 0, 0}
 };
 

tests/do.cc

@@ -68,3 +68,34 @@ test_return_t gearman_client_do_huge_unique(void *object)
 
   return TEST_SUCCESS;
 }
+
+test_return_t gearman_client_do_with_active_background_task(void *object)
+{
+  gearman_client_st *client= (gearman_client_st *)object;
+  const char *worker_function= (const char *)gearman_client_context(client);
+  
+  gearman_task_st *epoch_task;
+  { // Start up epoch_task
+    gearman_work_t work_description= gearman_work_epoch(time(NULL) +5, GEARMAN_JOB_PRIORITY_NORMAL);
+    gearman_argument_t value= gearman_argument_make(gearman_literal_param("test load"));
+    test_true_got(epoch_task= gearman_execute(client, gearman_c_str_param(worker_function), NULL, 0, &work_description, &value), gearman_client_error(client));
+    test_truth(epoch_task);
+    test_truth(gearman_task_job_handle(epoch_task));
+  }
+
+  gearman_string_t value= { gearman_literal_param("submit_job_test") };
+  size_t result_length;
+  gearman_return_t rc;
+  void *job_result= gearman_client_do(client, worker_function, NULL, gearman_string_param(value), &result_length, &rc);
+
+  test_true_got(rc == GEARMAN_SUCCESS, gearman_client_error(client) ? gearman_client_error(client) : gearman_strerror(rc));
+  test_truth(job_result);
+  test_compare(gearman_size(value), result_length);
+
+  test_memcmp(gearman_c_str(value), job_result, gearman_size(value));
+
+  free(job_result);
+  gearman_task_free(epoch_task);
+
+  return TEST_SUCCESS;
+}

tests/do.h

@@ -40,3 +40,5 @@
 #include <libtest/test.h>
 
 test_return_t gearman_client_do_huge_unique(void *);
+
+test_return_t gearman_client_do_with_active_background_task(void *);

tests/worker_test.cc

@@ -312,14 +312,12 @@ static test_return_t echo_max_test(void *object)
 
 static test_return_t abandoned_worker_test(void *)
 {
-  char job_handle[GEARMAN_JOB_HANDLE_SIZE];
-  gearman_packet_st packet;
+  gearman_job_handle_t job_handle;
   const void *args[2];
   size_t args_size[2];
 
   {
-    gearman_client_st *client;
-    client= gearman_client_create(NULL);
+    gearman_client_st *client= gearman_client_create(NULL);
     test_truth(client);
     gearman_client_add_server(client, NULL, WORKER_TEST_PORT);
     test_true_got(gearman_success(gearman_client_do_background(client, "abandoned_worker", NULL, NULL, 0, job_handle)), gearman_client_error(client));
@@ -335,17 +333,18 @@ static test_return_t abandoned_worker_test(void *)
 
   worker1->set_host(NULL, WORKER_TEST_PORT);
 
+  gearman_packet_st packet;
   args[0]= "abandoned_worker";
   args_size[0]= strlen("abandoned_worker");
   test_truth(gearman_success(gearman_packet_create_args(universal, packet, GEARMAN_MAGIC_REQUEST,
 							GEARMAN_COMMAND_CAN_DO,
 							args, args_size, 1)));
 
-  gearman_return_t ret;
-  test_true_got(gearman_success(ret= worker1->send(packet, true)), gearman_universal_error(universal));
+  test_true_got(gearman_success(worker1->send(packet, true)), gearman_universal_error(universal));
 
   gearman_packet_free(&packet);
 
+  gearman_return_t ret;
   test_true_got(gearman_success(ret= gearman_packet_create_args(universal, packet, GEARMAN_MAGIC_REQUEST,
                                                                 GEARMAN_COMMAND_GRAB_JOB,
                                                                 NULL, NULL, 0)), gearman_strerror(ret));