← Back to branch summary

~clint-fewbar/gearmand/fix-postgresql-path

« back to all changes in this revision

Viewing changes to tests/gearman_execute_partition.cc

  • Committer: Brian Aker
  • Date: 2011-07-21 04:50:58 UTC
  • mto: This revision was merged to the branch mainline in revision 442.
  • Revision ID: brian@tangent.org-20110721045058-tadgpgkjrf472rwy
Update all of test framework

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/gearman_execute_partition.cc
50
50
{
51
51
  gearman_client_st *client= (gearman_client_st *)object;
52
52
 
53
 
  test_true_got(gearman_success(gearman_client_echo(client, gearman_literal_param("this is mine"))), gearman_client_error(client));
 
53
  test_true_got(gearman_success(gearman_client_echo(client, test_literal_param("this is mine"))), gearman_client_error(client));
54
54
 
55
55
  // This just hear to make it easier to trace when gearman_execute() is
56
56
  // called (look in the log to see the failed option setting.
57
 
  gearman_client_set_server_option(client, gearman_literal_param("should fail"));
58
 
  gearman_argument_t workload= gearman_argument_make(0, 0, gearman_literal_param("this dog does not hunt"));
 
57
  gearman_client_set_server_option(client, test_literal_param("should fail"));
 
58
  gearman_argument_t workload= gearman_argument_make(0, 0, test_literal_param("this dog does not hunt"));
59
59
 
60
60
  gearman_task_st *task;
61
61
 
62
62
  // Test client as NULL
63
63
  test_false(task= gearman_execute_by_partition(NULL,
64
 
                                                gearman_literal_param("split_worker"),
65
 
                                                gearman_literal_param("client_test"),
 
64
                                                test_literal_param("split_worker"),
 
65
                                                test_literal_param("client_test"),
66
66
                                                NULL, 0,  // unique
67
67
                                                NULL,
68
68
                                                &workload, 0));
82
82
{
83
83
  gearman_client_st *client= (gearman_client_st *)object;
84
84
 
85
 
  test_true_got(gearman_success(gearman_client_echo(client, gearman_literal_param("this is mine"))), gearman_client_error(client));
 
85
  test_true_got(gearman_success(gearman_client_echo(client, test_literal_param("this is mine"))), gearman_client_error(client));
86
86
 
87
87
  // This just hear to make it easier to trace when
88
88
  // gearman_execute_partition() is called (look in the log to see the
89
89
  // failed option setting.
90
 
  gearman_client_set_server_option(client, gearman_literal_param("should fail"));
91
 
  gearman_argument_t workload= gearman_argument_make(0, 0, gearman_literal_param("this dog does not hunt"));
 
90
  gearman_client_set_server_option(client, test_literal_param("should fail"));
 
91
  gearman_argument_t workload= gearman_argument_make(0, 0, test_literal_param("this dog does not hunt"));
92
92
 
93
93
  gearman_task_st *task;
94
94
  test_true_got(task= gearman_execute_by_partition(client,
95
 
                                                   gearman_literal_param("split_worker"),
96
 
                                                   gearman_literal_param("client_test"),
 
95
                                                   test_literal_param("split_worker"),
 
96
                                                   test_literal_param("client_test"),
97
97
                                                   NULL, 0,  // unique
98
98
                                                   NULL,
99
99
                                                   &workload, 0), gearman_client_error(client));
100
100
 
101
 
  gearman_return_t rc;
102
 
  test_true_got(gearman_success(rc= gearman_task_return(task)), gearman_client_error(client) ? gearman_client_error(client) : gearman_strerror(rc));
 
101
  test_compare(GEARMAN_SUCCESS, gearman_task_return(task));
103
102
  gearman_result_st *result= gearman_task_result(task);
104
103
  test_truth(result);
105
104
  const char *value= gearman_result_value(result);
106
105
  test_truth(value);
107
 
  test_compare(18, gearman_result_size(result));
 
106
  test_compare(18UL, gearman_result_size(result));
108
107
 
109
108
  gearman_task_free(task);
110
109
  gearman_client_task_free_all(client);
117
116
  gearman_client_st *client= (gearman_client_st *)object;
118
117
  const char *worker_function= (const char *)gearman_client_context(client);
119
118
 
120
 
  test_true_got(gearman_success(gearman_client_echo(client, gearman_literal_param("this is mine"))), gearman_client_error(client));
 
119
  test_true_got(gearman_success(gearman_client_echo(client, test_literal_param("this is mine"))), gearman_client_error(client));
121
120
 
122
 
  gearman_argument_t workload= gearman_argument_make(0, 0, gearman_literal_param("this dog does not hunt mapper_fail"));
 
121
  gearman_argument_t workload= gearman_argument_make(0, 0, test_literal_param("this dog does not hunt mapper_fail"));
123
122
 
124
123
  gearman_task_st *task;
125
124
  test_true_got(task= gearman_execute_by_partition(client,
126
 
                                                   gearman_literal_param("split_worker"),
 
125
                                                   test_literal_param("split_worker"),
127
126
                                                   gearman_string_param_cstr(worker_function),
128
127
                                                   NULL, 0,  // unique
129
128
                                                   NULL,
142
141
  gearman_client_st *client= (gearman_client_st *)object;
143
142
  const char *worker_function= (const char *)gearman_client_context(client);
144
143
 
145
 
  test_true_got(gearman_success(gearman_client_echo(client, gearman_literal_param("this is mine"))), gearman_client_error(client));
 
144
  test_true_got(gearman_success(gearman_client_echo(client, test_literal_param("this is mine"))), gearman_client_error(client));
146
145
 
147
 
  gearman_argument_t workload= gearman_argument_make(0, 0, gearman_literal_param("this dog does not hunt fail"));
 
146
  gearman_argument_t workload= gearman_argument_make(0, 0, test_literal_param("this dog does not hunt fail"));
148
147
 
149
148
  gearman_task_st *task;
150
149
  test_true_got(task= gearman_execute_by_partition(client,
151
 
                                                   gearman_literal_param("split_worker"),
 
150
                                                   test_literal_param("split_worker"),
152
151
                                                   gearman_string_param_cstr(worker_function),
153
152
                                                   NULL, 0,  // unique
154
153
                                                   NULL,
166
165
{
167
166
  gearman_client_st *client= (gearman_client_st *)object;
168
167
 
169
 
  test_true_got(gearman_success(gearman_client_echo(client, gearman_literal_param("this is mine"))), gearman_client_error(client));
 
168
  test_true_got(gearman_success(gearman_client_echo(client, test_literal_param("this is mine"))), gearman_client_error(client));
170
169
 
171
170
  // This just hear to make it easier to trace when
172
171
  // gearman_execute_partition() is called (look in the log to see the
173
172
  // failed option setting.
174
 
  gearman_client_set_server_option(client, gearman_literal_param("should fail"));
175
 
  gearman_argument_t workload= gearman_argument_make(0, 0, gearman_literal_param("this dog does not hunt"));
 
173
  gearman_client_set_server_option(client, test_literal_param("should fail"));
 
174
  gearman_argument_t workload= gearman_argument_make(0, 0, test_literal_param("this dog does not hunt"));
176
175
 
177
176
  gearman_task_st *task;
178
177
  test_true_got(task= gearman_execute(client,
179
 
                                      gearman_literal_param("split_worker"),
 
178
                                      test_literal_param("split_worker"),
180
179
                                      NULL, 0,  // unique
181
180
                                      NULL,
182
181
                                      &workload, 0), gearman_client_error(client));
183
182
 
184
 
  gearman_return_t rc;
185
 
  test_true_got(gearman_success(rc= gearman_task_return(task)), gearman_client_error(client) ? gearman_client_error(client) : gearman_strerror(rc));
 
183
  test_compare(GEARMAN_SUCCESS, gearman_task_return(task));
186
184
  gearman_result_st *result= gearman_task_result(task);
187
185
  test_truth(result);
188
186
  const char *value= gearman_result_value(result);
189
187
  test_truth(value);
190
 
  test_compare(18, gearman_result_size(result));
 
188
  test_compare(18UL, gearman_result_size(result));
191
189
 
192
190
  gearman_task_free(task);
193
191
  gearman_client_task_free_all(client);
199
197
{
200
198
  gearman_client_st *client= (gearman_client_st *)object;
201
199
 
202
 
  gearman_argument_t workload= gearman_argument_make(0, 0, gearman_literal_param("this dog does not hunt"));
 
200
  gearman_argument_t workload= gearman_argument_make(0, 0, test_literal_param("this dog does not hunt"));
203
201
 
204
202
  gearman_task_st *task;
205
203
  test_true_got(task= gearman_execute_by_partition(client,
206
 
                                                   gearman_literal_param("client_test"),
207
 
                                                   gearman_literal_param("count"),
 
204
                                                   test_literal_param("client_test"),
 
205
                                                   test_literal_param("count"),
208
206
                                                   NULL, 0,  // unique
209
207
                                                   NULL,
210
208
                                                   &workload, 0), gearman_client_error(client));