Fix it so that is_known and is_running are a bit more accurate.

libgearman/client.cc

@@ -529,8 +529,11 @@ gearman_return_t gearman_client_job_status(gearman_client_st *client,
 
   gearman_task_clear_fn(do_task_ptr);
 
-  ret= gearman_client_run_tasks(client);
-  if (ret != GEARMAN_IO_WAIT)
+  do {
+    ret= gearman_client_run_tasks(client);
+  } while (gearman_continue(ret));
+
+  if (gearman_success(ret))
   {
     if (is_known)
       *is_known= do_task.options.is_known;

libgearman/execute.cc

@@ -145,6 +145,15 @@ gearman_task_st *gearman_execute(gearman_client_st *client,
 
   gearman_client_run_tasks(client);
 
+#if 0
+  gearman_task_st *check_task= client->task_list;
+  std::cerr << std::endl;
+  do
+  {
+    std::cerr << __func__ << " " << gearman_task_job_handle(check_task) << " " << gearman_strerror(check_task->result_rc) << " " << check_task->options.is_known << std::endl;
+  } while ((check_task= gearman_next(check_task)));
+#endif
+
   return task;
 }
 

libgearman/run.cc

@@ -155,6 +155,7 @@ gearman_return_t _client_run_task(gearman_client_st *client, gearman_task_st *ta
   case GEARMAN_TASK_STATE_WORK:
     if (task->recv->command == GEARMAN_COMMAND_JOB_CREATED)
     {
+      task->options.is_known= true;
       snprintf(task->job_handle, GEARMAN_JOB_HANDLE_SIZE, "%.*s",
                int(task->recv->arg_size[0]),
                static_cast<char *>(task->recv->arg[0]));
@@ -181,6 +182,9 @@ gearman_return_t _client_run_task(gearman_client_st *client, gearman_task_st *ta
     }
     else if (task->recv->command == GEARMAN_COMMAND_WORK_DATA)
     {
+      task->options.is_known= true;
+      task->options.is_running= true;
+
   case GEARMAN_TASK_STATE_DATA:
       if (task->func.data_fn)
       {
@@ -248,10 +252,14 @@ gearman_return_t _client_run_task(gearman_client_st *client, gearman_task_st *ta
       }
 
       if (task->send.command == GEARMAN_COMMAND_GET_STATUS)
+      {
         break;
+      }
     }
     else if (task->recv->command == GEARMAN_COMMAND_WORK_COMPLETE)
     {
+      task->options.is_known= false;
+      task->options.is_running= false;
       task->result_rc= GEARMAN_SUCCESS;
 
   case GEARMAN_TASK_STATE_COMPLETE:
@@ -284,6 +292,8 @@ gearman_return_t _client_run_task(gearman_client_st *client, gearman_task_st *ta
     {
       // If things fail we need to delete the result, and set the result_rc
       // correctly.
+      task->options.is_known= false;
+      task->options.is_running= false;
       delete task->result_ptr;
       task->result_ptr= NULL;
       task->result_rc= GEARMAN_WORK_FAIL;

tests/basic.cc

@@ -146,7 +146,7 @@ test_return_t queue_add(void *object)
 {
   Context *test= (Context *)object;
   gearman_client_st client, *client_ptr;
-  char job_handle[GEARMAN_JOB_HANDLE_SIZE]= {};
+  gearman_job_handle_t job_handle= {};
   test_truth(test);
 
   test->run_worker= false;
@@ -232,7 +232,7 @@ test_return_t lp_734663(void *object)
 
   for (uint32_t x= 0; x < NUMBER_OF_JOBS; x++)
   {
-    char job_handle[GEARMAN_JOB_HANDLE_SIZE]= {};
+    gearman_job_handle_t job_handle= {};
     gearman_return_t rc= gearman_client_do_background(&client, worker_function_name, NULL, value, sizeof(value), job_handle);
     test_truth(rc == GEARMAN_SUCCESS);
     test_truth(job_handle[0]);

tests/client_test.cc

@@ -581,7 +581,7 @@ static test_return_t background_test(void *object)
   const char *worker_function= (const char *)gearman_client_context(client);
   test_truth(worker_function);
 
-  char job_handle[GEARMAN_JOB_HANDLE_SIZE];
+  gearman_job_handle_t job_handle;
   test_compare_got(GEARMAN_SUCCESS,
                    gearman_client_do_background(client, worker_function, NULL, gearman_string_param(value), job_handle), 
                    gearman_client_error(client));
@@ -606,7 +606,7 @@ static test_return_t background_test(void *object)
 static test_return_t background_failure_test(void *object)
 {
   gearman_client_st *client= (gearman_client_st *)object;
-  char job_handle[GEARMAN_JOB_HANDLE_SIZE];
+  gearman_job_handle_t job_handle;
   bool is_known;
   bool is_running;
   uint32_t numerator;
@@ -1040,7 +1040,8 @@ test_st gearman_execute_tests[] ={
   {"gearman_execute()", 0, gearman_execute_test },
   {"gearman_execute(GEARMAN_WORK_FAIL)", 0, gearman_execute_fail_test },
   {"gearman_execute() epoch", 0, gearman_execute_epoch_test },
-  {"gearman_execute() timeout", 0, gearman_execute_timeout_test },
+  {"gearman_execute() epoch and test gearman_job_handle_t", 0, gearman_execute_epoch_check_job_handle_test },
+  {"gearman_execute(GEARMAN_TIMEOUT)", 0, gearman_execute_timeout_test },
   {"gearman_execute() background", 0, gearman_execute_bg_test },
   {"gearman_execute() multiple background", 0, gearman_execute_multile_bg_test },
   {0, 0, 0}

tests/execute.cc

@@ -57,6 +57,8 @@ test_return_t gearman_execute_test(void *object)
 
   test_true_got(task= gearman_execute(client, gearman_c_str_param(worker_function), NULL, 0, NULL, &value), gearman_client_error(client));
   test_compare(gearman_literal_param_size("test load"), gearman_result_size(gearman_task_result(task)));
+  test_false(gearman_task_is_known(task));
+  test_false(gearman_task_is_running(task));
 
   gearman_task_free(task);
 
@@ -74,6 +76,8 @@ test_return_t gearman_execute_fail_test(void *object)
 
   test_true_got(task= gearman_execute(client, gearman_c_str_param(worker_function), NULL, 0, NULL, &value), gearman_client_error(client));
   test_compare_got(GEARMAN_WORK_FAIL, gearman_task_error(task), gearman_strerror(gearman_task_error(task)));
+  test_false(gearman_task_is_known(task));
+  test_false(gearman_task_is_running(task));
 
   gearman_task_free(task);
 
@@ -112,6 +116,35 @@ test_return_t gearman_execute_epoch_test(void *object)
   test_true_got(task= gearman_execute(client, gearman_c_str_param(worker_function), NULL, 0, &workload, &value), gearman_client_error(client));
   test_truth(task);
   test_truth(gearman_task_job_handle(task));
+  test_true(gearman_task_is_known(task));
+  test_false(gearman_task_is_running(task));
+  gearman_task_free(task);
+
+  return TEST_SUCCESS;
+}
+
+test_return_t gearman_execute_epoch_check_job_handle_test(void *object)
+{
+  gearman_client_st *client= (gearman_client_st *)object;
+  const char *worker_function= (const char *)gearman_client_context(client);
+  assert(worker_function);
+
+  gearman_work_t workload= gearman_work_epoch(time(NULL) +5, GEARMAN_JOB_PRIORITY_NORMAL);
+
+  gearman_task_st *task;
+  gearman_argument_t value= gearman_argument_make(gearman_literal_param("test load"));
+  test_true_got(task= gearman_execute(client, gearman_c_str_param(worker_function), NULL, 0, &workload, &value), gearman_client_error(client));
+
+  test_truth(task);
+  test_truth(gearman_task_job_handle(task));
+
+  gearman_return_t rc;
+  bool is_known;
+  do {
+    rc= gearman_client_job_status(client, gearman_task_job_handle(task), &is_known, NULL, NULL, NULL);
+  }  while (gearman_continue(rc) or is_known);
+  test_compare(GEARMAN_SUCCESS, rc);
+
   gearman_task_free(task);
 
   return TEST_SUCCESS;

tests/execute.h

@@ -41,5 +41,6 @@ test_return_t gearman_execute_test(void *object);
 test_return_t gearman_execute_fail_test(void *object);
 test_return_t gearman_execute_timeout_test(void *object);
 test_return_t gearman_execute_epoch_test(void *object);
+test_return_t gearman_execute_epoch_check_job_handle_test(void *object);
 test_return_t gearman_execute_bg_test(void *object);
 test_return_t gearman_execute_multile_bg_test(void *object);