← Back to branch summary

~fractalcat/gearmand/docfixes

« back to all changes in this revision

Viewing changes to tests/libgearman-1.0/unique.cc

  • Committer: Brian Aker
  • Date: 2012-12-13 11:44:26 UTC
  • mto: (621.4.66 workspace)
  • mto: This revision was merged to the branch mainline in revision 676.
  • Revision ID: brian@tangent.org-20121213114426-lnrt6aysy7lqc01h
Adding support for deriving the unique value based on the data that is supplied by the client.

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/libgearman-1.0/unique.cc
145
145
  return TEST_SUCCESS;
146
146
}
147
147
 
 
148
test_return_t coalescence_by_data_hash_TEST(void *object)
 
149
{
 
150
  gearman_client_st *client_one= (gearman_client_st *)object;
 
151
  test_true(client_one);
 
152
 
 
153
  Client client_two(client_one);
 
154
 
 
155
  const char* unique_handle= "#";
 
156
 
 
157
  gearman_function_t sleep_return_random_worker_FN= gearman_function_create(sleep_return_random_worker);
 
158
  std::auto_ptr<worker_handle_st> handle(test_worker_start(libtest::default_port(),
 
159
                                                           NULL,
 
160
                                                           __func__,
 
161
                                                           sleep_return_random_worker_FN,
 
162
                                                           NULL,
 
163
                                                           gearman_worker_options_t(),
 
164
                                                           0)); // timeout
 
165
 
 
166
  // First task
 
167
  gearman_return_t ret;
 
168
  gearman_task_st *first_task= gearman_client_add_task(client_one,
 
169
                                                       NULL, // preallocated task
 
170
                                                       NULL, // context 
 
171
                                                       __func__, // function
 
172
                                                       unique_handle, // unique
 
173
                                                       test_literal_param(__func__), // workload
 
174
                                                       &ret);
 
175
  test_compare(GEARMAN_SUCCESS, ret);
 
176
  test_truth(first_task);
 
177
  test_true(gearman_task_unique(first_task));
 
178
  test_compare(strlen("2285535048"), strlen(gearman_task_unique(first_task)));
 
179
 
 
180
  // Second task
 
181
  gearman_task_st *second_task= gearman_client_add_task(&client_two,
 
182
                                                        NULL, // preallocated task
 
183
                                                        NULL, // context 
 
184
                                                        __func__, // function
 
185
                                                        unique_handle, // unique
 
186
                                                        test_literal_param(__func__), // workload
 
187
                                                        &ret);
 
188
  test_compare(GEARMAN_SUCCESS, ret);
 
189
  test_truth(second_task);
 
190
  test_true(gearman_task_unique(second_task));
 
191
  test_compare(strlen("2285535048"), strlen(gearman_task_unique(second_task)));
 
192
  
 
193
  test_strcmp(gearman_task_unique(first_task), gearman_task_unique(second_task));
 
194
  test_strcmp("2285535048", gearman_task_unique(second_task));
 
195
 
 
196
  do {
 
197
    ret= gearman_client_run_tasks(client_one);
 
198
    gearman_client_run_tasks(&client_two);
 
199
  } while (gearman_continue(ret));
 
200
 
 
201
  do {
 
202
    ret= gearman_client_run_tasks(&client_two);
 
203
  } while (gearman_continue(ret));
 
204
 
 
205
  gearman_result_st* first_result= gearman_task_result(first_task);
 
206
  gearman_result_st* second_result= gearman_task_result(second_task);
 
207
 
 
208
  test_compare(GEARMAN_SUCCESS, gearman_task_return(first_task));
 
209
  test_compare(GEARMAN_SUCCESS, gearman_task_return(second_task));
 
210
 
 
211
  test_compare(gearman_result_value(first_result), gearman_result_value(second_result));
 
212
 
 
213
  gearman_task_free(first_task);
 
214
  gearman_task_free(second_task);
 
215
 
 
216
  return TEST_SUCCESS;
 
217
}
 
218
 
148
219
test_return_t coalescence_by_data_TEST(void *object)
149
220
{
150
221
  gearman_client_st *client_one= (gearman_client_st *)object;