~brianaker/libmemcached/1164440

const char *server_string= "--server=localhost:4444 --server=localhost:4445 --server=localhost:4446 --server=localhost:4447 --server=localhost --server=memcache1.memcache.bk.sapo.pt:11211 --server=memcache1.memcache.bk.sapo.pt:11212 --server=memcache1.memcache.bk.sapo.pt:11213 --server=memcache1.memcache.bk.sapo.pt:11214 --server=memcache2.memcache.bk.sapo.pt:11211 --server=memcache2.memcache.bk.sapo.pt:11212 --server=memcache2.memcache.bk.sapo.pt:11213 --server=memcache2.memcache.bk.sapo.pt:11214";

378

char buffer[BUFSIZ];

379

380

test_compare(MEMCACHED_SUCCESS,

381

libmemcached_check_configuration(server_string, strlen(server_string), buffer, sizeof(buffer)));

382

memcached_st *memc= memcached(server_string, strlen(server_string));

383

test_true(memc);

384

385

memcached_server_fn callbacks[1];

386

callbacks[0]= server_print_callback;

387

memcached_server_cursor(memc, callbacks, NULL, 1);

388

389

memcached_free(memc);

390

391

return TEST_SUCCESS;

392

}

393

394

static memcached_return_t server_display_unsort_function(const memcached_st*,

395

const memcached_server_st *server,

396

void *context)

106

397

{

107

398

/* Do Nothing */

108

399

uint32_t x= *((uint32_t *)(context));

109

400

110

assert(test_ports[x] == server->port);

401

if (! (test_ports[x] == server->port))

402

{

403

fprintf(stderr, "%lu -> %lu\n", (unsigned long)test_ports[x], (unsigned long)server->port);

404

return MEMCACHED_FAILURE;

405

}

406

111

407

*((uint32_t *)(context))= ++x;

112

408

113

409

return MEMCACHED_SUCCESS;

114

410

}

115

411

116

test_return server_unsort_test(memcached_st *ptr)

412

test_return_t server_unsort_test(memcached_st *ptr)

117

413

{

118

uint8_t x;

119

uint32_t counter= 0; /* Prime the value for the assert in server_display_function */

120

uint32_t bigger= 0; /* Prime the value for the assert in server_display_function */

121

memcached_return rc;

122

memcached_server_function callbacks[1];

414

size_t counter= 0; /* Prime the value for the test_true in server_display_function */

415

size_t bigger= 0; /* Prime the value for the test_true in server_display_function */

416

memcached_server_fn callbacks[1];

123

417

memcached_st *local_memc;

418

(void)ptr;

124

419

125

420

local_memc= memcached_create(NULL);

126

assert(local_memc);

421

test_true(local_memc);

127

422

128

for (x= 0; x < TEST_PORT_COUNT; x++)

423

for (uint32_t x= 0; x < TEST_PORT_COUNT; x++)

129

424

{

130

test_ports[x]= random() % 64000;

131

rc= memcached_server_add(local_memc, "localhost", test_ports[x]);

132

assert(local_memc->number_of_hosts == x+1);

133

assert(local_memc->hosts[0].count == x+1);

134

assert(rc == MEMCACHED_SUCCESS);

425

test_ports[x]= (in_port_t)(random() % 64000);

426

test_compare(MEMCACHED_SUCCESS,

427

memcached_server_add_with_weight(local_memc, "localhost", test_ports[x], 0));

428

test_compare(memcached_server_count(local_memc), x +1);

429

#if 0 // Rewrite

430

test_true(memcached_server_list_count(memcached_server_list(local_memc)) == x+1);

431

#endif

135

432

}

136

433

137

434

callbacks[0]= server_display_unsort_function;

145

442

146

443

memcached_free(local_memc);

147

444

148

return 0;

445

return TEST_SUCCESS;

149

446

}

150

447

151

test_return allocation_test(memcached_st *not_used)

448

test_return_t allocation_test(memcached_st *not_used)

152

449

{

450

(void)not_used;

153

451

memcached_st *memc;

154

452

memc= memcached_create(NULL);

155

assert(memc);

453

test_true(memc);

156

454

memcached_free(memc);

157

455

158

return 0;

456

return TEST_SUCCESS;

159

457

}

160

458

161

test_return clone_test(memcached_st *memc)

459

test_return_t clone_test(memcached_st *memc)

162

460

{

163

461

/* All null? */

164

462

{

165

memcached_st *clone;

166

clone= memcached_clone(NULL, NULL);

167

assert(clone);

168

memcached_free(clone);

463

memcached_st *memc_clone;

464

memc_clone= memcached_clone(NULL, NULL);

465

test_true(memc_clone);

466

memcached_free(memc_clone);

169

467

}

170

468

171

469

/* Can we init from null? */

172

470

{

173

memcached_st *clone;

174

clone= memcached_clone(NULL, memc);

175

assert(clone);

176

memcached_free(clone);

177

}

178

179

/* Can we init from struct? */

180

{

181

memcached_st declared_clone;

182

memcached_st *clone;

183

clone= memcached_clone(&declared_clone, NULL);

184

assert(clone);

185

memcached_free(clone);

186

}

187

188

/* Can we init from struct? */

189

{

190

memcached_st declared_clone;

191

memcached_st *clone;

192

clone= memcached_clone(&declared_clone, memc);

193

assert(clone);

194

memcached_free(clone);

195

}

196

197

return 0;

198

}

199

200

test_return connection_test(memcached_st *memc)

201

{

202

memcached_return rc;

203

204

rc= memcached_server_add(memc, "localhost", 0);

205

assert(rc == MEMCACHED_SUCCESS);

206

207

return 0;

208

}

209

210

test_return error_test(memcached_st *memc)

211

{

212

memcached_return rc;

213

214

for (rc= MEMCACHED_SUCCESS; rc < MEMCACHED_MAXIMUM_RETURN; rc++)

215

{

216

printf("Error %d -> %s\n", rc, memcached_strerror(memc, rc));

217

}

218

219

return 0;

220

}

221

222

test_return set_test(memcached_st *memc)

223

{

224

memcached_return rc;

225

char *key= "foo";

226

char *value= "when we sanitize";

227

228

rc= memcached_set(memc, key, strlen(key),

229

value, strlen(value),

230

(time_t)0, (uint32_t)0);

231

assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);

232

233

return 0;

234

}

235

236

test_return append_test(memcached_st *memc)

237

{

238

memcached_return rc;

239

char *key= "fig";

240

char *value= "we";

241

size_t value_length;

242

uint32_t flags;

243

244

rc= memcached_flush(memc, 0);

245

assert(rc == MEMCACHED_SUCCESS);

246

247

rc= memcached_set(memc, key, strlen(key),

248

value, strlen(value),

249

(time_t)0, (uint32_t)0);

250

assert(rc == MEMCACHED_SUCCESS);

251

252

rc= memcached_append(memc, key, strlen(key),

253

" the", strlen(" the"),

254

(time_t)0, (uint32_t)0);

255

assert(rc == MEMCACHED_SUCCESS);

256

257

rc= memcached_append(memc, key, strlen(key),

258

" people", strlen(" people"),

259

(time_t)0, (uint32_t)0);

260

assert(rc == MEMCACHED_SUCCESS);

261

262

value= memcached_get(memc, key, strlen(key),

263

&value_length, &flags, &rc);

264

assert(!memcmp(value, "we the people", strlen("we the people")));

265

assert(strlen("we the people") == value_length);

266

assert(rc == MEMCACHED_SUCCESS);

267

free(value);

268

269

return 0;

270

}

271

272

test_return append_binary_test(memcached_st *memc)

273

{

274

memcached_return rc;

275

char *key= "numbers";

276

unsigned int *store_ptr;

277

unsigned int store_list[] = { 23, 56, 499, 98, 32847, 0 };

278

char *value;

279

size_t value_length;

280

uint32_t flags;

281

unsigned int x;

282

283

rc= memcached_flush(memc, 0);

284

assert(rc == MEMCACHED_SUCCESS);

285

286

rc= memcached_set(memc,

287

key, strlen(key),

288

NULL, 0,

289

(time_t)0, (uint32_t)0);

290

assert(rc == MEMCACHED_SUCCESS);

291

292

for (x= 0; store_list[x] ; x++)

293

{

294

rc= memcached_append(memc,

295

key, strlen(key),

296

(char *)&store_list[x], sizeof(unsigned int),

297

(time_t)0, (uint32_t)0);

298

assert(rc == MEMCACHED_SUCCESS);

299

}

300

301

value= memcached_get(memc, key, strlen(key),

302

&value_length, &flags, &rc);

303

assert((value_length == (sizeof(unsigned int) * x)));

304

assert(rc == MEMCACHED_SUCCESS);

305

306

store_ptr= (unsigned int *)value;

307

x= 0;

308

while ((size_t)store_ptr < (size_t)(value + value_length))

309

{

310

assert(*store_ptr == store_list[x++]);

311

store_ptr++;

312

}

313

free(value);

314

315

return 0;

316

}

317

318

test_return cas2_test(memcached_st *memc)

319

{

320

memcached_return rc;

321

char *keys[]= {"fudge", "son", "food"};

471

memcached_st *memc_clone;

472

memc_clone= memcached_clone(NULL, memc);

473

test_true(memc_clone);

474

475

{ // Test allocators

476

test_true(memc_clone->allocators.free == memc->allocators.free);

477

test_true(memc_clone->allocators.malloc == memc->allocators.malloc);

478

test_true(memc_clone->allocators.realloc == memc->allocators.realloc);

479

test_true(memc_clone->allocators.calloc == memc->allocators.calloc);

480

}

481

482

test_true(memc_clone->connect_timeout == memc->connect_timeout);

483

test_true(memc_clone->delete_trigger == memc->delete_trigger);

484

test_true(memc_clone->distribution == memc->distribution);

485

{ // Test all of the flags

486

test_true(memc_clone->flags.no_block == memc->flags.no_block);

487

test_true(memc_clone->flags.tcp_nodelay == memc->flags.tcp_nodelay);

488

test_true(memc_clone->flags.support_cas == memc->flags.support_cas);

489

test_true(memc_clone->flags.buffer_requests == memc->flags.buffer_requests);

490

test_true(memc_clone->flags.use_sort_hosts == memc->flags.use_sort_hosts);

491

test_true(memc_clone->flags.verify_key == memc->flags.verify_key);

492

test_true(memc_clone->ketama.weighted == memc->ketama.weighted);

493

test_true(memc_clone->flags.binary_protocol == memc->flags.binary_protocol);

494

test_true(memc_clone->flags.hash_with_namespace == memc->flags.hash_with_namespace);

495

test_true(memc_clone->flags.reply == memc->flags.reply);

496

test_true(memc_clone->flags.use_udp == memc->flags.use_udp);

497

test_true(memc_clone->flags.auto_eject_hosts == memc->flags.auto_eject_hosts);

498

test_true(memc_clone->flags.randomize_replica_read == memc->flags.randomize_replica_read);

499

}

500

test_true(memc_clone->get_key_failure == memc->get_key_failure);

501

test_true(hashkit_compare(&memc_clone->hashkit, &memc->hashkit));

502

test_true(memc_clone->io_bytes_watermark == memc->io_bytes_watermark);

503

test_true(memc_clone->io_msg_watermark == memc->io_msg_watermark);

504

test_true(memc_clone->io_key_prefetch == memc->io_key_prefetch);

505

test_true(memc_clone->on_cleanup == memc->on_cleanup);

506

test_true(memc_clone->on_clone == memc->on_clone);

507

test_true(memc_clone->poll_timeout == memc->poll_timeout);

508

test_true(memc_clone->rcv_timeout == memc->rcv_timeout);

509

test_true(memc_clone->recv_size == memc->recv_size);

510

test_true(memc_clone->retry_timeout == memc->retry_timeout);

511

test_true(memc_clone->send_size == memc->send_size);

512

test_true(memc_clone->server_failure_limit == memc->server_failure_limit);

513

test_true(memc_clone->snd_timeout == memc->snd_timeout);

514

test_true(memc_clone->user_data == memc->user_data);

515

516

memcached_free(memc_clone);

517

}

518

519

/* Can we init from struct? */

520

{

521

memcached_st declared_clone;

522

memcached_st *memc_clone;

523

memset(&declared_clone, 0 , sizeof(memcached_st));

524

memc_clone= memcached_clone(&declared_clone, NULL);

525

test_true(memc_clone);

526

memcached_free(memc_clone);

527

}

528

529

/* Can we init from struct? */

530

{

531

memcached_st declared_clone;

532

memcached_st *memc_clone;

533

memset(&declared_clone, 0 , sizeof(memcached_st));

534

memc_clone= memcached_clone(&declared_clone, memc);

535

test_true(memc_clone);

536

memcached_free(memc_clone);

537

}

538

539

return TEST_SUCCESS;

540

}

541

542

test_return_t userdata_test(memcached_st *memc)

543

{

544

void* foo= NULL;

545

test_false(memcached_set_user_data(memc, foo));

546

test_true(memcached_get_user_data(memc) == foo);

547

test_true(memcached_set_user_data(memc, NULL) == foo);

548

549

return TEST_SUCCESS;

550

}

551

552

test_return_t connection_test(memcached_st *memc)

553

{

554

test_compare(MEMCACHED_SUCCESS,

555

memcached_server_add_with_weight(memc, "localhost", 0, 0));

556

557

return TEST_SUCCESS;

558

}

559

560

test_return_t libmemcached_string_behavior_test(memcached_st *)

561

{

562

for (int x= MEMCACHED_BEHAVIOR_NO_BLOCK; x < int(MEMCACHED_BEHAVIOR_MAX); ++x)

563

{

564

test_true(libmemcached_string_behavior(memcached_behavior_t(x)));

565

}

566

test_compare(37, int(MEMCACHED_BEHAVIOR_MAX));

567

568

return TEST_SUCCESS;

569

}

570

571

test_return_t libmemcached_string_distribution_test(memcached_st *)

572

{

573

for (int x= MEMCACHED_DISTRIBUTION_MODULA; x < int(MEMCACHED_DISTRIBUTION_CONSISTENT_MAX); ++x)

574

{

575

test_true(libmemcached_string_distribution(memcached_server_distribution_t(x)));

576

}

577

test_compare(7, int(MEMCACHED_DISTRIBUTION_CONSISTENT_MAX));

578

579

return TEST_SUCCESS;

580

}

581

582

test_return_t memcached_return_t_TEST(memcached_st *memc)

583

{

584

uint32_t values[] = { 851992627U, 2337886783U, 4109241422U, 4001849190U,

585

982370485U, 1263635348U, 4242906218U, 3829656100U,

586

1891735253U, 334139633U, 2257084983U, 3351789013U,

587

13199785U, 2542027183U, 1097051614U, 199566778U,

588

2748246961U, 2465192557U, 1664094137U, 2405439045U,

589

1842224848U, 692413798U, 3479807801U, 919913813U,

590

4269430871U, 610793021U, 527273862U, 1437122909U,

591

2300930706U, 2943759320U, 674306647U, 2400528935U,

592

54481931U, 4186304426U, 1741088401U, 2979625118U,

593

4159057246U, 3425930182U, 2593724503U, 1868899624U,

594

1769812374U, 2302537950U, 1110330676U, 3365377466U,

595

1336171666U, 3021258493U, 2334992265U, 3861994737U,

596

3582734124U, 3365377466U };

597

598

// You have updated the memcache_error messages but not updated docs/tests.

599

for (int rc= int(MEMCACHED_SUCCESS); rc < int(MEMCACHED_MAXIMUM_RETURN); ++rc)

600

{

601

uint32_t hash_val;

602

const char *msg= memcached_strerror(memc, memcached_return_t(rc));

603

hash_val= memcached_generate_hash_value(msg, strlen(msg),

604

MEMCACHED_HASH_JENKINS);

605

if (values[rc] != hash_val)

606

{

607

fprintf(stderr, "\n\nYou have updated memcached_return_t without updating the memcached_return_t_TEST\n");

608

fprintf(stderr, "%u, %s, (%u)\n\n", (uint32_t)rc, memcached_strerror(memc, memcached_return_t(rc)), hash_val);

609

}

610

test_compare(values[rc], hash_val);

611

}

612

test_compare(49, int(MEMCACHED_MAXIMUM_RETURN));

613

614

return TEST_SUCCESS;

615

}

616

617

test_return_t set_test(memcached_st *memc)

618

{

619

memcached_return_t rc= memcached_set(memc,

620

test_literal_param("foo"),

621

test_literal_param("when we sanitize"),

622

time_t(0), (uint32_t)0);

623

test_true_got(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED, memcached_strerror(NULL, rc));

624

625

return TEST_SUCCESS;

626

}

627

628

test_return_t append_test(memcached_st *memc)

629

{

630

memcached_return_t rc;

631

const char *in_value= "we";

632

size_t value_length;

633

uint32_t flags;

634

635

test_compare(MEMCACHED_SUCCESS,

636

memcached_flush(memc, 0));

637

638

test_compare(MEMCACHED_SUCCESS,

639

memcached_set(memc,

640

test_literal_param(__func__),

641

in_value, strlen(in_value),

642

time_t(0), uint32_t(0)));

643

644

test_compare(MEMCACHED_SUCCESS,

645

memcached_append(memc,

646

test_literal_param(__func__),

647

" the", strlen(" the"),

648

time_t(0), uint32_t(0)));

649

650

test_compare(MEMCACHED_SUCCESS,

651

memcached_append(memc,

652

test_literal_param(__func__),

653

" people", strlen(" people"),

654

time_t(0), uint32_t(0)));

655

656

char *out_value= memcached_get(memc,

657

test_literal_param(__func__),

658

&value_length, &flags, &rc);

659

test_memcmp(out_value, "we the people", strlen("we the people"));

660

test_compare(strlen("we the people"), value_length);

661

test_compare(MEMCACHED_SUCCESS, rc);

662

free(out_value);

663

664

return TEST_SUCCESS;

665

}

666

667

test_return_t append_binary_test(memcached_st *memc)

668

{

669

uint32_t store_list[] = { 23, 56, 499, 98, 32847, 0 };

670

671

test_compare(MEMCACHED_SUCCESS,

672

memcached_flush(memc, 0));

673

674

test_compare(MEMCACHED_SUCCESS,

675

memcached_set(memc,

676

test_literal_param(__func__),

677

NULL, 0,

678

time_t(0), uint32_t(0)));

679

680

size_t count= 0;

681

for (uint32_t x= 0; store_list[x] ; x++)

682

{

683

test_compare(MEMCACHED_SUCCESS,

684

memcached_append(memc,

685

test_literal_param(__func__),

686

(char *)&store_list[x], sizeof(uint32_t),

687

time_t(0), uint32_t(0)));

688

count++;

689

}

690

691

size_t value_length;

692

uint32_t flags;

693

memcached_return_t rc;

694

uint32_t *value= (uint32_t *)memcached_get(memc,

695

test_literal_param(__func__),

696

&value_length, &flags, &rc);

697

test_compare(value_length, sizeof(uint32_t) * count);

698

test_compare(MEMCACHED_SUCCESS, rc);

699

700

for (uint32_t counter= count, *ptr= value; counter; counter--)

701

{

702

test_compare(*ptr, store_list[count - counter]);

703

ptr++;

704

}

705

free(value);

706

707

return TEST_SUCCESS;

708

}

709

710

test_return_t memcached_mget_mixed_memcached_get_TEST(memcached_st *memc)

711

{

712

keys_st keys(200);

713

714

for (libtest::vchar_ptr_t::iterator iter= keys.begin();

715

iter != keys.end();

716

iter++)

717

{

718

test_compare(MEMCACHED_SUCCESS,

719

memcached_set(memc,

720

(*iter), 36,

721

NULL, 0,

722

time_t(0), uint32_t(0)));

723

}

724

725

for (ptrdiff_t loop= 0; loop < 20; loop++)

726

{

727

if (random() %2)

728

{

729

test_compare(MEMCACHED_SUCCESS,

730

memcached_mget(memc, keys.keys_ptr(), keys.lengths_ptr(), keys.size()));

731

732

memcached_result_st *results= memcached_result_create(memc, NULL);

733

test_true(results);

734

735

size_t result_count= 0;

736

memcached_return_t rc;

737

while (memcached_fetch_result(memc, results, &rc))

738

{

739

result_count++;

740

}

741

test_compare(keys.size(), result_count);

742

}

743

else

744

{

745

int which_key= random() %keys.size();

746

size_t value_length;

747

uint32_t flags;

748

memcached_return_t rc;

749

char *out_value= memcached_get(memc, keys.key_at(which_key), keys.length_at(which_key),

750

&value_length, &flags, &rc);

751

test_compare(MEMCACHED_SUCCESS, rc);

752

test_null(out_value);

753

test_zero(value_length);

754

test_zero(flags);

755

}

756

}

757

758

return TEST_SUCCESS;

759

}

760

761

test_return_t cas2_test(memcached_st *memc)

762

{

763

const char *keys[]= {"fudge", "son", "food"};

322

764

size_t key_length[]= {5, 3, 4};

323

char *value= "we the people";

765

const char *value= "we the people";

324

766

size_t value_length= strlen("we the people");

325

unsigned int x;

326

memcached_result_st results_obj;

327

memcached_result_st *results;

328

unsigned int set= 1;

329

330

rc= memcached_flush(memc, 0);

331

assert(rc == MEMCACHED_SUCCESS);

332

333

memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS, set);

334

335

for (x= 0; x < 3; x++)

767

768

test_compare(MEMCACHED_SUCCESS, memcached_flush(memc, 0));

769

770

test_compare(MEMCACHED_SUCCESS, memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS, true));

771

772

for (uint32_t x= 0; x < 3; x++)

336

773

{

337

rc= memcached_set(memc, keys[x], key_length[x],

338

keys[x], key_length[x],

339

(time_t)50, (uint32_t)9);

340

assert(rc == MEMCACHED_SUCCESS);

774

test_compare(MEMCACHED_SUCCESS,

775

memcached_set(memc, keys[x], key_length[x],

776

keys[x], key_length[x],

777

time_t(50), uint32_t(9)));

341

778

}

342

779

343

rc= memcached_mget(memc, keys, key_length, 3);

344

345

results= memcached_result_create(memc, &results_obj);

346

347

results= memcached_fetch_result(memc, &results_obj, &rc);

348

assert(results);

349

assert(results->cas);

350

assert(rc == MEMCACHED_SUCCESS);

351

WATCHPOINT_ASSERT(memcached_result_cas(results));

352

353

assert(!memcmp(value, "we the people", strlen("we the people")));

354

assert(strlen("we the people") == value_length);

355

assert(rc == MEMCACHED_SUCCESS);

356

357

memcached_result_free(&results_obj);

358

359

return 0;

780

test_compare(MEMCACHED_SUCCESS,

781

memcached_mget(memc, keys, key_length, 3));

782

783

memcached_result_st *results= memcached_result_create(memc, NULL);

784

test_true(results);

785

786

memcached_return_t rc;

787

results= memcached_fetch_result(memc, results, &rc);

788

test_true(results);

789

test_true(results->item_cas);

790

test_compare(MEMCACHED_SUCCESS, rc);

791

test_true(memcached_result_cas(results));

792

793

test_memcmp(value, "we the people", strlen("we the people"));

794

test_compare(strlen("we the people"), value_length);

795

test_compare(MEMCACHED_SUCCESS, rc);

796

797

memcached_result_free(results);

798

799

return TEST_SUCCESS;

360

800

}

361

801

362

test_return cas_test(memcached_st *memc)

802

test_return_t cas_test(memcached_st *memc)

363

803

{

364

memcached_return rc;

365

char *key= "fun";

366

size_t key_length= strlen("fun");

367

char *value= "we the people";

368

size_t value_length= strlen("we the people");

804

const char* keys[2] = { __func__, NULL };

805

size_t keylengths[2] = { strlen(__func__), 0 };

806

369

807

memcached_result_st results_obj;

370

memcached_result_st *results;

371

unsigned int set= 1;

372

373

rc= memcached_flush(memc, 0);

374

assert(rc == MEMCACHED_SUCCESS);

375

376

memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS, set);

377

378

rc= memcached_set(memc, key, strlen(key),

379

value, strlen(value),

380

(time_t)0, (uint32_t)0);

381

assert(rc == MEMCACHED_SUCCESS);

382

383

rc= memcached_mget(memc, &key, &key_length, 1);

384

385

results= memcached_result_create(memc, &results_obj);

386

387

results= memcached_fetch_result(memc, &results_obj, &rc);

388

assert(results);

389

assert(rc == MEMCACHED_SUCCESS);

390

WATCHPOINT_ASSERT(memcached_result_cas(results));

391

392

assert(!memcmp(value, "we the people", strlen("we the people")));

393

assert(strlen("we the people") == value_length);

394

assert(rc == MEMCACHED_SUCCESS);

395

396

rc= memcached_cas(memc, key, key_length,

397

"change the value", strlen("change the value"),

398

0, 0, memcached_result_cas(results));

399

400

assert(rc == MEMCACHED_SUCCESS);

401

402

rc= memcached_cas(memc, key, key_length,

403

"change the value", strlen("change the value"),

404

0, 0, 23);

405

406

assert(rc == MEMCACHED_DATA_EXISTS);

407

808

809

test_compare(MEMCACHED_SUCCESS, memcached_flush(memc, 0));

810

811

test_skip(true, memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS, true));

812

813

test_compare(MEMCACHED_SUCCESS,

814

memcached_set(memc,

815

test_literal_param(__func__),

816

test_literal_param("we the people"),

817

(time_t)0, (uint32_t)0));

818

819

test_compare(MEMCACHED_SUCCESS,

820

memcached_mget(memc, keys, keylengths, 1));

821

822

memcached_result_st *results= memcached_result_create(memc, &results_obj);

823

test_true(results);

824

825

memcached_return_t rc;

826

results= memcached_fetch_result(memc, &results_obj, &rc);

827

test_true(results);

828

test_compare(MEMCACHED_SUCCESS, rc);

829

test_true(memcached_result_cas(results));

830

test_memcmp("we the people", memcached_result_value(results), test_literal_param_size("we the people"));

831

test_compare(test_literal_param_size("we the people"),

832

strlen(memcached_result_value(results)));

833

834

uint64_t cas= memcached_result_cas(results);

835

836

#if 0

837

results= memcached_fetch_result(memc, &results_obj, &rc);

838

test_true(rc == MEMCACHED_END);

839

test_true(results == NULL);

840

#endif

841

842

test_compare(MEMCACHED_SUCCESS,

843

memcached_cas(memc,

844

test_literal_param(__func__),

845

test_literal_param("change the value"),

846

0, 0, cas));

847

848

849

* The item will have a new cas value, so try to set it again with the old

850

* value. This should fail!

851

852

test_compare(MEMCACHED_DATA_EXISTS,

853

memcached_cas(memc,

854

test_literal_param(__func__),

855

test_literal_param("change the value"),

856

0, 0, cas));

408

857

409

858

memcached_result_free(&results_obj);

410

859

411

return 0;

860

return TEST_SUCCESS;

412

861

}

413

862

414

test_return prepend_test(memcached_st *memc)

863

864

test_return_t prepend_test(memcached_st *memc)

415

865

{

416

memcached_return rc;

417

char *key= "fig";

418

char *value= "people";

866

const char *key= "fig";

867

const char *value= "people";

868

869

test_compare(MEMCACHED_SUCCESS,

870

memcached_flush(memc, 0));

871

872

test_compare(MEMCACHED_SUCCESS,

873

memcached_set(memc, key, strlen(key),

874

value, strlen(value),

875

time_t(0), uint32_t(0)));

876

877

test_compare(MEMCACHED_SUCCESS,

878

memcached_prepend(memc, key, strlen(key),

879

"the ", strlen("the "),

880

time_t(0), uint32_t(0)));

881

882

test_compare(MEMCACHED_SUCCESS,

883

memcached_prepend(memc, key, strlen(key),

884

"we ", strlen("we "),

885

time_t(0), uint32_t(0)));

886

419

887

size_t value_length;

420

888

uint32_t flags;

421

422

rc= memcached_flush(memc, 0);

423

assert(rc == MEMCACHED_SUCCESS);

424

425

rc= memcached_set(memc, key, strlen(key),

426

value, strlen(value),

427

(time_t)0, (uint32_t)0);

428

assert(rc == MEMCACHED_SUCCESS);

429

430

rc= memcached_prepend(memc, key, strlen(key),

431

"the ", strlen("the "),

432

(time_t)0, (uint32_t)0);

433

assert(rc == MEMCACHED_SUCCESS);

434

435

rc= memcached_prepend(memc, key, strlen(key),

436

"we ", strlen("we "),

437

(time_t)0, (uint32_t)0);

438

assert(rc == MEMCACHED_SUCCESS);

439

440

value= memcached_get(memc, key, strlen(key),

889

memcached_return_t rc;

890

char *out_value= memcached_get(memc, key, strlen(key),

441

891

&value_length, &flags, &rc);

442

assert(!memcmp(value, "we the people", strlen("we the people")));

443

assert(strlen("we the people") == value_length);

444

assert(rc == MEMCACHED_SUCCESS);

445

free(value);

892

test_memcmp(out_value, "we the people", strlen("we the people"));

893

test_compare(strlen("we the people"), value_length);

894

test_compare(MEMCACHED_SUCCESS, rc);

895

free(out_value);

446

896

447

return 0;

897

return TEST_SUCCESS;

448

898

}

449

899

450

900

451

901

Set the value, then quit to make sure it is flushed.

452

902

Come back in and test that add fails.

453

903

454

test_return add_test(memcached_st *memc)

904

test_return_t add_test(memcached_st *memc)

455

905

{

456

memcached_return rc;

457

char *key= "foo";

458

char *value= "when we sanitize";

459

unsigned long long setting_value;

460

461

setting_value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NO_BLOCK);

462

463

rc= memcached_set(memc, key, strlen(key),

464

value, strlen(value),

465

(time_t)0, (uint32_t)0);

466

assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);

906

test_compare_hint(return_value_based_on_buffering(memc),

907

memcached_set(memc,

908

test_literal_param(__func__),

909

test_literal_param("when we sanitize"),

910

time_t(0), uint32_t(0)),

911

memcached_last_error_message(memc));

912

467

913

memcached_quit(memc);

468

rc= memcached_add(memc, key, strlen(key),

469

value, strlen(value),

470

(time_t)0, (uint32_t)0);

471

472

/* Too many broken OS'es have broken loopback in async, so we can't be sure of the result */

473

if (setting_value)

474

assert(rc == MEMCACHED_NOTSTORED || rc == MEMCACHED_STORED);

475

else

476

assert(rc == MEMCACHED_NOTSTORED);

477

478

return 0;

914

915

test_compare_hint(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) ? MEMCACHED_DATA_EXISTS : MEMCACHED_NOTSTORED,

916

memcached_add(memc,

917

test_literal_param(__func__),

918

test_literal_param("try something else"),

919

time_t(0), uint32_t(0)),

920

memcached_last_error_message(memc));

921

922

return TEST_SUCCESS;

479

923

}

480

924

481

test_return add_wrapper(memcached_st *memc)

925

926

** There was a problem of leaking filedescriptors in the initial release

927

** of MacOSX 10.5. This test case triggers the problem. On some Solaris

928

** systems it seems that the kernel is slow on reclaiming the resources

929

** because the connects starts to time out (the test doesn't do much

930

** anyway, so just loop 10 iterations)

931

932

test_return_t add_wrapper(memcached_st *memc)

482

933

{

483

unsigned int x;

934

unsigned int max= 10000;

935

#ifdef __sun

936

max= 10;

937

#endif

938

#ifdef __APPLE__

939

max= 10;

940

#endif

484

941

485

for (x= 0; x < 10000; x++)

942

for (uint32_t x= 0; x < max; x++)

486

943

add_test(memc);

487

944

488

return 0;

489

}

490

491

test_return replace_test(memcached_st *memc)

492

{

493

memcached_return rc;

494

char *key= "foo";

495

char *value= "when we sanitize";

496

char *original= "first we insert some data";

497

498

rc= memcached_set(memc, key, strlen(key),

499

original, strlen(original),

500

(time_t)0, (uint32_t)0);

501

assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);

502

503

rc= memcached_replace(memc, key, strlen(key),

504

value, strlen(value),

505

(time_t)0, (uint32_t)0);

506

assert(rc == MEMCACHED_SUCCESS);

507

508

return 0;

509

}

510

511

test_return delete_test(memcached_st *memc)

512

{

513

memcached_return rc;

514

char *key= "foo";

515

char *value= "when we sanitize";

516

517

rc= memcached_set(memc, key, strlen(key),

518

value, strlen(value),

519

(time_t)0, (uint32_t)0);

520

assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);

521

522

rc= memcached_delete(memc, key, strlen(key), (time_t)0);

523

assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);

524

525

return 0;

526

}

527

528

test_return flush_test(memcached_st *memc)

529

{

530

memcached_return rc;

531

532

rc= memcached_flush(memc, 0);

533

assert(rc == MEMCACHED_SUCCESS);

534

535

return 0;

536

}

537

538

memcached_return server_function(memcached_st *ptr, memcached_server_st *server, void *context)

945

return TEST_SUCCESS;

946

}

947

948

test_return_t replace_test(memcached_st *memc)

949

{

950

test_compare(return_value_based_on_buffering(memc),

951

memcached_set(memc,

952

test_literal_param(__func__),

953

test_literal_param("when we sanitize"),

954

time_t(0), uint32_t(0)));

955

956

test_compare(MEMCACHED_SUCCESS,

957

memcached_replace(memc,

958

test_literal_param(__func__),

959

test_literal_param("first we insert some data"),

960

time_t(0), uint32_t(0)));

961

962

return TEST_SUCCESS;

963

}

964

965

test_return_t delete_test(memcached_st *memc)

966

{

967

test_compare(return_value_based_on_buffering(memc),

968

memcached_set(memc,

969

test_literal_param(__func__),

970

test_literal_param("when we sanitize"),

971

time_t(0), uint32_t(0)));

972

973

test_compare_hint(return_value_based_on_buffering(memc),

974

memcached_delete(memc,

975

test_literal_param(__func__),

976

time_t(0)),

977

memcached_last_error_message(memc));

978

979

return TEST_SUCCESS;

980

}

981

982

test_return_t flush_test(memcached_st *memc)

983

{

984

uint64_t query_id= memcached_query_id(memc);

985

test_compare(MEMCACHED_SUCCESS,

986

memcached_flush(memc, 0));

987

test_compare(query_id +1, memcached_query_id(memc));

988

989

return TEST_SUCCESS;

990

}

991

992

static memcached_return_t server_function(const memcached_st *,

993

const memcached_server_st *,

994

void *)

539

995

{

540

996

/* Do Nothing */

541

542

997

return MEMCACHED_SUCCESS;

543

998

}

544

999

545

test_return memcached_server_cursor_test(memcached_st *memc)

1000

test_return_t memcached_server_cursor_test(memcached_st *memc)

546

1001

{

547

char *context= "foo bad";

548

memcached_server_function callbacks[1];

1002

char context[10];

1003

strncpy(context, "foo bad", sizeof(context));

1004

memcached_server_fn callbacks[1];

549

1005

550

1006

callbacks[0]= server_function;

551

1007

memcached_server_cursor(memc, callbacks, context, 1);

552

553

return 0;

1008

return TEST_SUCCESS;

554

1009

}

555

1010

556

test_return bad_key_test(memcached_st *memc)

1011

test_return_t bad_key_test(memcached_st *memc)

557

1012

{

558

memcached_return rc;

559

char *key= "foo bad";

560

char *string;

561

size_t string_length;

1013

memcached_return_t rc;

1014

const char *key= "foo bad";

562

1015

uint32_t flags;

563

memcached_st *clone;

564

unsigned int set= 1;

565

566

clone= memcached_clone(NULL, memc);

567

assert(clone);

568

569

(void)memcached_behavior_set(clone, MEMCACHED_BEHAVIOR_VERIFY_KEY, set);

570

571

string= memcached_get(clone, key, strlen(key),

572

&string_length, &flags, &rc);

573

assert(rc == MEMCACHED_BAD_KEY_PROVIDED);

574

assert(string_length == 0);

575

assert(!string);

576

577

set= 0;

578

(void)memcached_behavior_set(clone, MEMCACHED_BEHAVIOR_VERIFY_KEY, set);

579

string= memcached_get(clone, key, strlen(key),

580

&string_length, &flags, &rc);

581

assert(rc == MEMCACHED_NOTFOUND);

582

assert(string_length == 0);

583

assert(!string);

584

585

memcached_free(clone);

586

587

return 0;

1016

1017

uint64_t query_id= memcached_query_id(memc);

1018

1019

// Just skip if we are in binary mode.

1020

test_skip(false, memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL));

1021

1022

test_compare(query_id, memcached_query_id(memc)); // We should not increase the query_id for memcached_behavior_get()

1023

1024

memcached_st *memc_clone= memcached_clone(NULL, memc);

1025

test_true(memc_clone);

1026

1027

query_id= memcached_query_id(memc_clone);

1028

test_compare(MEMCACHED_SUCCESS,

1029

memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_VERIFY_KEY, true));

1030

test_compare(query_id, memcached_query_id(memc_clone)); // We should not increase the query_id for memcached_behavior_set()

1031

1032

/* All keys are valid in the binary protocol (except for length) */

1033

if (memcached_behavior_get(memc_clone, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) == false)

1034

{

1035

uint64_t before_query_id= memcached_query_id(memc_clone);

1036

{

1037

size_t string_length;

1038

char *string= memcached_get(memc_clone, key, strlen(key),

1039

&string_length, &flags, &rc);

1040

test_compare(MEMCACHED_BAD_KEY_PROVIDED, rc);

1041

test_zero(string_length);

1042

test_false(string);

1043

}

1044

test_compare(before_query_id +1, memcached_query_id(memc_clone));

1045

1046

query_id= memcached_query_id(memc_clone);

1047

test_compare(MEMCACHED_SUCCESS,

1048

memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_VERIFY_KEY, false));

1049

test_compare(query_id, memcached_query_id(memc_clone)); // We should not increase the query_id for memcached_behavior_set()

1050

{

1051

size_t string_length;

1052

char *string= memcached_get(memc_clone, key, strlen(key),

1053

&string_length, &flags, &rc);

1054

test_compare_got(MEMCACHED_NOTFOUND, rc, memcached_strerror(NULL, rc));

1055

test_zero(string_length);

1056

test_false(string);

1057

}

1058

1059

/* Test multi key for bad keys */

1060

const char *keys[] = { "GoodKey", "Bad Key", "NotMine" };

1061

size_t key_lengths[] = { 7, 7, 7 };

1062

query_id= memcached_query_id(memc_clone);

1063

test_compare(MEMCACHED_SUCCESS,

1064

memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_VERIFY_KEY, true));

1065

test_compare(query_id, memcached_query_id(memc_clone));

1066

1067

query_id= memcached_query_id(memc_clone);

1068

test_compare(MEMCACHED_BAD_KEY_PROVIDED,

1069

memcached_mget(memc_clone, keys, key_lengths, 3));

1070

test_compare(query_id +1, memcached_query_id(memc_clone));

1071

1072

query_id= memcached_query_id(memc_clone);

1073

// Grouping keys are not required to follow normal key behaviors

1074

test_compare(MEMCACHED_SUCCESS,

1075

memcached_mget_by_key(memc_clone, "foo daddy", 9, keys, key_lengths, 1));

1076

test_compare(query_id +1, memcached_query_id(memc_clone));

1077

1078

/* The following test should be moved to the end of this function when the

1079

memcached server is updated to allow max size length of the keys in the

1080

binary protocol

1081

1082

test_compare(MEMCACHED_SUCCESS,

1083

memcached_callback_set(memc_clone, MEMCACHED_CALLBACK_NAMESPACE, NULL));

1084

1085

libtest::vchar_t longkey;

1086

{

1087

libtest::vchar_t::iterator it= longkey.begin();

1088

longkey.insert(it, MEMCACHED_MAX_KEY, 'a');

1089

}

1090

1091

test_compare(longkey.size(), size_t(MEMCACHED_MAX_KEY));

1092

{

1093

size_t string_length;

1094

// We subtract 1

1095

test_null(memcached_get(memc_clone, &longkey[0], longkey.size() -1, &string_length, &flags, &rc));

1096

test_compare(MEMCACHED_NOTFOUND, rc);

1097

test_zero(string_length);

1098

1099

test_null(memcached_get(memc_clone, &longkey[0], longkey.size(), &string_length, &flags, &rc));

1100

test_compare(MEMCACHED_BAD_KEY_PROVIDED, rc);

1101

test_zero(string_length);

1102

}

1103

}

1104

1105

/* Make sure zero length keys are marked as bad */

1106

{

1107

test_compare(MEMCACHED_SUCCESS,

1108

memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_VERIFY_KEY, true));

1109

size_t string_length;

1110

char *string= memcached_get(memc_clone, key, 0,

1111

&string_length, &flags, &rc);

1112

test_compare(MEMCACHED_BAD_KEY_PROVIDED, rc);

1113

test_zero(string_length);

1114

test_false(string);

1115

}

1116

1117

memcached_free(memc_clone);

1118

1119

return TEST_SUCCESS;

588

1120

}

589

1121

590

1122

#define READ_THROUGH_VALUE "set for me"

591

memcached_return read_through_trigger(memcached_st *memc,

592

char *key, size_t key_length,

593

memcached_result_st *result)

1123

static memcached_return_t read_through_trigger(memcached_st *memc,

1124

char *key,

1125

size_t key_length,

1126

memcached_result_st *result)

594

1127

{

595

1128

(void)memc;(void)key;(void)key_length;

596

1129

return memcached_result_set_value(result, READ_THROUGH_VALUE, strlen(READ_THROUGH_VALUE));

597

1130

}

598

1131

599

test_return read_through(memcached_st *memc)

600

{

601

memcached_return rc;

602

char *key= "foo";

603

char *string;

604

size_t string_length;

605

uint32_t flags;

606

607

string= memcached_get(memc, key, strlen(key),

608

&string_length, &flags, &rc);

609

610

assert(rc == MEMCACHED_NOTFOUND);

611

assert(string_length == 0);

612

assert(!string);

613

614

rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_GET_FAILURE, read_through_trigger);

615

assert(rc == MEMCACHED_SUCCESS);

616

617

string= memcached_get(memc, key, strlen(key),

618

&string_length, &flags, &rc);

619

620

assert(rc == MEMCACHED_SUCCESS);

621

assert(string_length == strlen(READ_THROUGH_VALUE));

622

assert(!strcmp(READ_THROUGH_VALUE, string));

623

free(string);

624

625

string= memcached_get(memc, key, strlen(key),

626

&string_length, &flags, &rc);

627

628

assert(rc == MEMCACHED_SUCCESS);

629

assert(string_length == strlen(READ_THROUGH_VALUE));

630

assert(!strcmp(READ_THROUGH_VALUE, string));

631

free(string);

632

633

return 0;

634

}

635

636

memcached_return delete_trigger(memcached_st *ptr, char *key, size_t key_length)

637

{

638

assert(key);

639

640

return MEMCACHED_SUCCESS;

641

}

642

643

test_return delete_through(memcached_st *memc)

644

{

645

memcached_trigger_delete_key callback;

646

memcached_return rc;

647

648

callback= delete_trigger;

649

650

rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_DELETE_TRIGGER, callback);

651

assert(rc == MEMCACHED_SUCCESS);

652

653

return 0;

654

}

655

656

test_return get_test(memcached_st *memc)

657

{

658

memcached_return rc;

659

char *key= "foo";

660

char *string;

661

size_t string_length;

662

uint32_t flags;

663

664

rc= memcached_delete(memc, key, strlen(key), (time_t)0);

665

assert(rc == MEMCACHED_BUFFERED || rc == MEMCACHED_NOTFOUND);

666

667

string= memcached_get(memc, key, strlen(key),

668

&string_length, &flags, &rc);

669

670

assert(rc == MEMCACHED_NOTFOUND);

671

assert(string_length == 0);

672

assert(!string);

673

674

return 0;

675

}

676

677

test_return get_test2(memcached_st *memc)

678

{

679

memcached_return rc;

680

char *key= "foo";

681

char *value= "when we sanitize";

682

char *string;

683

size_t string_length;

684

uint32_t flags;

685

686

rc= memcached_set(memc, key, strlen(key),

687

value, strlen(value),

688

(time_t)0, (uint32_t)0);

689

assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);

690

691

string= memcached_get(memc, key, strlen(key),

692

&string_length, &flags, &rc);

693

694

assert(string);

695

assert(rc == MEMCACHED_SUCCESS);

696

assert(string_length == strlen(value));

697

assert(!memcmp(string, value, string_length));

698

699

free(string);

700

701

return 0;

702

}

703

704

test_return set_test2(memcached_st *memc)

705

{

706

memcached_return rc;

707

char *key= "foo";

708

char *value= "train in the brain";

709

size_t value_length= strlen(value);

710

unsigned int x;

711

712

for (x= 0; x < 10; x++)

713

{

714

rc= memcached_set(memc, key, strlen(key),

715

value, value_length,

716

(time_t)0, (uint32_t)0);

717

assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);

718

}

719

720

return 0;

721

}

722

723

test_return set_test3(memcached_st *memc)

724

{

725

memcached_return rc;

726

char *key= "foo";

727

char *value;

728

size_t value_length= 8191;

729

unsigned int x;

730

731

value = (char*)malloc(value_length);

732

assert(value);

733

734

for (x= 0; x < value_length; x++)

735

value[x] = (char) (x % 127);

736

737

for (x= 0; x < 1; x++)

738

{

739

rc= memcached_set(memc, key, strlen(key),

740

value, value_length,

741

(time_t)0, (uint32_t)0);

742

assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);

743

}

744

745

free(value);

746

747

return 0;

748

}

749

750

test_return get_test3(memcached_st *memc)

751

{

752

memcached_return rc;

753

char *key= "foo";

754

char *value;

755

size_t value_length= 8191;

756

char *string;

757

size_t string_length;

758

uint32_t flags;

759

int x;

760

761

value = (char*)malloc(value_length);

762

assert(value);

763

764

for (x= 0; x < value_length; x++)

765

value[x] = (char) (x % 127);

766

767

rc= memcached_set(memc, key, strlen(key),

768

value, value_length,

769

(time_t)0, (uint32_t)0);

770

assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);

771

772

string= memcached_get(memc, key, strlen(key),

773

&string_length, &flags, &rc);

774

775

assert(rc == MEMCACHED_SUCCESS);

776

assert(string);

777

assert(string_length == value_length);

778

assert(!memcmp(string, value, string_length));

779

780

free(string);

781

free(value);

782

783

return 0;

784

}

785

786

test_return get_test4(memcached_st *memc)

787

{

788

memcached_return rc;

789

char *key= "foo";

790

char *value;

791

size_t value_length= 8191;

792

char *string;

793

size_t string_length;

794

uint32_t flags;

795

int x;

796

797

value = (char*)malloc(value_length);

798

assert(value);

799

800

for (x= 0; x < value_length; x++)

801

value[x] = (char) (x % 127);

802

803

rc= memcached_set(memc, key, strlen(key),

804

value, value_length,

805

(time_t)0, (uint32_t)0);

806

assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);

807

808

for (x= 0; x < 10; x++)

809

{

810

string= memcached_get(memc, key, strlen(key),

811

&string_length, &flags, &rc);

812

813

assert(rc == MEMCACHED_SUCCESS);

814

assert(string);

815

assert(string_length == value_length);

816

assert(!memcmp(string, value, string_length));

1132

#ifndef __INTEL_COMPILER

1133

#pragma GCC diagnostic ignored "-Wstrict-aliasing"

1134

#endif

1135

1136

test_return_t read_through(memcached_st *memc)

1137

{

1138

memcached_trigger_key_fn cb= (memcached_trigger_key_fn)read_through_trigger;

1139

1140

size_t string_length;

1141

uint32_t flags;

1142

memcached_return_t rc;

1143

char *string= memcached_get(memc,

1144

test_literal_param(__func__),

1145

&string_length, &flags, &rc);

1146

1147

test_compare(MEMCACHED_NOTFOUND, rc);

1148

test_false(string_length);

1149

test_false(string);

1150

1151

test_compare(MEMCACHED_SUCCESS,

1152

memcached_callback_set(memc, MEMCACHED_CALLBACK_GET_FAILURE, *(void **)&cb));

1153

1154

string= memcached_get(memc,

1155

test_literal_param(__func__),

1156

&string_length, &flags, &rc);

1157

1158

test_compare(MEMCACHED_SUCCESS, rc);

1159

test_compare(string_length, sizeof(READ_THROUGH_VALUE) -1);

1160

test_true(string[sizeof(READ_THROUGH_VALUE) -1] == 0);

1161

test_strcmp(READ_THROUGH_VALUE, string);

1162

free(string);

1163

1164

string= memcached_get(memc,

1165

test_literal_param(__func__),

1166

&string_length, &flags, &rc);

1167

1168

test_compare(MEMCACHED_SUCCESS, rc);

1169

test_true(string);

1170

test_compare(string_length, sizeof(READ_THROUGH_VALUE) -1);

1171

test_true(string[sizeof(READ_THROUGH_VALUE) -1] == 0);

1172

test_strcmp(READ_THROUGH_VALUE, string);

1173

free(string);

1174

1175

return TEST_SUCCESS;

1176

}

1177

1178

test_return_t set_test2(memcached_st *memc)

1179

{

1180

for (uint32_t x= 0; x < 10; x++)

1181

{

1182

test_compare(return_value_based_on_buffering(memc),

1183

memcached_set(memc,

1184

test_literal_param("foo"),

1185

test_literal_param("train in the brain"),

1186

time_t(0), uint32_t(0)));

1187

}

1188

1189

return TEST_SUCCESS;

1190

}

1191

1192

test_return_t set_test3(memcached_st *memc)

1193

{

1194

size_t value_length= 8191;

1195

1196

libtest::vchar_t value;

1197

value.reserve(value_length);

1198

for (uint32_t x= 0; x < value_length; x++)

1199

{

1200

value.push_back(char(x % 127));

1201

}

1202

1203

/* The dump test relies on there being at least 32 items in memcached */

1204

for (uint32_t x= 0; x < 32; x++)

1205

{

1206

char key[16];

1207

1208

snprintf(key, sizeof(key), "foo%u", x);

1209

1210

uint64_t query_id= memcached_query_id(memc);

1211

test_compare_hint(return_value_based_on_buffering(memc),

1212

memcached_set(memc, key, strlen(key),

1213

&value[0], value.size(),

1214

time_t(0), uint32_t(0)),

1215

memcached_last_error_message(memc));

1216

test_compare(query_id +1, memcached_query_id(memc));

1217

}

1218

1219

return TEST_SUCCESS;

1220

}

1221

1222

test_return_t mget_end(memcached_st *memc)

1223

{

1224

const char *keys[]= { "foo", "foo2" };

1225

size_t lengths[]= { 3, 4 };

1226

const char *values[]= { "fjord", "41" };

1227

1228

// Set foo and foo2

1229

for (size_t x= 0; x < test_array_length(keys); x++)

1230

{

1231

test_compare(MEMCACHED_SUCCESS,

1232

memcached_set(memc,

1233

keys[x], lengths[x],

1234

values[x], strlen(values[x]),

1235

time_t(0), uint32_t(0)));

1236

}

1237

1238

char *string;

1239

size_t string_length;

1240

uint32_t flags;

1241

1242

// retrieve both via mget

1243

test_compare(MEMCACHED_SUCCESS,

1244

memcached_mget(memc,

1245

keys, lengths,

1246

test_array_length(keys)));

1247

1248

char key[MEMCACHED_MAX_KEY];

1249

size_t key_length;

1250

memcached_return_t rc;

1251

1252

// this should get both

1253

for (size_t x= 0; x < test_array_length(keys); x++)

1254

{

1255

string= memcached_fetch(memc, key, &key_length, &string_length,

1256

&flags, &rc);

1257

test_compare(MEMCACHED_SUCCESS, rc);

1258

int val = 0;

1259

if (key_length == 4)

1260

{

1261

val= 1;

1262

}

1263

1264

test_compare(string_length, strlen(values[val]));

1265

test_true(strncmp(values[val], string, string_length) == 0);

817

1266

free(string);

818

1267

}

819

1268

820

free(value);

821

822

return 0;

1269

// this should indicate end

1270

string= memcached_fetch(memc, key, &key_length, &string_length, &flags, &rc);

1271

test_compare(MEMCACHED_END, rc);

1272

test_null(string);

1273

1274

// now get just one

1275

test_compare(MEMCACHED_SUCCESS,

1276

memcached_mget(memc, keys, lengths, 1));

1277

1278

string= memcached_fetch(memc, key, &key_length, &string_length, &flags, &rc);

1279

test_compare(key_length, lengths[0]);

1280

test_true(strncmp(keys[0], key, key_length) == 0);

1281

test_compare(string_length, strlen(values[0]));

1282

test_true(strncmp(values[0], string, string_length) == 0);

1283

test_compare(MEMCACHED_SUCCESS, rc);

1284

free(string);

1285

1286

// this should indicate end

1287

string= memcached_fetch(memc, key, &key_length, &string_length, &flags, &rc);

1288

test_compare(MEMCACHED_END, rc);

1289

test_null(string);

1290

1291

return TEST_SUCCESS;

823

1292

}

824

1293

825

1294

/* Do not copy the style of this code, I just access hosts to testthis function */

826

test_return stats_servername_test(memcached_st *memc)

827

{

828

memcached_return rc;

829

memcached_stat_st stat;

830

rc= memcached_stat_servername(&stat, NULL,

831

memc->hosts[0].hostname,

832

memc->hosts[0].port);

833

834

return 0;

835

}

836

837

test_return increment_test(memcached_st *memc)

838

{

839

uint64_t new_number;

840

memcached_return rc;

841

char *key= "number";

842

char *value= "0";

843

844

rc= memcached_set(memc, key, strlen(key),

845

value, strlen(value),

846

(time_t)0, (uint32_t)0);

847

assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);

848

849

rc= memcached_increment(memc, key, strlen(key),

850

1, &new_number);

851

assert(rc == MEMCACHED_SUCCESS);

852

assert(new_number == 1);

853

854

rc= memcached_increment(memc, key, strlen(key),

855

1, &new_number);

856

assert(rc == MEMCACHED_SUCCESS);

857

assert(new_number == 2);

858

859

return 0;

860

}

861

862

test_return decrement_test(memcached_st *memc)

863

{

864

uint64_t new_number;

865

memcached_return rc;

866

char *key= "number";

867

char *value= "3";

868

869

rc= memcached_set(memc, key, strlen(key),

870

value, strlen(value),

871

(time_t)0, (uint32_t)0);

872

assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);

873

874

rc= memcached_decrement(memc, key, strlen(key),

875

1, &new_number);

876

assert(rc == MEMCACHED_SUCCESS);

877

assert(new_number == 2);

878

879

rc= memcached_decrement(memc, key, strlen(key),

880

1, &new_number);

881

assert(rc == MEMCACHED_SUCCESS);

882

assert(new_number == 1);

883

884

return 0;

885

}

886

887

test_return quit_test(memcached_st *memc)

888

{

889

memcached_return rc;

890

char *key= "fudge";

891

char *value= "sanford and sun";

892

893

rc= memcached_set(memc, key, strlen(key),

894

value, strlen(value),

895

(time_t)10, (uint32_t)3);

896

assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);

1295

test_return_t stats_servername_test(memcached_st *memc)

1296

{

1297

memcached_stat_st memc_stat;

1298

memcached_server_instance_st instance=

1299

memcached_server_instance_by_position(memc, 0);

1300

1301

if (LIBMEMCACHED_WITH_SASL_SUPPORT and memcached_get_sasl_callbacks(memc))

1302

{

1303

return TEST_SKIPPED;

1304

}

1305

1306

test_compare(MEMCACHED_SUCCESS, memcached_stat_servername(&memc_stat, NULL,

1307

memcached_server_name(instance),

1308

memcached_server_port(instance)));

1309

1310

return TEST_SUCCESS;

1311

}

1312

1313

test_return_t increment_test(memcached_st *memc)

1314

{

1315

uint64_t new_number;

1316

1317

test_compare(MEMCACHED_SUCCESS,

1318

memcached_set(memc,

1319

test_literal_param("number"),

1320

test_literal_param("0"),

1321

(time_t)0, (uint32_t)0));

1322

1323

test_compare(MEMCACHED_SUCCESS,

1324

memcached_increment(memc, test_literal_param("number"), 1, &new_number));

1325

test_compare(uint64_t(1), new_number);

1326

1327

test_compare(MEMCACHED_SUCCESS,

1328

memcached_increment(memc, test_literal_param("number"), 1, &new_number));

1329

test_compare(uint64_t(2), new_number);

1330

1331

return TEST_SUCCESS;

1332

}

1333

1334

test_return_t increment_with_initial_test(memcached_st *memc)

1335

{

1336

test_skip(true, memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL));

1337

1338

uint64_t new_number;

1339

uint64_t initial= 0;

1340

1341

test_compare(MEMCACHED_SUCCESS, memcached_flush_buffers(memc));

1342

1343

test_compare(MEMCACHED_SUCCESS,

1344

memcached_increment_with_initial(memc, test_literal_param("number"), 1, initial, 0, &new_number));

1345

test_compare(new_number, initial);

1346

1347

test_compare(MEMCACHED_SUCCESS,

1348

memcached_increment_with_initial(memc, test_literal_param("number"), 1, initial, 0, &new_number));

1349

test_compare(new_number, (initial +1));

1350

1351

return TEST_SUCCESS;

1352

}

1353

1354

test_return_t decrement_test(memcached_st *memc)

1355

{

1356

test_compare(return_value_based_on_buffering(memc),

1357

memcached_set(memc,

1358

test_literal_param(__func__),

1359

test_literal_param("3"),

1360

time_t(0), uint32_t(0)));

1361

// Make sure we flush the value we just set

1362

test_compare(MEMCACHED_SUCCESS, memcached_flush_buffers(memc));

1363

1364

uint64_t new_number;

1365

test_compare(MEMCACHED_SUCCESS,

1366

memcached_decrement(memc,

1367

test_literal_param(__func__),

1368

1, &new_number));

1369

test_compare(uint64_t(2), new_number);

1370

1371

test_compare(MEMCACHED_SUCCESS,

1372

memcached_decrement(memc,

1373

test_literal_param(__func__),

1374

1, &new_number));

1375

test_compare(uint64_t(1), new_number);

1376

1377

return TEST_SUCCESS;

1378

}

1379

1380

test_return_t decrement_with_initial_test(memcached_st *memc)

1381

{

1382

test_skip(true, memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL));

1383

1384

uint64_t initial= 3;

1385

1386

test_compare(MEMCACHED_SUCCESS, memcached_flush_buffers(memc));

1387

1388

uint64_t new_number;

1389

test_compare(MEMCACHED_SUCCESS,

1390

memcached_decrement_with_initial(memc,

1391

test_literal_param(__func__),

1392

1, initial,

1393

0, &new_number));

1394

test_compare(new_number, initial);

1395

1396

test_compare(MEMCACHED_SUCCESS,

1397

memcached_decrement_with_initial(memc,

1398

test_literal_param(__func__),

1399

1, initial,

1400

0, &new_number));

1401

test_compare(new_number, (initial - 1));

1402

1403

return TEST_SUCCESS;

1404

}

1405

1406

test_return_t increment_by_key_test(memcached_st *memc)

1407

{

1408

const char *master_key= "foo";

1409

const char *key= "number";

1410

const char *value= "0";

1411

1412

test_compare(return_value_based_on_buffering(memc),

1413

memcached_set_by_key(memc, master_key, strlen(master_key),

1414

key, strlen(key),

1415

value, strlen(value),

1416

time_t(0), uint32_t(0)));

1417

1418

// Make sure we flush the value we just set

1419

test_compare(MEMCACHED_SUCCESS, memcached_flush_buffers(memc));

1420

1421

uint64_t new_number;

1422

test_compare(MEMCACHED_SUCCESS,

1423

memcached_increment_by_key(memc, master_key, strlen(master_key),

1424

key, strlen(key), 1, &new_number));

1425

test_compare(uint64_t(1), new_number);

1426

1427

test_compare(MEMCACHED_SUCCESS,

1428

memcached_increment_by_key(memc, master_key, strlen(master_key),

1429

key, strlen(key), 1, &new_number));

1430

test_compare(uint64_t(2), new_number);

1431

1432

return TEST_SUCCESS;

1433

}

1434

1435

test_return_t increment_with_initial_by_key_test(memcached_st *memc)

1436

{

1437

test_skip(true, memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL));

1438

1439

uint64_t new_number;

1440

const char *master_key= "foo";

1441

const char *key= "number";

1442

uint64_t initial= 0;

1443

1444

test_compare(MEMCACHED_SUCCESS,

1445

memcached_increment_with_initial_by_key(memc, master_key, strlen(master_key),

1446

key, strlen(key),

1447

1, initial, 0, &new_number));

1448

test_compare(new_number, initial);

1449

1450

test_compare(MEMCACHED_SUCCESS,

1451

memcached_increment_with_initial_by_key(memc, master_key, strlen(master_key),

1452

key, strlen(key),

1453

1, initial, 0, &new_number));

1454

test_compare(new_number, (initial +1));

1455

1456

return TEST_SUCCESS;

1457

}

1458

1459

test_return_t decrement_by_key_test(memcached_st *memc)

1460

{

1461

uint64_t new_number;

1462

const char *value= "3";

1463

1464

test_compare(return_value_based_on_buffering(memc),

1465

memcached_set_by_key(memc,

1466

test_literal_param("foo"),

1467

test_literal_param("number"),

1468

value, strlen(value),

1469

(time_t)0, (uint32_t)0));

1470

1471

test_compare(MEMCACHED_SUCCESS,

1472

memcached_decrement_by_key(memc,

1473

test_literal_param("foo"),

1474

test_literal_param("number"),

1475

1, &new_number));

1476

test_compare(uint64_t(2), new_number);

1477

1478

test_compare(MEMCACHED_SUCCESS,

1479

memcached_decrement_by_key(memc,

1480

test_literal_param("foo"),

1481

test_literal_param("number"),

1482

1, &new_number));

1483

test_compare(uint64_t(1), new_number);

1484

1485

return TEST_SUCCESS;

1486

}

1487

1488

test_return_t decrement_with_initial_by_key_test(memcached_st *memc)

1489

{

1490

test_skip(true, memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL));

1491

1492

uint64_t new_number;

1493

uint64_t initial= 3;

1494

1495

test_compare(MEMCACHED_SUCCESS,

1496

memcached_decrement_with_initial_by_key(memc,

1497

test_literal_param("foo"),

1498

test_literal_param("number"),

1499

1, initial, 0, &new_number));

1500

test_compare(new_number, initial);

1501

1502

test_compare(MEMCACHED_SUCCESS,

1503

memcached_decrement_with_initial_by_key(memc,

1504

test_literal_param("foo"),

1505

test_literal_param("number"),

1506

1, initial, 0, &new_number));

1507

test_compare(new_number, (initial - 1));

1508

1509

return TEST_SUCCESS;

1510

}

1511

test_return_t binary_increment_with_prefix_test(memcached_st *memc)

1512

{

1513

test_skip(true, memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL));

1514

1515

test_compare(MEMCACHED_SUCCESS, memcached_callback_set(memc, MEMCACHED_CALLBACK_PREFIX_KEY, (void *)"namespace:"));

1516

1517

test_compare(return_value_based_on_buffering(memc),

1518

memcached_set(memc,

1519

test_literal_param("number"),

1520

test_literal_param("0"),

1521

(time_t)0, (uint32_t)0));

1522

1523

uint64_t new_number;

1524

test_compare(MEMCACHED_SUCCESS, memcached_increment(memc,

1525

test_literal_param("number"),

1526

1, &new_number));

1527

test_compare(uint64_t(1), new_number);

1528

1529

test_compare(MEMCACHED_SUCCESS, memcached_increment(memc,

1530

test_literal_param("number"),

1531

1, &new_number));

1532

test_compare(uint64_t(2), new_number);

1533

1534

return TEST_SUCCESS;

1535

}

1536

1537

test_return_t quit_test(memcached_st *memc)

1538

{

1539

const char *value= "sanford and sun";

1540

1541

test_compare(return_value_based_on_buffering(memc),

1542

memcached_set(memc,

1543

test_literal_param(__func__),

1544

value, strlen(value),

1545

(time_t)10, (uint32_t)3));

897

1546

memcached_quit(memc);

898

1547

899

rc= memcached_set(memc, key, strlen(key),

900

value, strlen(value),

901

(time_t)50, (uint32_t)9);

902

assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);

1548

test_compare(return_value_based_on_buffering(memc),

1549

memcached_set(memc,

1550

test_literal_param(__func__),

1551

value, strlen(value),

1552

(time_t)50, (uint32_t)9));

903

1553

904

return 0;

1554

return TEST_SUCCESS;

905

1555

}

906

1556

907

test_return mget_result_test(memcached_st *memc)

1557

test_return_t mget_result_test(memcached_st *memc)

908

1558

{

909

memcached_return rc;

910

char *keys[]= {"fudge", "son", "food"};

1559

const char *keys[]= {"fudge", "son", "food"};

911

1560

size_t key_length[]= {5, 3, 4};

912

unsigned int x;

913

1561

914

1562

memcached_result_st results_obj;

915

1563

memcached_result_st *results;

916

1564

917

1565

results= memcached_result_create(memc, &results_obj);

918

assert(results);

919

assert(&results_obj == results);

1566

test_true(results);

1567

test_true(&results_obj == results);

920

1568

921

1569

/* We need to empty the server before continueing test */

922

rc= memcached_flush(memc, 0);

923

assert(rc == MEMCACHED_SUCCESS);

924

925

rc= memcached_mget(memc, keys, key_length, 3);

926

assert(rc == MEMCACHED_SUCCESS);

927

928

while ((results= memcached_fetch_result(memc, &results_obj, &rc)) != NULL)

1570

test_compare(MEMCACHED_SUCCESS,

1571

memcached_flush(memc, 0));

1572

1573

test_compare(MEMCACHED_SUCCESS,

1574

memcached_mget(memc, keys, key_length, 3));

1575

1576

memcached_return_t rc;

1577

while ((results= memcached_fetch_result(memc, &results_obj, &rc)))

929

1578

{

930

assert(results);

1579

test_true(results);

931

1580

}

932

1581

933

while ((results= memcached_fetch_result(memc, &results_obj, &rc)) != NULL)

934

assert(!results);

935

assert(rc == MEMCACHED_END);

1582

while ((results= memcached_fetch_result(memc, &results_obj, &rc))) { test_true(false); /* We should never see a value returned */ };

1583

test_false(results);

1584

test_compare_got(MEMCACHED_NOTFOUND, rc, memcached_strerror(NULL, rc));

936

1585

937

for (x= 0; x < 3; x++)

1586

for (uint32_t x= 0; x < 3; x++)

938

1587

{

939

rc= memcached_set(memc, keys[x], key_length[x],

1588

rc= memcached_set(memc, keys[x], key_length[x],

940

1589

keys[x], key_length[x],

941

1590

(time_t)50, (uint32_t)9);

942

assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);

1591

test_true_got(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED, memcached_strerror(NULL, rc));

943

1592

}

944

1593

945

rc= memcached_mget(memc, keys, key_length, 3);

946

assert(rc == MEMCACHED_SUCCESS);

1594

test_compare(MEMCACHED_SUCCESS,

1595

memcached_mget(memc, keys, key_length, 3));

947

1596

948

1597

while ((results= memcached_fetch_result(memc, &results_obj, &rc)))

949

1598

{

950

assert(results);

951

assert(&results_obj == results);

952

assert(rc == MEMCACHED_SUCCESS);

953

assert(memcached_result_key_length(results) == memcached_result_length(results));

954

assert(!memcmp(memcached_result_key_value(results),

955

memcached_result_value(results),

956

memcached_result_length(results)));

1599

test_true(results);

1600

test_true(&results_obj == results);

1601

test_compare(MEMCACHED_SUCCESS, rc);

1602

test_memcmp(memcached_result_key_value(results),

1603

memcached_result_value(results),

1604

memcached_result_length(results));

1605

test_compare(memcached_result_key_length(results), memcached_result_length(results));

957

1606

}

958

1607

959

1608

memcached_result_free(&results_obj);

960

1609

961

return 0;

1610

return TEST_SUCCESS;

962

1611

}

963

1612

964

test_return mget_result_alloc_test(memcached_st *memc)

1613

test_return_t mget_result_alloc_test(memcached_st *memc)

965

1614

{

966

memcached_return rc;

967

char *keys[]= {"fudge", "son", "food"};

1615

const char *keys[]= {"fudge", "son", "food"};

968

1616

size_t key_length[]= {5, 3, 4};

969

unsigned int x;

970

1617

971

1618

memcached_result_st *results;

972

1619

973

1620

/* We need to empty the server before continueing test */

974

rc= memcached_flush(memc, 0);

975

assert(rc == MEMCACHED_SUCCESS);

976

977

rc= memcached_mget(memc, keys, key_length, 3);

978

assert(rc == MEMCACHED_SUCCESS);

979

980

while ((results= memcached_fetch_result(memc, NULL, &rc)) != NULL)

1621

test_compare(MEMCACHED_SUCCESS,

1622

memcached_flush(memc, 0));

1623

1624

test_compare(MEMCACHED_SUCCESS,

1625

memcached_mget(memc, keys, key_length, 3));

1626

1627

memcached_return_t rc;

1628

while ((results= memcached_fetch_result(memc, NULL, &rc)))

981

1629

{

982

assert(results);

1630

test_true(results);

983

1631

}

984

assert(!results);

985

assert(rc == MEMCACHED_END);

1632

test_false(results);

1633

test_compare_got(MEMCACHED_NOTFOUND, rc, memcached_strerror(NULL, rc));

986

1634

987

for (x= 0; x < 3; x++)

1635

for (uint32_t x= 0; x < 3; x++)

988

1636

{

989

rc= memcached_set(memc, keys[x], key_length[x],

1637

rc= memcached_set(memc, keys[x], key_length[x],

990

1638

keys[x], key_length[x],

991

1639

(time_t)50, (uint32_t)9);

992

assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);

1640

test_true_got(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED, memcached_strerror(NULL, rc));

993

1641

}

994

1642

995

rc= memcached_mget(memc, keys, key_length, 3);

996

assert(rc == MEMCACHED_SUCCESS);

1643

test_compare(MEMCACHED_SUCCESS,

1644

memcached_mget(memc, keys, key_length, 3));

997

1645

998

x= 0;

1646

uint32_t x= 0;

999

1647

while ((results= memcached_fetch_result(memc, NULL, &rc)))

1000

1648

{

1001

assert(results);

1002

assert(rc == MEMCACHED_SUCCESS);

1003

assert(memcached_result_key_length(results) == memcached_result_length(results));

1004

assert(!memcmp(memcached_result_key_value(results),

1005

memcached_result_value(results),

1006

memcached_result_length(results)));

1649

test_true(results);

1650

test_compare(MEMCACHED_SUCCESS, rc);

1651

test_compare(memcached_result_key_length(results), memcached_result_length(results));

1652

test_memcmp(memcached_result_key_value(results),

1653

memcached_result_value(results),

1654

memcached_result_length(results));

1007

1655

memcached_result_free(results);

1008

1656

x++;

1009

1657

}

1010

1658

1011

return 0;

1012

}

1013

1014

/* Count the results */

1015

unsigned int callback_counter(memcached_st *ptr, memcached_result_st *result, void *context)

1016

{

1017

unsigned int *counter= (unsigned int *)context;

1018

1019

*counter= *counter + 1;

1020

1021

return 0;

1022

}

1023

1024

test_return mget_result_function(memcached_st *memc)

1025

{

1026

memcached_return rc;

1027

char *keys[]= {"fudge", "son", "food"};

1659

return TEST_SUCCESS;

1660

}

1661

1662

test_return_t mget_result_function(memcached_st *memc)

1663

{

1664

const char *keys[]= {"fudge", "son", "food"};

1028

1665

size_t key_length[]= {5, 3, 4};

1029

unsigned int x;

1030

unsigned int counter;

1031

memcached_execute_function callbacks[1];

1666

size_t counter;

1667

memcached_execute_fn callbacks[1];

1032

1668

1033

/* We need to empty the server before continueing test */

1034

rc= memcached_flush(memc, 0);

1035

for (x= 0; x < 3; x++)

1669

for (uint32_t x= 0; x < 3; x++)

1036

1670

{

1037

rc= memcached_set(memc, keys[x], key_length[x],

1038

keys[x], key_length[x],

1039

(time_t)50, (uint32_t)9);

1040

assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);

1671

test_compare(return_value_based_on_buffering(memc),

1672

memcached_set(memc, keys[x], key_length[x],

1673

keys[x], key_length[x],

1674

time_t(50), uint32_t(9)));

1041

1675

}

1676

test_compare(MEMCACHED_SUCCESS, memcached_flush_buffers(memc));

1677

memcached_quit(memc);

1042

1678

1043

rc= memcached_mget(memc, keys, key_length, 3);

1044

assert(rc == MEMCACHED_SUCCESS);

1679

test_compare(MEMCACHED_SUCCESS,

1680

memcached_mget(memc, keys, key_length, 3));

1045

1681

1046

1682

callbacks[0]= &callback_counter;

1047

1683

counter= 0;

1048

rc= memcached_fetch_execute(memc, callbacks, (void *)&counter, 1);

1049

1050

assert(counter == 3);

1051

1052

return 0;

1684

1685

test_compare(MEMCACHED_SUCCESS,

1686

memcached_fetch_execute(memc, callbacks, (void *)&counter, 1));

1687

1688

test_compare(size_t(3), counter);

1689

1690

return TEST_SUCCESS;

1053

1691

}

1054

1692

1055

test_return mget_test(memcached_st *memc)

1693

test_return_t mget_test(memcached_st *memc)

1056

1694

{

1057

memcached_return rc;

1058

char *keys[]= {"fudge", "son", "food"};

1695

const char *keys[]= {"fudge", "son", "food"};

1059

1696

size_t key_length[]= {5, 3, 4};

1060

unsigned int x;

1061

uint32_t flags;

1062

1697

1063

1698

char return_key[MEMCACHED_MAX_KEY];

1064

1699

size_t return_key_length;

1065

1700

char *return_value;

1066

1701

size_t return_value_length;

1067

1702

1068

/* We need to empty the server before continueing test */

1069

rc= memcached_flush(memc, 0);

1070

assert(rc == MEMCACHED_SUCCESS);

1071

1072

rc= memcached_mget(memc, keys, key_length, 3);

1073

assert(rc == MEMCACHED_SUCCESS);

1074

1075

while ((return_value= memcached_fetch(memc, return_key, &return_key_length,

1076

&return_value_length, &flags, &rc)) != NULL)

1703

test_compare(MEMCACHED_SUCCESS,

1704

memcached_mget(memc, keys, key_length, 3));

1705

1706

uint32_t flags;

1707

memcached_return_t rc;

1708

while ((return_value= memcached_fetch(memc, return_key, &return_key_length,

1709

&return_value_length, &flags, &rc)))

1077

1710

{

1078

assert(return_value);

1711

test_true(return_value);

1079

1712

}

1080

assert(!return_value);

1081

assert(return_value_length == 0);

1082

assert(rc == MEMCACHED_END);

1713

test_false(return_value);

1714

test_zero(return_value_length);

1715

test_compare(MEMCACHED_NOTFOUND, rc);

1083

1716

1084

for (x= 0; x < 3; x++)

1717

for (uint32_t x= 0; x < 3; x++)

1085

1718

{

1086

rc= memcached_set(memc, keys[x], key_length[x],

1719

rc= memcached_set(memc, keys[x], key_length[x],

1087

1720

keys[x], key_length[x],

1088

1721

(time_t)50, (uint32_t)9);

1089

assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);

1722

test_true_got(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED, memcached_strerror(NULL, rc));

1090

1723

}

1091

1092

rc= memcached_mget(memc, keys, key_length, 3);

1093

assert(rc == MEMCACHED_SUCCESS);

1094

1095

x= 0;

1096

while ((return_value= memcached_fetch(memc, return_key, &return_key_length,

1724

test_compare(MEMCACHED_SUCCESS,

1725

memcached_mget(memc, keys, key_length, 3));

1726

1727

uint32_t x= 0;

1728

while ((return_value= memcached_fetch(memc, return_key, &return_key_length,

1097

1729

&return_value_length, &flags, &rc)))

1098

1730

{

1099

assert(return_value);

1100

assert(rc == MEMCACHED_SUCCESS);

1101

assert(return_key_length == return_value_length);

1102

assert(!memcmp(return_value, return_key, return_value_length));

1731

test_true(return_value);

1732

test_compare(MEMCACHED_SUCCESS, rc);

1733

if (not memc->_namespace)

1734

{

1735

test_compare(return_key_length, return_value_length);

1736

test_memcmp(return_value, return_key, return_value_length);

1737

}

1103

1738

free(return_value);

1104

1739

x++;

1105

1740

}

1106

1741

1107

return 0;

1108

}

1109

1110

test_return get_stats_keys(memcached_st *memc)

1111

{

1112

char **list;

1113

char **ptr;

1114

memcached_stat_st stat;

1115

memcached_return rc;

1116

1117

list= memcached_stat_get_keys(memc, &stat, &rc);

1118

assert(rc == MEMCACHED_SUCCESS);

1119

for (ptr= list; *ptr; ptr++)

1120

assert(*ptr);

1121

fflush(stdout);

1122

1123

free(list);

1124

1125

return 0;

1126

}

1127

1128

test_return version_string_test(memcached_st *memc)

1129

{

1130

const char *version_string;

1131

1132

version_string= memcached_lib_version();

1133

1134

assert(!strcmp(version_string, LIBMEMCACHED_VERSION_STRING));

1135

1136

return 0;

1137

}

1138

1139

test_return get_stats(memcached_st *memc)

1140

{

1141

unsigned int x;

1142

char **list;

1143

char **ptr;

1144

memcached_return rc;

1145

memcached_stat_st *stat;

1146

1147

stat= memcached_stat(memc, NULL, &rc);

1148

assert(rc == MEMCACHED_SUCCESS);

1149

1150

assert(rc == MEMCACHED_SUCCESS);

1151

assert(stat);

1152

1153

for (x= 0; x < memcached_server_count(memc); x++)

1742

return TEST_SUCCESS;

1743

}

1744

1745

test_return_t mget_execute(memcached_st *original_memc)

1746

{

1747

test_skip(true, memcached_behavior_get(original_memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL));

1748

1749

memcached_st *memc= create_single_instance_memcached(original_memc, "--BINARY-PROTOCOL");

1750

test_true(memc);

1751

1752

keys_st keys(20480);

1753

1754

/* First add all of the items.. */

1755

char blob[1024] = {0};

1756

1757

for (size_t x= 0; x < keys.size(); ++x)

1758

{

1759

uint64_t query_id= memcached_query_id(memc);

1760

memcached_return_t rc= memcached_add(memc,

1761

keys.key_at(x), keys.length_at(x),

1762

blob, sizeof(blob),

1763

0, 0);

1764

test_true_got(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED,

1765

memcached_strerror(NULL, rc));

1766

test_compare(query_id +1, memcached_query_id(memc));

1767

}

1768

1769

/* Try to get all of them with a large multiget */

1770

size_t counter= 0;

1771

memcached_execute_fn callbacks[]= { &callback_counter };

1772

test_compare(MEMCACHED_SUCCESS,

1773

memcached_mget_execute(memc,

1774

keys.keys_ptr(), keys.lengths_ptr(),

1775

keys.size(), callbacks, &counter, 1));

1776

1777

{

1778

uint64_t query_id= memcached_query_id(memc);

1779

test_compare(MEMCACHED_SUCCESS,

1780

memcached_fetch_execute(memc, callbacks, (void *)&counter, 1));

1781

test_compare(query_id, memcached_query_id(memc));

1782

1783

/* Verify that we got all of the items */

1784

test_compare(keys.size(), counter);

1785

}

1786

1787

memcached_free(memc);

1788

1789

return TEST_SUCCESS;

1790

}

1791

1792

#define REGRESSION_BINARY_VS_BLOCK_COUNT 20480

1793

static pairs_st *global_pairs;

1794

1795

test_return_t key_setup(memcached_st *memc)

1796

{

1797

test_skip(TEST_SUCCESS, pre_binary(memc));

1798

1799

global_pairs= pairs_generate(REGRESSION_BINARY_VS_BLOCK_COUNT, 0);

1800

1801

return TEST_SUCCESS;

1802

}

1803

1804

test_return_t key_teardown(memcached_st *)

1805

{

1806

pairs_free(global_pairs);

1807

1808

return TEST_SUCCESS;

1809

}

1810

1811

test_return_t block_add_regression(memcached_st *memc)

1812

{

1813

/* First add all of the items.. */

1814

for (ptrdiff_t x= 0; x < REGRESSION_BINARY_VS_BLOCK_COUNT; ++x)

1815

{

1816

char blob[1024] = {0};

1817

1818

memcached_return_t rc= memcached_add_by_key(memc, "bob", 3, global_pairs[x].key, global_pairs[x].key_length, blob, sizeof(blob), 0, 0);

1819

test_true_got(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_SERVER_MEMORY_ALLOCATION_FAILURE, memcached_strerror(NULL, rc));

1820

}

1821

1822

return TEST_SUCCESS;

1823

}

1824

1825

test_return_t binary_add_regression(memcached_st *memc)

1826

{

1827

test_skip(MEMCACHED_SUCCESS, memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, true));

1828

test_return_t rc= block_add_regression(memc);

1829

1830

return rc;

1831

}

1832

1833

test_return_t get_stats_keys(memcached_st *memc)

1834

{

1835

char **stat_list;

1836

char **ptr;

1837

memcached_stat_st memc_stat;

1838

memcached_return_t rc;

1839

1840

stat_list= memcached_stat_get_keys(memc, &memc_stat, &rc);

1841

test_compare(MEMCACHED_SUCCESS, rc);

1842

for (ptr= stat_list; *ptr; ptr++)

1843

test_true(*ptr);

1844

1845

free(stat_list);

1846

1847

return TEST_SUCCESS;

1848

}

1849

1850

test_return_t version_string_test(memcached_st *)

1851

{

1852

test_strcmp(LIBMEMCACHED_VERSION_STRING, memcached_lib_version());

1853

1854

return TEST_SUCCESS;

1855

}

1856

1857

test_return_t get_stats(memcached_st *memc)

1858

{

1859

memcached_return_t rc;

1860

1861

memcached_stat_st *memc_stat= memcached_stat(memc, NULL, &rc);

1862

test_compare(MEMCACHED_SUCCESS, rc);

1863

test_true(memc_stat);

1864

1865

for (uint32_t x= 0; x < memcached_server_count(memc); x++)

1154

1866

{

1155

list= memcached_stat_get_keys(memc, stat+x, &rc);

1156

assert(rc == MEMCACHED_SUCCESS);

1157

for (ptr= list; *ptr; ptr++);

1867

char **stat_list= memcached_stat_get_keys(memc, memc_stat+x, &rc);

1868

test_compare(MEMCACHED_SUCCESS, rc);

1869

for (char **ptr= stat_list; *ptr; ptr++) {};

1158

1870

1159

free(list);

1871

free(stat_list);

1160

1872

}

1161

1873

1162

memcached_stat_free(NULL, stat);

1874

memcached_stat_free(NULL, memc_stat);

1163

1875

1164

return 0;

1876

return TEST_SUCCESS;

1165

1877

}

1166

1878

1167

test_return add_host_test(memcached_st *memc)

1879

test_return_t add_host_test(memcached_st *memc)

1168

1880

{

1169

unsigned int x;

1170

memcached_server_st *servers;

1171

memcached_return rc;

1172

1881

char servername[]= "0.example.com";

1173

1882

1174

servers= memcached_server_list_append(NULL, servername, 400, &rc);

1175

assert(servers);

1176

assert(1 == memcached_server_list_count(servers));

1883

memcached_return_t rc;

1884

memcached_server_st *servers= memcached_server_list_append_with_weight(NULL, servername, 400, 0, &rc);

1885

test_compare(1U, memcached_server_list_count(servers));

1177

1886

1178

for (x= 2; x < 20; x++)

1887

for (unsigned int x= 2; x < 20; x++)

1179

1888

{

1180

1889

char buffer[SMALL_STRING_LEN];

1181

1890

1182

1891

snprintf(buffer, SMALL_STRING_LEN, "%u.example.com", 400+x);

1183

servers= memcached_server_list_append(servers, buffer, 401,

1892

servers= memcached_server_list_append_with_weight(servers, buffer, 401, 0,

1184

1893

&rc);

1185

assert(rc == MEMCACHED_SUCCESS);

1186

assert(x == memcached_server_list_count(servers));

1894

test_compare(MEMCACHED_SUCCESS, rc);

1895

test_compare(x, memcached_server_list_count(servers));

1187

1896

}

1188

1897

1189

rc= memcached_server_push(memc, servers);

1190

assert(rc == MEMCACHED_SUCCESS);

1191

rc= memcached_server_push(memc, servers);

1192

assert(rc == MEMCACHED_SUCCESS);

1898

test_compare(MEMCACHED_SUCCESS, memcached_server_push(memc, servers));

1899

test_compare(MEMCACHED_SUCCESS, memcached_server_push(memc, servers));

1193

1900

1194

1901

memcached_server_list_free(servers);

1195

1902

1196

return 0;

1197

}

1198

1199

memcached_return clone_test_callback(memcached_st *parent, memcached_st *clone)

1200

{

1201

return MEMCACHED_SUCCESS;

1202

}

1203

1204

memcached_return cleanup_test_callback(memcached_st *ptr)

1205

{

1206

return MEMCACHED_SUCCESS;

1207

}

1208

1209

test_return callback_test(memcached_st *memc)

1903

return TEST_SUCCESS;

1904

}

1905

1906

test_return_t memcached_fetch_result_NOT_FOUND(memcached_st *memc)

1907

{

1908

memcached_return_t rc;

1909

1910

const char *key= "not_found";

1911

size_t key_length= test_literal_param_size("not_found");

1912

1913

test_compare(MEMCACHED_SUCCESS,

1914

memcached_mget(memc, &key, &key_length, 1));

1915

1916

memcached_result_st *result= memcached_fetch_result(memc, NULL, &rc);

1917

test_null(result);

1918

test_compare_got(MEMCACHED_NOTFOUND, rc, memcached_strerror(NULL, rc));

1919

1920

memcached_result_free(result);

1921

1922

return TEST_SUCCESS;

1923

}

1924

1925

static memcached_return_t clone_test_callback(memcached_st *, memcached_st *)

1926

{

1927

return MEMCACHED_SUCCESS;

1928

}

1929

1930

static memcached_return_t cleanup_test_callback(memcached_st *)

1931

{

1932

return MEMCACHED_SUCCESS;

1933

}

1934

1935

test_return_t callback_test(memcached_st *memc)

1210

1936

{

1211

1937

/* Test User Data */

1212

1938

{

1213

1939

int x= 5;

1214

1940

int *test_ptr;

1215

memcached_return rc;

1941

memcached_return_t rc;

1216

1942

1217

rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_USER_DATA, &x);

1218

assert(rc == MEMCACHED_SUCCESS);

1943

test_compare(MEMCACHED_SUCCESS, memcached_callback_set(memc, MEMCACHED_CALLBACK_USER_DATA, &x));

1219

1944

test_ptr= (int *)memcached_callback_get(memc, MEMCACHED_CALLBACK_USER_DATA, &rc);

1220

assert(*test_ptr == x);

1945

test_true(*test_ptr == x);

1221

1946

}

1222

1947

1223

1948

/* Test Clone Callback */

1224

1949

{

1225

memcached_clone_func temp_function;

1226

memcached_return rc;

1950

memcached_clone_fn clone_cb= (memcached_clone_fn)clone_test_callback;

1951

void *clone_cb_ptr= *(void **)&clone_cb;

1952

void *temp_function= NULL;

1227

1953

1228

rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_CLONE_FUNCTION, clone_test_callback);

1229

assert(rc == MEMCACHED_SUCCESS);

1230

temp_function= (memcached_clone_func)memcached_callback_get(memc, MEMCACHED_CALLBACK_CLONE_FUNCTION, &rc);

1231

assert(temp_function == clone_test_callback);

1954

test_compare(MEMCACHED_SUCCESS, memcached_callback_set(memc, MEMCACHED_CALLBACK_CLONE_FUNCTION, clone_cb_ptr));

1955

memcached_return_t rc;

1956

temp_function= memcached_callback_get(memc, MEMCACHED_CALLBACK_CLONE_FUNCTION, &rc);

1957

test_true(temp_function == clone_cb_ptr);

1958

test_compare(MEMCACHED_SUCCESS, rc);

1232

1959

}

1233

1960

1234

1961

/* Test Cleanup Callback */

1235

1962

{

1236

memcached_cleanup_func temp_function;

1237

memcached_return rc;

1963

memcached_cleanup_fn cleanup_cb= (memcached_cleanup_fn)cleanup_test_callback;

1964

void *cleanup_cb_ptr= *(void **)&cleanup_cb;

1965

void *temp_function= NULL;

1966

memcached_return_t rc;

1238

1967

1239

rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_CLONE_FUNCTION, cleanup_test_callback);

1240

assert(rc == MEMCACHED_SUCCESS);

1241

temp_function= (memcached_cleanup_func)memcached_callback_get(memc, MEMCACHED_CALLBACK_CLONE_FUNCTION, &rc);

1242

assert(temp_function == cleanup_test_callback);

1968

test_compare(MEMCACHED_SUCCESS, memcached_callback_set(memc, MEMCACHED_CALLBACK_CLONE_FUNCTION, cleanup_cb_ptr));

1969

temp_function= memcached_callback_get(memc, MEMCACHED_CALLBACK_CLONE_FUNCTION, &rc);

1970

test_true(temp_function == cleanup_cb_ptr);

1243

1971

}

1244

1972

1245

return 0;

1973

return TEST_SUCCESS;

1246

1974

}

1247

1975

1248

1976

/* We don't test the behavior itself, we test the switches */

1249

test_return behavior_test(memcached_st *memc)

1250

{

1251

unsigned long long value;

1252

unsigned int set= 1;

1253

1254

memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, set);

1255

value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NO_BLOCK);

1256

assert(value == 1);

1257

1258

memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, set);

1259

value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY);

1260

assert(value == 1);

1261

1262

set= MEMCACHED_HASH_MD5;

1263

memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, set);

1264

value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_HASH);

1265

assert(value == MEMCACHED_HASH_MD5);

1266

1267

set= 0;

1268

1269

memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, set);

1270

value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NO_BLOCK);

1271

assert(value == 0);

1272

1273

memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, set);

1274

value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY);

1275

assert(value == 0);

1276

1277

set= MEMCACHED_HASH_DEFAULT;

1278

memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, set);

1279

value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_HASH);

1280

assert(value == MEMCACHED_HASH_DEFAULT);

1281

1282

set= MEMCACHED_HASH_CRC;

1283

memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, set);

1284

value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_HASH);

1285

assert(value == MEMCACHED_HASH_CRC);

1286

1287

value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE);

1288

assert(value > 0);

1289

1290

value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE);

1291

assert(value > 0);

1292

1293

return 0;

1294

}

1295

1296

/* Test case provided by Cal Haldenbrand */

1297

test_return user_supplied_bug1(memcached_st *memc)

1298

{

1299

unsigned int setter= 1;

1300

unsigned int x;

1301

1302

unsigned long long total= 0;

1303

int size= 0;

1304

char key[10];

1305

char randomstuff[6 * 1024];

1306

memcached_return rc;

1307

1308

memset(randomstuff, 0, 6 * 1024);

1309

1310

/* We just keep looking at the same values over and over */

1311

srandom(10);

1312

1313

memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, setter);

1314

memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, setter);

1315

1316

1317

/* add key */

1318

for (x= 0 ; total < 20 * 1024576 ; x++ )

1319

{

1320

unsigned int j= 0;

1321

1322

size= (rand() % ( 5 * 1024 ) ) + 400;

1323

memset(randomstuff, 0, 6 * 1024);

1324

assert(size < 6 * 1024); /* Being safe here */

1325

1326

for (j= 0 ; j < size ;j++)

1327

randomstuff[j] = (char) (rand() % 26) + 97;

1328

1329

total += size;

1330

sprintf(key, "%d", x);

1331

rc = memcached_set(memc, key, strlen(key),

1332

randomstuff, strlen(randomstuff), 10, 0);

1333

/* If we fail, lets try again */

1334

if (rc != MEMCACHED_SUCCESS && rc != MEMCACHED_BUFFERED)

1335

rc = memcached_set(memc, key, strlen(key),

1336

randomstuff, strlen(randomstuff), 10, 0);

1337

assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);

1338

}

1339

1340

return 0;

1341

}

1342

1343

/* Test case provided by Cal Haldenbrand */

1344

test_return user_supplied_bug2(memcached_st *memc)

1345

{

1346

int errors;

1347

unsigned int setter;

1348

unsigned int x;

1349

unsigned long long total;

1350

1351

setter= 1;

1352

memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, setter);

1353

memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, setter);

1354

#ifdef NOT_YET

1355

setter = 20 * 1024576;

1356

memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE, setter);

1357

setter = 20 * 1024576;

1358

memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE, setter);

1359

getter = memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE);

1360

getter = memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE);

1361

1362

for (x= 0, errors= 0, total= 0 ; total < 20 * 1024576 ; x++)

1363

#endif

1364

1365

for (x= 0, errors= 0, total= 0 ; total < 24576 ; x++)

1366

{

1367

memcached_return rc= MEMCACHED_SUCCESS;

1368

char buffer[SMALL_STRING_LEN];

1369

uint32_t flags= 0;

1370

size_t val_len= 0;

1371

char *getval;

1372

1373

memset(buffer, 0, SMALL_STRING_LEN);

1374

1375

snprintf(buffer, SMALL_STRING_LEN, "%u", x);

1376

getval= memcached_get(memc, buffer, strlen(buffer),

1377

&val_len, &flags, &rc);

1378

if (rc != MEMCACHED_SUCCESS)

1379

{

1380

if (rc == MEMCACHED_NOTFOUND)

1381

errors++;

1382

else

1383

{

1384

WATCHPOINT_ERROR(rc);

1385

assert(0);

1386

}

1387

1388

continue;

1389

}

1390

total+= val_len;

1391

errors= 0;

1392

free(getval);

1393

}

1394

1395

return 0;

1396

}

1397

1398

/* Do a large mget() over all the keys we think exist */

1399

#define KEY_COUNT 3000 // * 1024576

1400

test_return user_supplied_bug3(memcached_st *memc)

1401

{

1402

memcached_return rc;

1403

unsigned int setter;

1404

unsigned int x;

1405

char **keys;

1406

size_t key_lengths[KEY_COUNT];

1407

1408

setter= 1;

1409

memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, setter);

1410

memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, setter);

1411

#ifdef NOT_YET

1412

setter = 20 * 1024576;

1413

memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE, setter);

1414

setter = 20 * 1024576;

1415

memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE, setter);

1416

getter = memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE);

1417

getter = memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE);

1418

#endif

1419

1420

keys= (char **)malloc(sizeof(char *) * KEY_COUNT);

1421

assert(keys);

1422

memset(keys, 0, (sizeof(char *) * KEY_COUNT));

1423

for (x= 0; x < KEY_COUNT; x++)

1424

{

1425

char buffer[30];

1426

1427

snprintf(buffer, 30, "%u", x);

1428

keys[x]= strdup(buffer);

1429

key_lengths[x]= strlen(keys[x]);

1430

}

1431

1432

rc= memcached_mget(memc, keys, key_lengths, KEY_COUNT);

1433

assert(rc == MEMCACHED_SUCCESS);

1434

1435

/* Turn this into a help function */

1436

{

1437

char return_key[MEMCACHED_MAX_KEY];

1438

size_t return_key_length;

1439

char *return_value;

1440

size_t return_value_length;

1441

uint32_t flags;

1442

1443

while ((return_value= memcached_fetch(memc, return_key, &return_key_length,

1444

&return_value_length, &flags, &rc)))

1445

{

1446

assert(return_value);

1447

assert(rc == MEMCACHED_SUCCESS);

1448

free(return_value);

1449

}

1450

}

1451

1452

for (x= 0; x < KEY_COUNT; x++)

1453

free(keys[x]);

1454

free(keys);

1455

1456

return 0;

1977

test_return_t behavior_test(memcached_st *memc)

1978

{

1979

memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, 1);

1980

test_compare(true, memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NO_BLOCK));

1981

1982

memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, 1);

1983

test_compare(true, memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY));

1984

1985

memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, MEMCACHED_HASH_MD5);

1986

test_compare(uint64_t(MEMCACHED_HASH_MD5), memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_HASH));

1987

1988

memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, 0);

1989

test_zero(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NO_BLOCK));

1990

1991

memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, 0);

1992

test_zero(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY));

1993

1994

memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, MEMCACHED_HASH_DEFAULT);

1995

test_compare(uint64_t(MEMCACHED_HASH_DEFAULT), memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_HASH));

1996

1997

memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, MEMCACHED_HASH_CRC);

1998

test_compare(uint64_t(MEMCACHED_HASH_CRC), memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_HASH));

1999

2000

test_true(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE));

2001

2002

test_true(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE));

2003

2004

uint64_t value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS);

2005

memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS, value +1);

2006

test_compare((value +1), memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS));

2007

2008

return TEST_SUCCESS;

2009

}

2010

2011

test_return_t MEMCACHED_BEHAVIOR_CORK_test(memcached_st *memc)

2012

{

2013

test_compare(MEMCACHED_DEPRECATED,

2014

memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_CORK, true));

2015

2016

// Platform dependent

2017

#if 0

2018

bool value= (bool)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_CORK);

2019

test_false(value);

2020

#endif

2021

2022

return TEST_SUCCESS;

2023

}

2024

2025

2026

test_return_t MEMCACHED_BEHAVIOR_TCP_KEEPALIVE_test(memcached_st *memc)

2027

{

2028

memcached_return_t rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_KEEPALIVE, true);

2029

test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_NOT_SUPPORTED);

2030

2031

bool value= (bool)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_TCP_KEEPALIVE);

2032

2033

if (memcached_success(rc))

2034

{

2035

test_true(value);

2036

}

2037

else

2038

{

2039

test_false(value);

2040

}

2041

2042

return TEST_SUCCESS;

2043

}

2044

2045

2046

test_return_t MEMCACHED_BEHAVIOR_TCP_KEEPIDLE_test(memcached_st *memc)

2047

{

2048

memcached_return_t rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_KEEPIDLE, true);

2049

test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_NOT_SUPPORTED);

2050

2051

bool value= (bool)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_TCP_KEEPIDLE);

2052

2053

if (memcached_success(rc))

2054

{

2055

test_true(value);

2056

}

2057

else

2058

{

2059

test_false(value);

2060

}

2061

2062

return TEST_SUCCESS;

1457

2063

}

1458

2064

1459

2065

/* Make sure we behave properly if server list has no values */

1460

test_return user_supplied_bug4(memcached_st *memc)

2066

test_return_t user_supplied_bug4(memcached_st *memc)

1461

2067

{

1462

memcached_return rc;

1463

char *keys[]= {"fudge", "son", "food"};

2068

const char *keys[]= {"fudge", "son", "food"};

1464

2069

size_t key_length[]= {5, 3, 4};

1465

unsigned int x;

1466

uint32_t flags;

1467

char return_key[MEMCACHED_MAX_KEY];

1468

size_t return_key_length;

1469

char *return_value;

1470

size_t return_value_length;

1471

2070

1472

2071

/* Here we free everything before running a bunch of mget tests */

1473

{

1474

memcached_server_list_free(memc->hosts);

1475

memc->hosts= NULL;

1476

memc->number_of_hosts= 0;

1477

}

2072

memcached_servers_reset(memc);

1478

2073

1479

2074

1480

2075

/* We need to empty the server before continueing test */

1481

rc= memcached_flush(memc, 0);

1482

assert(rc == MEMCACHED_NO_SERVERS);

1483

1484

rc= memcached_mget(memc, keys, key_length, 3);

1485

assert(rc == MEMCACHED_NO_SERVERS);

1486

1487

while ((return_value= memcached_fetch(memc, return_key, &return_key_length,

1488

&return_value_length, &flags, &rc)) != NULL)

1489

{

1490

assert(return_value);

1491

}

1492

assert(!return_value);

1493

assert(return_value_length == 0);

1494

assert(rc == MEMCACHED_NO_SERVERS);

1495

1496

for (x= 0; x < 3; x++)

1497

{

1498

rc= memcached_set(memc, keys[x], key_length[x],

1499

keys[x], key_length[x],

1500

(time_t)50, (uint32_t)9);

1501

assert(rc == MEMCACHED_NO_SERVERS);

1502

}

1503

1504

rc= memcached_mget(memc, keys, key_length, 3);

1505

assert(rc == MEMCACHED_NO_SERVERS);

1506

1507

x= 0;

1508

while ((return_value= memcached_fetch(memc, return_key, &return_key_length,

1509

&return_value_length, &flags, &rc)))

1510

{

1511

assert(return_value);

1512

assert(rc == MEMCACHED_SUCCESS);

1513

assert(return_key_length == return_value_length);

1514

assert(!memcmp(return_value, return_key, return_value_length));

1515

free(return_value);

1516

x++;

1517

}

1518

1519

return 0;

2076

test_compare(MEMCACHED_NO_SERVERS,

2077

memcached_flush(memc, 0));

2078

2079

test_compare(MEMCACHED_NO_SERVERS,

2080

memcached_mget(memc, keys, key_length, 3));

2081

2082

{

2083

unsigned int keys_returned;

2084

memcached_return_t rc;

2085

test_compare(TEST_SUCCESS, fetch_all_results(memc, keys_returned, rc));

2086

test_compare(MEMCACHED_NOTFOUND, rc);

2087

test_zero(keys_returned);

2088

}

2089

2090

for (uint32_t x= 0; x < 3; x++)

2091

{

2092

test_compare(MEMCACHED_NO_SERVERS,

2093

memcached_set(memc, keys[x], key_length[x],

2094

keys[x], key_length[x],

2095

(time_t)50, (uint32_t)9));

2096

}

2097

2098

test_compare(MEMCACHED_NO_SERVERS,

2099

memcached_mget(memc, keys, key_length, 3));

2100

2101

{

2102

char *return_value;

2103

char return_key[MEMCACHED_MAX_KEY];

2104

memcached_return_t rc;

2105

size_t return_key_length;

2106

size_t return_value_length;

2107

uint32_t flags;

2108

uint32_t x= 0;

2109

while ((return_value= memcached_fetch(memc, return_key, &return_key_length,

2110

&return_value_length, &flags, &rc)))

2111

{

2112

test_true(return_value);

2113

test_compare(MEMCACHED_SUCCESS, rc);

2114

test_true(return_key_length == return_value_length);

2115

test_memcmp(return_value, return_key, return_value_length);

2116

free(return_value);

2117

x++;

2118

}

2119

}

2120

2121

return TEST_SUCCESS;

1520

2122

}

1521

2123

1522

2124

#define VALUE_SIZE_BUG5 1048064

1523

test_return user_supplied_bug5(memcached_st *memc)

2125

test_return_t user_supplied_bug5(memcached_st *memc)

1524

2126

{

1525

memcached_return rc;

1526

char *keys[]= {"036790384900", "036790384902", "036790384904", "036790384906"};

2127

const char *keys[]= {"036790384900", "036790384902", "036790384904", "036790384906"};

1527

2128

size_t key_length[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};

1528

char return_key[MEMCACHED_MAX_KEY];

1529

size_t return_key_length;

1530

2129

char *value;

1531

2130

size_t value_length;

1532

2131

uint32_t flags;

2132

char *insert_data= new (std::nothrow) char[VALUE_SIZE_BUG5];

2133

2134

for (uint32_t x= 0; x < VALUE_SIZE_BUG5; x++)

2135

{

2136

insert_data[x]= (signed char)rand();

2137

}

2138

2139

test_compare(MEMCACHED_SUCCESS,

2140

memcached_flush(memc, 0));

2141

2142

memcached_return_t rc;

2143

test_null(memcached_get(memc, keys[0], key_length[0], &value_length, &flags, &rc));

2144

test_compare(MEMCACHED_SUCCESS,

2145

memcached_mget(memc, keys, key_length, 4));

2146

1533

2147

unsigned int count;

1534

unsigned int x;

1535

char insert_data[VALUE_SIZE_BUG5];

1536

1537

for (x= 0; x < VALUE_SIZE_BUG5; x++)

1538

insert_data[x]= rand();

1539

1540

memcached_flush(memc, 0);

1541

value= memcached_get(memc, keys[0], key_length[0],

1542

&value_length, &flags, &rc);

1543

assert(value == NULL);

1544

rc= memcached_mget(memc, keys, key_length, 4);

1545

1546

count= 0;

1547

while ((value= memcached_fetch(memc, return_key, &return_key_length,

1548

&value_length, &flags, &rc)))

1549

count++;

1550

assert(count == 0);

1551

1552

for (x= 0; x < 4; x++)

2148

test_compare(TEST_SUCCESS, fetch_all_results(memc, count, rc));

2149

test_compare(MEMCACHED_NOTFOUND, rc);

2150

test_zero(count);

2151

2152

for (uint32_t x= 0; x < 4; x++)

1553

2153

{

1554

rc= memcached_set(memc, keys[x], key_length[x],

1555

insert_data, VALUE_SIZE_BUG5,

1556

(time_t)0, (uint32_t)0);

1557

assert(rc == MEMCACHED_SUCCESS);

2154

test_compare(MEMCACHED_SUCCESS,

2155

memcached_set(memc, keys[x], key_length[x],

2156

insert_data, VALUE_SIZE_BUG5,

2157

(time_t)0, (uint32_t)0));

1558

2158

}

1559

2159

1560

for (x= 0; x < 10; x++)

2160

for (uint32_t x= 0; x < 10; x++)

1561

2161

{

1562

2162

value= memcached_get(memc, keys[0], key_length[0],

1563

&value_length, &flags, &rc);

1564

assert(value);

1565

free(value);

1566

1567

rc= memcached_mget(memc, keys, key_length, 4);

1568

count= 0;

1569

while ((value= memcached_fetch(memc, return_key, &return_key_length,

1570

&value_length, &flags, &rc)))

1571

{

1572

count++;

1573

free(value);

1574

}

1575

assert(count == 4);

2163

&value_length, &flags, &rc);

2164

test_compare(rc, MEMCACHED_SUCCESS);

2165

test_true(value);

2166

::free(value);

2167

2168

test_compare(MEMCACHED_SUCCESS,

2169

memcached_mget(memc, keys, key_length, 4));

2170

2171

test_compare(TEST_SUCCESS, fetch_all_results(memc, count));

2172

test_compare(4U, count);

1576

2173

}

2174

delete [] insert_data;

1577

2175

1578

return 0;

2176

return TEST_SUCCESS;

1579

2177

}

1580

2178

1581

test_return user_supplied_bug6(memcached_st *memc)

2179

test_return_t user_supplied_bug6(memcached_st *memc)

1582

2180

{

1583

memcached_return rc;

1584

char *keys[]= {"036790384900", "036790384902", "036790384904", "036790384906"};

2181

const char *keys[]= {"036790384900", "036790384902", "036790384904", "036790384906"};

1585

2182

size_t key_length[]= {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};

1586

2183

char return_key[MEMCACHED_MAX_KEY];

1587

2184

size_t return_key_length;

1588

2185

char *value;

1589

2186

size_t value_length;

1590

2187

uint32_t flags;

1591

unsigned int count;

1592

unsigned int x;

1593

char insert_data[VALUE_SIZE_BUG5];

1594

1595

for (x= 0; x < VALUE_SIZE_BUG5; x++)

1596

insert_data[x]= rand();

1597

1598

memcached_flush(memc, 0);

1599

value= memcached_get(memc, keys[0], key_length[0],

1600

&value_length, &flags, &rc);

1601

assert(value == NULL);

1602

assert(rc == MEMCACHED_NOTFOUND);

1603

rc= memcached_mget(memc, keys, key_length, 4);

1604

assert(rc == MEMCACHED_SUCCESS);

1605

1606

count= 0;

1607

while ((value= memcached_fetch(memc, return_key, &return_key_length,

1608

&value_length, &flags, &rc)))

2188

char *insert_data= new (std::nothrow) char[VALUE_SIZE_BUG5];

2189

2190

for (uint32_t x= 0; x < VALUE_SIZE_BUG5; x++)

2191

{

2192

insert_data[x]= (signed char)rand();

2193

}

2194

2195

test_compare(MEMCACHED_SUCCESS, memcached_flush(memc, 0));

2196

2197

test_compare(TEST_SUCCESS, confirm_keys_dont_exist(memc, keys, test_array_length(keys)));

2198

2199

// We will now confirm that memcached_mget() returns success, but we will

2200

// then check to make sure that no actual keys are returned.

2201

test_compare(MEMCACHED_SUCCESS,

2202

memcached_mget(memc, keys, key_length, 4));

2203

2204

memcached_return_t rc;

2205

uint32_t count= 0;

2206

while ((value= memcached_fetch(memc, return_key, &return_key_length,

2207

&value_length, &flags, &rc)))

2208

{

1609

2209

count++;

1610

assert(count == 0);

1611

assert(rc == MEMCACHED_END);

2210

}

2211

test_zero(count);

2212

test_compare_got(MEMCACHED_NOTFOUND, rc, memcached_strerror(NULL, rc));

1612

2213

1613

for (x= 0; x < 4; x++)

2214

for (uint32_t x= 0; x < test_array_length(keys); x++)

1614

2215

{

1615

rc= memcached_set(memc, keys[x], key_length[x],

1616

insert_data, VALUE_SIZE_BUG5,

1617

(time_t)0, (uint32_t)0);

1618

assert(rc == MEMCACHED_SUCCESS);

2216

test_compare(MEMCACHED_SUCCESS,

2217

memcached_set(memc, keys[x], key_length[x],

2218

insert_data, VALUE_SIZE_BUG5,

2219

(time_t)0, (uint32_t)0));

1619

2220

}

2221

test_compare(TEST_SUCCESS, confirm_keys_exist(memc, keys, test_array_length(keys)));

1620

2222

1621

for (x= 0; x < 2; x++)

2223

for (uint32_t x= 0; x < 2; x++)

1622

2224

{

1623

2225

value= memcached_get(memc, keys[0], key_length[0],

1624

&value_length, &flags, &rc);

1625

assert(value);

2226

&value_length, &flags, &rc);

2227

test_true(value);

1626

2228

free(value);

1627

2229

1628

rc= memcached_mget(memc, keys, key_length, 4);

1629

assert(rc == MEMCACHED_SUCCESS);

1630

count= 3;

2230

test_compare(MEMCACHED_SUCCESS,

2231

memcached_mget(memc, keys, key_length, 4));

1631

2232

/* We test for purge of partial complete fetches */

1632

2233

for (count= 3; count; count--)

1633

2234

{

1634

value= memcached_fetch(memc, return_key, &return_key_length,

2235

value= memcached_fetch(memc, return_key, &return_key_length,

1635

2236

&value_length, &flags, &rc);

1636

assert(rc == MEMCACHED_SUCCESS);

1637

assert(!(memcmp(value, insert_data, value_length)));

1638

assert(value_length);

2237

test_compare(MEMCACHED_SUCCESS, rc);

2238

test_memcmp(value, insert_data, value_length);

2239

test_true(value_length);

1639

2240

free(value);

1640

2241

}

1641

2242

}

2243

delete [] insert_data;

1642

2244

1643

return 0;

2245

return TEST_SUCCESS;

1644

2246

}

1645

2247

1646

test_return user_supplied_bug8(memcached_st *memc)

2248

test_return_t user_supplied_bug8(memcached_st *)

1647

2249

{

1648

memcached_return rc;

2250

memcached_return_t rc;

1649

2251

memcached_st *mine;

1650

memcached_st *clone;

2252

memcached_st *memc_clone;

1651

2253

1652

2254

memcached_server_st *servers;

1653

char *server_list= "memcache1.memcache.bk.sapo.pt:11211, memcache1.memcache.bk.sapo.pt:11212, memcache1.memcache.bk.sapo.pt:11213, memcache1.memcache.bk.sapo.pt:11214, memcache2.memcache.bk.sapo.pt:11211, memcache2.memcache.bk.sapo.pt:11212, memcache2.memcache.bk.sapo.pt:11213, memcache2.memcache.bk.sapo.pt:11214";

2255

const char *server_list= "memcache1.memcache.bk.sapo.pt:11211, memcache1.memcache.bk.sapo.pt:11212, memcache1.memcache.bk.sapo.pt:11213, memcache1.memcache.bk.sapo.pt:11214, memcache2.memcache.bk.sapo.pt:11211, memcache2.memcache.bk.sapo.pt:11212, memcache2.memcache.bk.sapo.pt:11213, memcache2.memcache.bk.sapo.pt:11214";

1654

2256

1655

2257

servers= memcached_servers_parse(server_list);

1656

assert(servers);

2258

test_true(servers);

1657

2259

1658

2260

mine= memcached_create(NULL);

1659

2261

rc= memcached_server_push(mine, servers);

1660

assert(rc == MEMCACHED_SUCCESS);

2262

test_compare(MEMCACHED_SUCCESS, rc);

1661

2263

memcached_server_list_free(servers);

1662

2264

1663

assert(mine);

1664

clone= memcached_clone(NULL, mine);

2265

test_true(mine);

2266

memc_clone= memcached_clone(NULL, mine);

1665

2267

1666

2268

memcached_quit(mine);

1667

memcached_quit(clone);

2269

memcached_quit(memc_clone);

1668

2270

1669

2271

1670

2272

memcached_free(mine);

1671

memcached_free(clone);

2273

memcached_free(memc_clone);

1672

2274

1673

return 0;

2275

return TEST_SUCCESS;

1674

2276

}

1675

2277

1676

2278

/* Test flag store/retrieve */

1677

test_return user_supplied_bug7(memcached_st *memc)

2279

test_return_t user_supplied_bug7(memcached_st *memc)

1678

2280

{

1679

memcached_return rc;

1680

char *keys= "036790384900";

1681

size_t key_length= strlen("036790384900");

2281

char *insert_data= new (std::nothrow) char[VALUE_SIZE_BUG5];

2282

test_true(insert_data);

2283

2284

for (size_t x= 0; x < VALUE_SIZE_BUG5; x++)

2285

{

2286

insert_data[x]= (signed char)rand();

2287

}

2288

2289

memcached_flush(memc, 0);

2290

2291

const char *keys= "036790384900";

2292

size_t key_length= strlen(keys);

2293

test_compare_hint(MEMCACHED_SUCCESS, memcached_set(memc, keys, key_length,

2294

insert_data, VALUE_SIZE_BUG5,

2295

time_t(0), 245U),

2296

memcached_last_error_message(memc));

2297

2298

memcached_return_t rc;

2299

size_t value_length;

2300

uint32_t flags= 0;

2301

char *value= memcached_get(memc, keys, key_length,

2302

&value_length, &flags, &rc);

2303

test_compare(245U, flags);

2304

test_true(value);

2305

free(value);

2306

2307

test_compare(MEMCACHED_SUCCESS, memcached_mget(memc, &keys, &key_length, 1));

2308

1682

2309

char return_key[MEMCACHED_MAX_KEY];

1683

2310

size_t return_key_length;

1684

char *value;

1685

size_t value_length;

1686

uint32_t flags;

1687

unsigned int x;

1688

char insert_data[VALUE_SIZE_BUG5];

1689

1690

for (x= 0; x < VALUE_SIZE_BUG5; x++)

1691

insert_data[x]= rand();

1692

1693

memcached_flush(memc, 0);

1694

1695

flags= 245;

1696

rc= memcached_set(memc, keys, key_length,

1697

insert_data, VALUE_SIZE_BUG5,

1698

(time_t)0, flags);

1699

assert(rc == MEMCACHED_SUCCESS);

1700

1701

flags= 0;

1702

value= memcached_get(memc, keys, key_length,

1703

&value_length, &flags, &rc);

1704

assert(flags == 245);

1705

assert(value);

1706

free(value);

1707

1708

rc= memcached_mget(memc, &keys, &key_length, 1);

1709

1710

flags= 0;

1711

value= memcached_fetch(memc, return_key, &return_key_length,

2311

flags= 0;

2312

value= memcached_fetch(memc, return_key, &return_key_length,

1712

2313

&value_length, &flags, &rc);

1713

assert(flags == 245);

1714

assert(value);

2314

test_compare(uint32_t(245), flags);

2315

test_true(value);

1715

2316

free(value);

1716

1717

1718

return 0;

2317

delete [] insert_data;

2318

2319

2320

return TEST_SUCCESS;

1719

2321

}

1720

2322

1721

test_return user_supplied_bug9(memcached_st *memc)

2323

test_return_t user_supplied_bug9(memcached_st *memc)

1722

2324

{

1723

memcached_return rc;

1724

char *keys[]= {"UDATA:edevil@sapo.pt", "fudge&*@#", "for^#@&$not"};

2325

const char *keys[]= {"UDATA:edevil@sapo.pt", "fudge&*@#", "for^#@&$not"};

1725

2326

size_t key_length[3];

1726

unsigned int x;

1727

2327

uint32_t flags;

1728

2328

unsigned count= 0;

1729

2329

1738

2338

key_length[2]= strlen("for^#@&$not");

1739

2339

1740

2340

1741

for (x= 0; x < 3; x++)

2341

for (unsigned int x= 0; x < 3; x++)

1742

2342

{

1743

rc= memcached_set(memc, keys[x], key_length[x],

1744

keys[x], key_length[x],

1745

(time_t)50, (uint32_t)9);

1746

assert(rc == MEMCACHED_SUCCESS);

2343

memcached_return_t rc= memcached_set(memc, keys[x], key_length[x],

2344

keys[x], key_length[x],

2345

(time_t)50, (uint32_t)9);

2346

test_compare(MEMCACHED_SUCCESS, rc);

1747

2347

}

1748

2348

1749

rc= memcached_mget(memc, keys, key_length, 3);

1750

assert(rc == MEMCACHED_SUCCESS);

2349

memcached_return_t rc= memcached_mget(memc, keys, key_length, 3);

2350

test_compare(MEMCACHED_SUCCESS, rc);

1751

2351

1752

2352

/* We need to empty the server before continueing test */

1753

while ((return_value= memcached_fetch(memc, return_key, &return_key_length,

1754

&return_value_length, &flags, &rc)) != NULL)

2353

while ((return_value= memcached_fetch(memc, return_key, &return_key_length,

2354

&return_value_length, &flags, &rc)) != NULL)

1755

2355

{

1756

assert(return_value);

2356

test_true(return_value);

1757

2357

free(return_value);

1758

2358

count++;

1759

2359

}

1760

assert(count == 3);

2360

test_compare(3U, count);

1761

2361

1762

return 0;

2362

return TEST_SUCCESS;

1763

2363

}

1764

2364

1765

2365

/* We are testing with aggressive timeout to get failures */

1766

test_return user_supplied_bug10(memcached_st *memc)

2366

test_return_t user_supplied_bug10(memcached_st *memc)

1767

2367

{

1768

char *key= "foo";

1769

char *value;

2368

test_skip(memc->servers[0].type, MEMCACHED_CONNECTION_TCP);

2369

1770

2370

size_t value_length= 512;

1771

unsigned int x;

1772

int key_len= 3;

1773

memcached_return rc;

1774

2371

unsigned int set= 1;

1775

2372

memcached_st *mclone= memcached_clone(NULL, memc);

1776

int32_t timeout;

1777

2373

1778

2374

memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_NO_BLOCK, set);

1779

2375

memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_TCP_NODELAY, set);

1780

timeout= 2;

1781

memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_POLL_TIMEOUT, timeout);

1782

1783

value = (char*)malloc(value_length * sizeof(char));

1784

1785

for (x= 0; x < value_length; x++)

1786

value[x]= (char) (x % 127);

1787

1788

for (x= 1; x <= 100000; ++x)

1789

{

1790

rc= memcached_set(mclone, key, key_len,value, value_length, 0, 0);

1791

1792

assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_WRITE_FAILURE || rc == MEMCACHED_BUFFERED);

1793

1794

if (rc == MEMCACHED_WRITE_FAILURE)

2376

memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_POLL_TIMEOUT, uint64_t(0));

2377

2378

libtest::vchar_t value;

2379

value.reserve(value_length);

2380

for (uint32_t x= 0; x < value_length; x++)

2381

{

2382

value.push_back(char(x % 127));

2383

}

2384

2385

for (unsigned int x= 1; x <= 100000; ++x)

2386

{

2387

memcached_return_t rc= memcached_set(mclone,

2388

test_literal_param("foo"),

2389

&value[0], value.size(),

2390

0, 0);

2391

2392

test_true_got((rc == MEMCACHED_SUCCESS or rc == MEMCACHED_WRITE_FAILURE or rc == MEMCACHED_BUFFERED or rc == MEMCACHED_TIMEOUT or rc == MEMCACHED_CONNECTION_FAILURE

2393

or rc == MEMCACHED_SERVER_TEMPORARILY_DISABLED),

2394

memcached_strerror(NULL, rc));

2395

2396

if (rc == MEMCACHED_WRITE_FAILURE or rc == MEMCACHED_TIMEOUT)

2397

{

1795

2398

x--;

2399

}

1796

2400

}

1797

2401

1798

free(value);

1799

2402

memcached_free(mclone);

1800

2403

1801

return 0;

2404

return TEST_SUCCESS;

1802

2405

}

1803

2406

1804

2407

1805

2408

We are looking failures in the async protocol

1806

2409

1807

test_return user_supplied_bug11(memcached_st *memc)

2410

test_return_t user_supplied_bug11(memcached_st *memc)

1808

2411

{

1809

char *key= "foo";

1810

char *value;

1811

size_t value_length= 512;

1812

unsigned int x;

1813

int key_len= 3;

1814

memcached_return rc;

1815

unsigned int set= 1;

1816

int32_t timeout;

1817

2412

memcached_st *mclone= memcached_clone(NULL, memc);

1818

2413

1819

memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_NO_BLOCK, set);

1820

memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_TCP_NODELAY, set);

1821

timeout= -1;

1822

memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_POLL_TIMEOUT, timeout);

1823

1824

timeout= (int32_t)memcached_behavior_get(mclone, MEMCACHED_BEHAVIOR_POLL_TIMEOUT);

1825

1826

assert(timeout == -1);

1827

1828

value = (char*)malloc(value_length * sizeof(char));

1829

1830

for (x= 0; x < value_length; x++)

1831

value[x]= (char) (x % 127);

1832

1833

for (x= 1; x <= 100000; ++x)

1834

{

1835

rc= memcached_set(mclone, key, key_len,value, value_length, 0, 0);

1836

}

1837

1838

free(value);

2414

memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_NO_BLOCK, true);

2415

memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_TCP_NODELAY, true);

2416

memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_POLL_TIMEOUT, size_t(-1));

2417

2418

test_compare(-1, int32_t(memcached_behavior_get(mclone, MEMCACHED_BEHAVIOR_POLL_TIMEOUT)));

2419

2420

2421

libtest::vchar_t value;

2422

value.reserve(512);

2423

for (unsigned int x= 0; x < 512; x++)

2424

{

2425

value.push_back(char(x % 127));

2426

}

2427

2428

for (unsigned int x= 1; x <= 100000; ++x)

2429

{

2430

memcached_return_t rc= memcached_set(mclone, test_literal_param("foo"), &value[0], value.size(), 0, 0);

2431

(void)rc;

2432

}

2433

1839

2434

memcached_free(mclone);

1840

2435

1841

return 0;

2436

return TEST_SUCCESS;

1842

2437

}

1843

2438

1844

2439

1845

2440

Bug found where incr was not returning MEMCACHED_NOTFOUND when object did not exist.

1846

2441

1847

test_return user_supplied_bug12(memcached_st *memc)

2442

test_return_t user_supplied_bug12(memcached_st *memc)

1848

2443

{

1849

memcached_return rc;

2444

memcached_return_t rc;

1850

2445

uint32_t flags;

1851

2446

size_t value_length;

1852

2447

char *value;

1853

2448

uint64_t number_value;

1854

2449

1855

2450

value= memcached_get(memc, "autoincrement", strlen("autoincrement"),

1856

&value_length, &flags, &rc);

1857

assert(value == NULL);

1858

assert(rc == MEMCACHED_NOTFOUND);

2451

&value_length, &flags, &rc);

2452

test_null(value);

2453

test_compare(MEMCACHED_NOTFOUND, rc);

1859

2454

1860

2455

rc= memcached_increment(memc, "autoincrement", strlen("autoincrement"),

1861

2456

1, &number_value);

1862

1863

assert(value == NULL);

1864

assert(rc == MEMCACHED_NOTFOUND);

1865

1866

rc= memcached_set(memc, "autoincrement", strlen("autoincrement"), "1", 1, 0, 0);

1867

1868

value= memcached_get(memc, "autoincrement", strlen("autoincrement"),

1869

&value_length, &flags, &rc);

1870

assert(value);

1871

assert(rc == MEMCACHED_SUCCESS);

2457

test_null(value);

2458

/* The binary protocol will set the key if it doesn't exist */

2459

if (memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) == 1)

2460

{

2461

test_compare(MEMCACHED_SUCCESS, rc);

2462

}

2463

else

2464

{

2465

test_compare(MEMCACHED_NOTFOUND, rc);

2466

}

2467

2468

test_compare(MEMCACHED_SUCCESS,

2469

memcached_set(memc, "autoincrement", strlen("autoincrement"), "1", 1, 0, 0));

2470

2471

value= memcached_get(memc, "autoincrement", strlen("autoincrement"), &value_length, &flags, &rc);

2472

test_true(value);

1872

2473

free(value);

1873

2474

1874

rc= memcached_increment(memc, "autoincrement", strlen("autoincrement"),

1875

1, &number_value);

1876

assert(number_value == 2);

1877

assert(rc == MEMCACHED_SUCCESS);

2475

test_compare(MEMCACHED_SUCCESS,

2476

memcached_increment(memc, "autoincrement", strlen("autoincrement"), 1, &number_value));

2477

test_compare(2UL, number_value);

1878

2478

1879

return 0;

2479

return TEST_SUCCESS;

1880

2480

}

1881

2481

1882

2482

1883

2483

Bug found where command total one more than MEMCACHED_MAX_BUFFER

1884

2484

set key34567890 0 0 8169 \r\n is sent followed by buffer of size 8169, followed by 8169

1885

1886

test_return user_supplied_bug13(memcached_st *memc)

2485

2486

test_return_t user_supplied_bug13(memcached_st *memc)

1887

2487

{

1888

2488

char key[] = "key34567890";

1889

char *overflow;

1890

memcached_return rc;

1891

size_t overflowSize;

1892

2489

1893

2490

char commandFirst[]= "set key34567890 0 0 ";

1894

2491

char commandLast[] = " \r\n"; /* first line of command sent to server */

1895

2492

size_t commandLength;

1896

size_t testSize;

1897

2493

1898

2494

commandLength = strlen(commandFirst) + strlen(commandLast) + 4; /* 4 is number of characters in size, probably 8196 */

1899

2495

1900

overflowSize = MEMCACHED_MAX_BUFFER - commandLength;

2496

size_t overflowSize = MEMCACHED_MAX_BUFFER - commandLength;

1901

2497

1902

for (testSize= overflowSize - 1; testSize < overflowSize + 1; testSize++)

2498

for (size_t testSize= overflowSize - 1; testSize < overflowSize + 1; testSize++)

1903

2499

{

1904

overflow= malloc(testSize);

1905

assert(overflow != NULL);

2500

char *overflow= new (std::nothrow) char[testSize];

2501

test_true(overflow);

1906

2502

1907

2503

memset(overflow, 'x', testSize);

1908

rc= memcached_set(memc, key, strlen(key),

1909

overflow, testSize, 0, 0);

1910

assert(rc == MEMCACHED_SUCCESS);

1911

free(overflow);

2504

test_compare(MEMCACHED_SUCCESS,

2505

memcached_set(memc, key, strlen(key),

2506

overflow, testSize, 0, 0));

2507

delete [] overflow;

1912

2508

}

1913

2509

1914

return 0;

2510

return TEST_SUCCESS;

1915

2511

}

1916

2512

1917

2513

1920

2516

Bug found where command total one more than MEMCACHED_MAX_BUFFER

1921

2517

set key34567890 0 0 8169 \r\n

1922

2518

is sent followed by buffer of size 8169, followed by 8169

1923

1924

test_return user_supplied_bug14(memcached_st *memc)

2519

2520

test_return_t user_supplied_bug14(memcached_st *memc)

1925

2521

{

1926

int setter= 1;

1927

memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, setter);

1928

memcached_return rc;

1929

char *key= "foo";

1930

char *value;

1931

size_t value_length= 18000;

1932

char *string;

1933

size_t string_length;

1934

uint32_t flags;

1935

unsigned int x;

1936

size_t current_length;

1937

1938

value = (char*)malloc(value_length);

1939

assert(value);

1940

1941

for (x= 0; x < value_length; x++)

1942

value[x] = (char) (x % 127);

1943

1944

for (current_length= 0; current_length < value_length; current_length++)

1945

{

1946

rc= memcached_set(memc, key, strlen(key),

1947

value, current_length,

1948

(time_t)0, (uint32_t)0);

1949

assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);

1950

1951

string= memcached_get(memc, key, strlen(key),

1952

&string_length, &flags, &rc);

1953

1954

assert(rc == MEMCACHED_SUCCESS);

1955

assert(string_length == current_length);

1956

assert(!memcmp(string, value, string_length));

2522

memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, true);

2523

2524

libtest::vchar_t value;

2525

value.reserve(18000);

2526

for (ptrdiff_t x= 0; x < 18000; x++)

2527

{

2528

value.push_back((char) (x % 127));

2529

}

2530

2531

for (size_t current_length= 1; current_length < value.size(); current_length++)

2532

{

2533

memcached_return_t rc= memcached_set(memc, test_literal_param("foo"),

2534

&value[0], current_length,

2535

(time_t)0, (uint32_t)0);

2536

test_true(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED);

2537

2538

size_t string_length;

2539

uint32_t flags;

2540

char *string= memcached_get(memc, test_literal_param("foo"),

2541

&string_length, &flags, &rc);

2542

2543

test_compare(MEMCACHED_SUCCESS, rc);

2544

test_compare(string_length, current_length);

2545

char buffer[1024];

2546

snprintf(buffer, sizeof(buffer), "%u", uint32_t(string_length));

2547

test_memcmp_hint(string, &value[0], string_length, buffer);

1957

2548

1958

2549

free(string);

1959

2550

}

1960

2551

1961

free(value);

1962

1963

return 0;

2552

return TEST_SUCCESS;

1964

2553

}

1965

2554

1966

2555

1967

2556

Look for zero length value problems

1968

1969

test_return user_supplied_bug15(memcached_st *memc)

1970

{

1971

uint32_t x;

1972

memcached_return rc;

1973

char *key= "mykey";

1974

char *value;

1975

size_t length;

1976

uint32_t flags;

1977

1978

for (x= 0; x < 2; x++)

1979

{

1980

rc= memcached_set(memc, key, strlen(key),

1981

NULL, 0,

1982

(time_t)0, (uint32_t)0);

1983

1984

assert(rc == MEMCACHED_SUCCESS);

1985

1986

value= memcached_get(memc, key, strlen(key),

1987

&length, &flags, &rc);

1988

1989

assert(rc == MEMCACHED_SUCCESS);

1990

assert(value == NULL);

1991

assert(length == 0);

1992

assert(flags == 0);

1993

1994

value= memcached_get(memc, key, strlen(key),

1995

&length, &flags, &rc);

1996

1997

assert(rc == MEMCACHED_SUCCESS);

1998

assert(value == NULL);

1999

assert(length == 0);

2000

assert(flags == 0);

2001

}

2002

2003

return 0;

2004

}

2005

2006

test_return result_static(memcached_st *memc)

2557

2558

test_return_t user_supplied_bug15(memcached_st *memc)

2559

{

2560

for (uint32_t x= 0; x < 2; x++)

2561

{

2562

memcached_return_t rc= memcached_set(memc, test_literal_param("mykey"),

2563

NULL, 0,

2564

(time_t)0, (uint32_t)0);

2565

2566

test_compare(MEMCACHED_SUCCESS, rc);

2567

2568

size_t length;

2569

uint32_t flags;

2570

char *value= memcached_get(memc, test_literal_param("mykey"),

2571

&length, &flags, &rc);

2572

2573

test_compare(MEMCACHED_SUCCESS, rc);

2574

test_false(value);

2575

test_zero(length);

2576

test_zero(flags);

2577

2578

value= memcached_get(memc, test_literal_param("mykey"),

2579

&length, &flags, &rc);

2580

2581

test_compare(MEMCACHED_SUCCESS, rc);

2582

test_null(value);

2583

test_zero(length);

2584

test_zero(flags);

2585

}

2586

2587

return TEST_SUCCESS;

2588

}

2589

2590

/* Check the return sizes on FLAGS to make sure it stores 32bit unsigned values correctly */

2591

test_return_t user_supplied_bug16(memcached_st *memc)

2592

{

2593

test_compare_hint(MEMCACHED_SUCCESS, memcached_set(memc, test_literal_param("mykey"),

2594

NULL, 0,

2595

(time_t)0, UINT32_MAX),

2596

memcached_last_error_message(memc));

2597

2598

2599

size_t length;

2600

uint32_t flags;

2601

memcached_return_t rc;

2602

char *value= memcached_get(memc, test_literal_param("mykey"),

2603

&length, &flags, &rc);

2604

2605

test_compare(MEMCACHED_SUCCESS, rc);

2606

test_null(value);

2607

test_zero(length);

2608

test_compare(flags, UINT32_MAX);

2609

2610

return TEST_SUCCESS;

2611

}

2612

2613

#if !defined(__sun) && !defined(__OpenBSD__)

2614

/* Check the validity of chinese key*/

2615

test_return_t user_supplied_bug17(memcached_st *memc)

2616

{

2617

const char *key= "豆瓣";

2618

const char *value="我们在炎热抑郁的夏天无法停止豆瓣";

2619

memcached_return_t rc= memcached_set(memc, key, strlen(key),

2620

value, strlen(value),

2621

(time_t)0, 0);

2622

2623

test_compare(MEMCACHED_SUCCESS, rc);

2624

2625

size_t length;

2626

uint32_t flags;

2627

char *value2= memcached_get(memc, key, strlen(key),

2628

&length, &flags, &rc);

2629

2630

test_true(length==strlen(value));

2631

test_compare(MEMCACHED_SUCCESS, rc);

2632

test_memcmp(value, value2, length);

2633

free(value2);

2634

2635

return TEST_SUCCESS;

2636

}

2637

#endif

2638

2639

2640

From Andrei on IRC

2641

2642

2643

test_return_t user_supplied_bug19(memcached_st *)

2644

{

2645

memcached_return_t res;

2646

2647

memcached_st *memc= memcached(test_literal_param("--server=localhost:11311/?100 --server=localhost:11312/?100"));

2648

2649

const memcached_server_st *server= memcached_server_by_key(memc, "a", 1, &res);

2650

test_true(server);

2651

2652

memcached_free(memc);

2653

2654

return TEST_SUCCESS;

2655

}

2656

2657

/* CAS test from Andei */

2658

test_return_t user_supplied_bug20(memcached_st *memc)

2659

{

2660

const char *key= "abc";

2661

size_t key_len= strlen("abc");

2662

2663

test_skip(MEMCACHED_SUCCESS, memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS, true));

2664

2665

test_compare(MEMCACHED_SUCCESS,

2666

memcached_set(memc,

2667

test_literal_param("abc"),

2668

test_literal_param("foobar"),

2669

(time_t)0, (uint32_t)0));

2670

2671

test_compare(MEMCACHED_SUCCESS,

2672

memcached_mget(memc, &key, &key_len, 1));

2673

2674

memcached_result_st result_obj;

2675

memcached_result_st *result= memcached_result_create(memc, &result_obj);

2676

test_true(result);

2677

2678

memcached_result_create(memc, &result_obj);

2679

memcached_return_t status;

2680

result= memcached_fetch_result(memc, &result_obj, &status);

2681

2682

test_true(result);

2683

test_compare(MEMCACHED_SUCCESS, status);

2684

2685

memcached_result_free(result);

2686

2687

return TEST_SUCCESS;

2688

}

2689

2690

/* Large mget() of missing keys with binary proto

2691

2692

* If many binary quiet commands (such as getq's in an mget) fill the output

2693

* buffer and the server chooses not to respond, memcached_flush hangs. See

2694

* http://lists.tangent.org/pipermail/libmemcached/2009-August/000918.html

2695

2696

2697

/* sighandler_t function that always asserts false */

2698

static void fail(int)

2699

{

2700

fatal_assert(0);

2701

}

2702

2703

2704

test_return_t _user_supplied_bug21(memcached_st* memc, size_t key_count)

2705

{

2706

#ifdef WIN32

2707

(void)memc;

2708

(void)key_count;

2709

return TEST_SKIPPED;

2710

#else

2711

void (*oldalarm)(int);

2712

2713

memcached_st *memc_clone= memcached_clone(NULL, memc);

2714

test_true(memc_clone);

2715

2716

/* only binproto uses getq for mget */

2717

test_compare(MEMCACHED_SUCCESS, memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, true));

2718

2719

/* empty the cache to ensure misses (hence non-responses) */

2720

test_compare(MEMCACHED_SUCCESS, memcached_flush(memc_clone, 0));

2721

2722

keys_st keys(key_count);

2723

2724

oldalarm= signal(SIGALRM, fail);

2725

alarm(5);

2726

2727

test_compare_got(MEMCACHED_SUCCESS,

2728

memcached_mget(memc_clone, keys.keys_ptr(), keys.lengths_ptr(), keys.size()),

2729

memcached_last_error_message(memc_clone));

2730

2731

alarm(0);

2732

signal(SIGALRM, oldalarm);

2733

2734

memcached_return_t rc;

2735

uint32_t flags;

2736

char return_key[MEMCACHED_MAX_KEY];

2737

size_t return_key_length;

2738

char *return_value;

2739

size_t return_value_length;

2740

while ((return_value= memcached_fetch(memc, return_key, &return_key_length,

2741

&return_value_length, &flags, &rc)))

2742

{

2743

test_false(return_value); // There are no keys to fetch, so the value should never be returned

2744

}

2745

test_compare(MEMCACHED_NOTFOUND, rc);

2746

test_zero(return_value_length);

2747

test_zero(return_key_length);

2748

test_false(return_key[0]);

2749

test_false(return_value);

2750

2751

memcached_free(memc_clone);

2752

2753

return TEST_SUCCESS;

2754

#endif

2755

}

2756

2757

test_return_t user_supplied_bug21(memcached_st *memc)

2758

{

2759

test_skip(TEST_SUCCESS, pre_binary(memc));

2760

2761

/* should work as of r580 */

2762

test_compare(TEST_SUCCESS,

2763

_user_supplied_bug21(memc, 10));

2764

2765

/* should fail as of r580 */

2766

test_compare(TEST_SUCCESS,

2767

_user_supplied_bug21(memc, 1000));

2768

2769

return TEST_SUCCESS;

2770

}

2771

2772

test_return_t output_ketama_weighted_keys(memcached_st *)

2773

{

2774

memcached_st *memc= memcached_create(NULL);

2775

test_true(memc);

2776

2777

2778

test_compare(MEMCACHED_SUCCESS,

2779

memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED, true));

2780

2781

uint64_t value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED);

2782

test_compare(value, uint64_t(1));

2783

2784

test_compare(MEMCACHED_SUCCESS,

2785

memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA_HASH, MEMCACHED_HASH_MD5));

2786

2787

value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA_HASH);

2788

test_true(value == MEMCACHED_HASH_MD5);

2789

2790

2791

test_true(memcached_behavior_set_distribution(memc, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY) == MEMCACHED_SUCCESS);

2792

2793

memcached_server_st *server_pool;

2794

server_pool = memcached_servers_parse("10.0.1.1:11211,10.0.1.2:11211,10.0.1.3:11211,10.0.1.4:11211,10.0.1.5:11211,10.0.1.6:11211,10.0.1.7:11211,10.0.1.8:11211,192.168.1.1:11211,192.168.100.1:11211");

2795

memcached_server_push(memc, server_pool);

2796

2797

// @todo this needs to be refactored to actually test something.

2798

#if 0

2799

FILE *fp;

2800

if ((fp = fopen("ketama_keys.txt", "w")))

2801

{

2802

// noop

2803

} else {

2804

printf("cannot write to file ketama_keys.txt");

2805

return TEST_FAILURE;

2806

}

2807

2808

for (int x= 0; x < 10000; x++)

2809

{

2810

char key[10];

2811

snprintf(key, sizeof(key), "%d", x);

2812

2813

uint32_t server_idx = memcached_generate_hash(memc, key, strlen(key));

2814

char *hostname = memc->hosts[server_idx].hostname;

2815

in_port_t port = memc->hosts[server_idx].port;

2816

fprintf(fp, "key %s is on host /%s:%u\n", key, hostname, port);

2817

memcached_server_instance_st instance=

2818

memcached_server_instance_by_position(memc, host_index);

2819

}

2820

fclose(fp);

2821

#endif

2822

memcached_server_list_free(server_pool);

2823

memcached_free(memc);

2824

2825

return TEST_SUCCESS;

2826

}

2827

2828

2829

test_return_t result_static(memcached_st *memc)

2007

2830

{

2008

2831

memcached_result_st result;

2009

memcached_result_st *result_ptr;

2832

memcached_result_st *result_ptr= memcached_result_create(memc, &result);

2833

test_false(result.options.is_allocated);

2834

test_true(memcached_is_initialized(&result));

2835

test_true(result_ptr);

2836

test_true(result_ptr == &result);

2010

2837

2011

result_ptr= memcached_result_create(memc, &result);

2012

assert(result.is_allocated == MEMCACHED_NOT_ALLOCATED);

2013

assert(result_ptr);

2014

2838

memcached_result_free(&result);

2015

2839

2016

return 0;

2017

}

2018

2019

test_return result_alloc(memcached_st *memc)

2020

{

2021

memcached_result_st *result;

2022

2023

result= memcached_result_create(memc, NULL);

2024

assert(result);

2025

memcached_result_free(result);

2026

2027

return 0;

2028

}

2029

2030

test_return string_static_null(memcached_st *memc)

2031

{

2032

memcached_string_st string;

2033

memcached_string_st *string_ptr;

2034

2035

string_ptr= memcached_string_create(memc, &string, 0);

2036

assert(string.is_allocated == MEMCACHED_NOT_ALLOCATED);

2037

assert(string_ptr);

2038

memcached_string_free(&string);

2039

2040

return 0;

2041

}

2042

2043

test_return string_alloc_null(memcached_st *memc)

2044

{

2045

memcached_string_st *string;

2046

2047

string= memcached_string_create(memc, NULL, 0);

2048

assert(string);

2049

memcached_string_free(string);

2050

2051

return 0;

2052

}

2053

2054

test_return string_alloc_with_size(memcached_st *memc)

2055

{

2056

memcached_string_st *string;

2057

2058

string= memcached_string_create(memc, NULL, 1024);

2059

assert(string);

2060

memcached_string_free(string);

2061

2062

return 0;

2063

}

2064

2065

test_return string_alloc_with_size_toobig(memcached_st *memc)

2066

{

2067

memcached_string_st *string;

2068

2069

string= memcached_string_create(memc, NULL, INT64_MAX);

2070

assert(string == NULL);

2071

2072

return 0;

2073

}

2074

2075

test_return string_alloc_append(memcached_st *memc)

2076

{

2077

unsigned int x;

2078

char buffer[SMALL_STRING_LEN];

2079

memcached_string_st *string;

2080

2081

/* Ring the bell! */

2082

memset(buffer, 6, SMALL_STRING_LEN);

2083

2084

string= memcached_string_create(memc, NULL, 100);

2085

assert(string);

2086

2087

for (x= 0; x < 1024; x++)

2088

{

2089

memcached_return rc;

2090

rc= memcached_string_append(string, buffer, SMALL_STRING_LEN);

2091

assert(rc == MEMCACHED_SUCCESS);

2092

}

2093

memcached_string_free(string);

2094

2095

return 0;

2096

}

2097

2098

test_return string_alloc_append_toobig(memcached_st *memc)

2099

{

2100

memcached_return rc;

2101

unsigned int x;

2102

char buffer[SMALL_STRING_LEN];

2103

memcached_string_st *string;

2104

2105

/* Ring the bell! */

2106

memset(buffer, 6, SMALL_STRING_LEN);

2107

2108

string= memcached_string_create(memc, NULL, 100);

2109

assert(string);

2110

2111

for (x= 0; x < 1024; x++)

2112

{

2113

rc= memcached_string_append(string, buffer, SMALL_STRING_LEN);

2114

assert(rc == MEMCACHED_SUCCESS);

2115

}

2116

rc= memcached_string_append(string, buffer, INT64_MAX);

2117

assert(rc == MEMCACHED_MEMORY_ALLOCATION_FAILURE);

2118

memcached_string_free(string);

2119

2120

return 0;

2121

}

2122

2123

test_return cleanup_pairs(memcached_st *memc)

2124

{

2125

pairs_free(global_pairs);

2126

2127

return 0;

2128

}

2129

2130

test_return generate_pairs(memcached_st *memc)

2131

{

2132

unsigned long long x;

2133

global_pairs= pairs_generate(GLOBAL_COUNT, 400);

2134

global_count= GLOBAL_COUNT;

2135

2136

for (x= 0; x < global_count; x++)

2137

{

2138

global_keys[x]= global_pairs[x].key;

2139

global_keys_length[x]= global_pairs[x].key_length;

2140

}

2141

2142

return 0;

2143

}

2144

2145

test_return generate_large_pairs(memcached_st *memc)

2146

{

2147

unsigned long long x;

2148

global_pairs= pairs_generate(GLOBAL2_COUNT, MEMCACHED_MAX_BUFFER+10);

2149

global_count= GLOBAL2_COUNT;

2150

2151

for (x= 0; x < global_count; x++)

2152

{

2153

global_keys[x]= global_pairs[x].key;

2154

global_keys_length[x]= global_pairs[x].key_length;

2155

}

2156

2157

return 0;

2158

}

2159

2160

test_return generate_data(memcached_st *memc)

2161

{

2162

execute_set(memc, global_pairs, global_count);

2163

2164

return 0;

2165

}

2166

2167

test_return generate_buffer_data(memcached_st *memc)

2168

{

2169

int latch= 0;

2170

2171

latch= 1;

2172

memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, latch);

2173

generate_data(memc);

2174

2175

return 0;

2176

}

2177

2178

test_return get_read_count(memcached_st *memc)

2179

{

2180

unsigned int x;

2181

memcached_return rc;

2182

memcached_st *clone;

2183

2184

clone= memcached_clone(NULL, memc);

2185

assert(clone);

2186

2187

memcached_server_add(clone, "localhost", 6666);

2188

2189

{

2190

char *return_value;

2191

size_t return_value_length;

2192

uint32_t flags;

2193

uint32_t count;

2194

2195

for (x= count= 0; x < global_count; x++)

2196

{

2197

return_value= memcached_get(clone, global_keys[x], global_keys_length[x],

2198

&return_value_length, &flags, &rc);

2199

if (rc == MEMCACHED_SUCCESS)

2200

{

2201

count++;

2202

if (return_value)

2203

free(return_value);

2204

}

2205

}

2206

fprintf(stderr, "\t%u -> %u", global_count, count);

2207

}

2208

2209

memcached_free(clone);

2210

2211

return 0;

2212

}

2213

2214

test_return get_read(memcached_st *memc)

2215

{

2216

unsigned int x;

2217

memcached_return rc;

2218

2219

{

2220

char *return_value;

2221

size_t return_value_length;

2222

uint32_t flags;

2223

2224

for (x= 0; x < global_count; x++)

2225

{

2226

return_value= memcached_get(memc, global_keys[x], global_keys_length[x],

2227

&return_value_length, &flags, &rc);

2228

2229

assert(return_value);

2230

assert(rc == MEMCACHED_SUCCESS);

2231

2232

if (rc == MEMCACHED_SUCCESS && return_value)

2233

free(return_value);

2234

}

2235

}

2236

2237

return 0;

2238

}

2239

2240

test_return mget_read(memcached_st *memc)

2241

{

2242

memcached_return rc;

2243

2244

rc= memcached_mget(memc, global_keys, global_keys_length, global_count);

2245

assert(rc == MEMCACHED_SUCCESS);

2246

/* Turn this into a help function */

2247

{

2248

char return_key[MEMCACHED_MAX_KEY];

2249

size_t return_key_length;

2250

char *return_value;

2251

size_t return_value_length;

2252

uint32_t flags;

2253

2254

while ((return_value= memcached_fetch(memc, return_key, &return_key_length,

2255

&return_value_length, &flags, &rc)))

2256

{

2257

assert(return_value);

2258

assert(rc == MEMCACHED_SUCCESS);

2259

free(return_value);

2260

}

2261

}

2262

2263

return 0;

2264

}

2265

2266

test_return mget_read_result(memcached_st *memc)

2267

{

2268

memcached_return rc;

2269

2270

rc= memcached_mget(memc, global_keys, global_keys_length, global_count);

2271

assert(rc == MEMCACHED_SUCCESS);

2272

/* Turn this into a help function */

2273

{

2274

memcached_result_st results_obj;

2275

memcached_result_st *results;

2276

2277

results= memcached_result_create(memc, &results_obj);

2278

2279

while ((results= memcached_fetch_result(memc, &results_obj, &rc)))

2280

{

2281

assert(results);

2282

assert(rc == MEMCACHED_SUCCESS);

2283

}

2284

2285

memcached_result_free(&results_obj);

2286

}

2287

2288

return 0;

2289

}

2290

2291

test_return mget_read_function(memcached_st *memc)

2292

{

2293

memcached_return rc;

2294

unsigned int counter;

2295

unsigned int (*callbacks[1])(memcached_st *, memcached_result_st *, void *);

2296

2297

rc= memcached_mget(memc, global_keys, global_keys_length, global_count);

2298

assert(rc == MEMCACHED_SUCCESS);

2299

2300

callbacks[0]= &callback_counter;

2301

counter= 0;

2302

rc= memcached_fetch_execute(memc, callbacks, (void *)&counter, 1);

2303

2304

return 0;

2305

}

2306

2307

test_return delete_generate(memcached_st *memc)

2308

{

2309

unsigned int x;

2310

2311

for (x= 0; x < global_count; x++)

2312

{

2313

(void)memcached_delete(memc, global_keys[x], global_keys_length[x], (time_t)0);

2314

}

2315

2316

return 0;

2317

}

2318

2319

test_return delete_buffer_generate(memcached_st *memc)

2320

{

2321

int latch= 0;

2322

unsigned int x;

2323

2324

latch= 1;

2325

memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, latch);

2326

2327

for (x= 0; x < global_count; x++)

2328

{

2329

(void)memcached_delete(memc, global_keys[x], global_keys_length[x], (time_t)0);

2330

}

2331

2332

return 0;

2333

}

2334

2335

test_return free_data(memcached_st *memc)

2336

{

2337

pairs_free(global_pairs);

2338

2339

return 0;

2340

}

2341

2342

test_return add_host_test1(memcached_st *memc)

2343

{

2344

unsigned int x;

2345

memcached_return rc;

2840

test_false(result.options.is_allocated);

2841

test_false(memcached_is_initialized(&result));

2842

2843

return TEST_SUCCESS;

2844

}

2845

2846

test_return_t result_alloc(memcached_st *memc)

2847

{

2848

memcached_result_st *result_ptr= memcached_result_create(memc, NULL);

2849

test_true(result_ptr);

2850

test_true(result_ptr->options.is_allocated);

2851

test_true(memcached_is_initialized(result_ptr));

2852

memcached_result_free(result_ptr);

2853

2854

return TEST_SUCCESS;

2855

}

2856

2857

2858

test_return_t add_host_test1(memcached_st *memc)

2859

{

2860

memcached_return_t rc;

2346

2861

char servername[]= "0.example.com";

2347

memcached_server_st *servers;

2348

2349

servers= memcached_server_list_append(NULL, servername, 400, &rc);

2350

assert(servers);

2351

assert(1 == memcached_server_list_count(servers));

2352

2353

for (x= 2; x < 20; x++)

2862

2863

memcached_server_st *servers= memcached_server_list_append_with_weight(NULL, servername, 400, 0, &rc);

2864

test_true(servers);

2865

test_compare(1U, memcached_server_list_count(servers));

2866

2867

for (uint32_t x= 2; x < 20; x++)

2354

2868

{

2355

2869

char buffer[SMALL_STRING_LEN];

2356

2870

2357

snprintf(buffer, SMALL_STRING_LEN, "%u.example.com", 400+x);

2358

servers= memcached_server_list_append(servers, buffer, 401,

2359

&rc);

2360

assert(rc == MEMCACHED_SUCCESS);

2361

assert(x == memcached_server_list_count(servers));

2871

snprintf(buffer, SMALL_STRING_LEN, "%lu.example.com", (unsigned long)(400 +x));

2872

servers= memcached_server_list_append_with_weight(servers, buffer, 401, 0,

2873

&rc);

2874

test_compare(MEMCACHED_SUCCESS, rc);

2875

test_compare(x, memcached_server_list_count(servers));

2362

2876

}

2363

2877

2364

rc= memcached_server_push(memc, servers);

2365

assert(rc == MEMCACHED_SUCCESS);

2366

rc= memcached_server_push(memc, servers);

2367

assert(rc == MEMCACHED_SUCCESS);

2878

test_compare(MEMCACHED_SUCCESS, memcached_server_push(memc, servers));

2879

test_compare(MEMCACHED_SUCCESS, memcached_server_push(memc, servers));

2368

2880

2369

2881

memcached_server_list_free(servers);

2370

2882

2371

return 0;

2372

}

2373

2374

memcached_return pre_nonblock(memcached_st *memc)

2375

{

2376

memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, 0);

2377

2378

return MEMCACHED_SUCCESS;

2379

}

2380

2381

memcached_return pre_murmur(memcached_st *memc)

2382

{

2383

memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_MURMUR);

2384

2385

return MEMCACHED_SUCCESS;

2386

}

2387

2388

memcached_return pre_md5(memcached_st *memc)

2389

{

2390

memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_MD5);

2391

2392

return MEMCACHED_SUCCESS;

2393

}

2394

2395

memcached_return pre_crc(memcached_st *memc)

2396

{

2397

memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_CRC);

2398

2399

return MEMCACHED_SUCCESS;

2400

}

2401

2402

memcached_return pre_hsieh(memcached_st *memc)

2403

{

2404

memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_HSIEH);

2405

2406

return MEMCACHED_SUCCESS;

2407

}

2408

2409

memcached_return pre_hash_fnv1_64(memcached_st *memc)

2410

{

2411

memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_FNV1_64);

2412

2413

return MEMCACHED_SUCCESS;

2414

}

2415

2416

memcached_return pre_hash_fnv1a_64(memcached_st *memc)

2417

{

2418

memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_FNV1A_64);

2419

2420

return MEMCACHED_SUCCESS;

2421

}

2422

2423

memcached_return pre_hash_fnv1_32(memcached_st *memc)

2424

{

2425

memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_FNV1_32);

2426

2427

return MEMCACHED_SUCCESS;

2428

}

2429

2430

memcached_return pre_hash_fnv1a_32(memcached_st *memc)

2431

{

2432

memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_FNV1A_32);

2433

2434

return MEMCACHED_SUCCESS;

2435

}

2436

2437

memcached_return pre_behavior_ketama(memcached_st *memc)

2438

{

2439

memcached_return rc;

2440

uint64_t value;

2441

2442

rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA, 1);

2443

assert(rc == MEMCACHED_SUCCESS);

2444

2445

value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA);

2446

assert(value == 1);

2447

2448

return MEMCACHED_SUCCESS;

2449

}

2450

2451

void my_free(memcached_st *ptr, void *mem)

2452

{

2883

return TEST_SUCCESS;

2884

}

2885

2886

2887

static void my_free(const memcached_st *ptr, void *mem, void *context)

2888

{

2889

(void)context;

2890

(void)ptr;

2891

#ifdef HARD_MALLOC_TESTS

2892

void *real_ptr= (mem == NULL) ? mem : (void*)((caddr_t)mem - 8);

2893

free(real_ptr);

2894

#else

2453

2895

free(mem);

2454

}

2455

2456

void *my_malloc(memcached_st *ptr, const size_t size)

2457

{

2458

return malloc(size);

2459

}

2460

2461

void *my_realloc(memcached_st *ptr, void *mem, const size_t size)

2462

{

2896

#endif

2897

}

2898

2899

2900

static void *my_malloc(const memcached_st *ptr, const size_t size, void *context)

2901

{

2902

(void)context;

2903

(void)ptr;

2904

#ifdef HARD_MALLOC_TESTS

2905

void *ret= malloc(size + 8);

2906

if (ret != NULL)

2907

{

2908

ret= (void*)((caddr_t)ret + 8);

2909

}

2910

#else

2911

void *ret= malloc(size);

2912

#endif

2913

2914

if (ret != NULL)

2915

{

2916

memset(ret, 0xff, size);

2917

}

2918

2919

return ret;

2920

}

2921

2922

2923

static void *my_realloc(const memcached_st *ptr, void *mem, const size_t size, void *)

2924

{

2925

#ifdef HARD_MALLOC_TESTS

2926

void *real_ptr= (mem == NULL) ? NULL : (void*)((caddr_t)mem - 8);

2927

void *nmem= realloc(real_ptr, size + 8);

2928

2929

void *ret= NULL;

2930

if (nmem != NULL)

2931

{

2932

ret= (void*)((caddr_t)nmem + 8);

2933

}

2934

2935

return ret;

2936

#else

2937

(void)ptr;

2463

2938

return realloc(mem, size);

2464

}

2465

2466

memcached_return set_memory_alloc(memcached_st *memc)

2467

{

2468

{

2469

memcached_malloc_function test_ptr;

2470

memcached_return rc;

2471

2472

rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_MALLOC_FUNCTION, &my_malloc);

2473

assert(rc == MEMCACHED_SUCCESS);

2474

test_ptr= (memcached_malloc_function)memcached_callback_get(memc, MEMCACHED_CALLBACK_MALLOC_FUNCTION, &rc);

2475

assert(rc == MEMCACHED_SUCCESS);

2476

assert(test_ptr == my_malloc);

2477

}

2478

2479

{

2480

memcached_realloc_function test_ptr;

2481

memcached_return rc;

2482

2483

rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_REALLOC_FUNCTION, &my_realloc);

2484

assert(rc == MEMCACHED_SUCCESS);

2485

test_ptr= (memcached_realloc_function)memcached_callback_get(memc, MEMCACHED_CALLBACK_REALLOC_FUNCTION, &rc);

2486

assert(rc == MEMCACHED_SUCCESS);

2487

assert(test_ptr == my_realloc);

2488

}

2489

2490

{

2491

memcached_free_function test_ptr;

2492

memcached_return rc;

2493

2494

rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_FREE_FUNCTION, my_free);

2495

assert(rc == MEMCACHED_SUCCESS);

2496

test_ptr= (memcached_free_function)memcached_callback_get(memc, MEMCACHED_CALLBACK_FREE_FUNCTION, &rc);

2497

assert(rc == MEMCACHED_SUCCESS);

2498

assert(test_ptr == my_free);

2499

}

2500

2501

return MEMCACHED_SUCCESS;

2502

}

2503

2504

memcached_return enable_wheel(memcached_st *memc)

2505

{

2506

memcached_server_distribution value= MEMCACHED_DISTRIBUTION_CONSISTENT_WHEEL;

2507

memcached_hash hash;

2508

memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_DISTRIBUTION, value);

2509

pre_hsieh(memc);

2510

2511

value= (memcached_server_distribution)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_DISTRIBUTION);

2512

assert(value == MEMCACHED_DISTRIBUTION_CONSISTENT_WHEEL);

2513

2514

hash= (memcached_hash)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_HASH);

2515

assert(hash == MEMCACHED_HASH_HSIEH);

2516

2517

2518

return MEMCACHED_SUCCESS;

2519

}

2520

2521

memcached_return enable_consistent(memcached_st *memc)

2522

{

2523

memcached_server_distribution value= MEMCACHED_DISTRIBUTION_CONSISTENT;

2524

memcached_hash hash;

2525

memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_DISTRIBUTION, value);

2526

pre_hsieh(memc);

2527

2528

value= (memcached_server_distribution)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_DISTRIBUTION);

2529

assert(value == MEMCACHED_DISTRIBUTION_CONSISTENT);

2530

2531

hash= (memcached_hash)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_HASH);

2532

assert(hash == MEMCACHED_HASH_HSIEH);

2533

2534

2535

return MEMCACHED_SUCCESS;

2536

}

2537

2538

memcached_return enable_cas(memcached_st *memc)

2939

#endif

2940

}

2941

2942

2943

static void *my_calloc(const memcached_st *ptr, size_t nelem, const size_t size, void *)

2944

{

2945

#ifdef HARD_MALLOC_TESTS

2946

void *mem= my_malloc(ptr, nelem * size);

2947

if (mem)

2948

{

2949

memset(mem, 0, nelem * size);

2950

}

2951

2952

return mem;

2953

#else

2954

(void)ptr;

2955

return calloc(nelem, size);

2956

#endif

2957

}

2958

2959

test_return_t selection_of_namespace_tests(memcached_st *memc)

2960

{

2961

memcached_return_t rc;

2962

const char *key= "mine";

2963

char *value;

2964

2965

/* Make sure be default none exists */

2966

value= (char*)memcached_callback_get(memc, MEMCACHED_CALLBACK_NAMESPACE, &rc);

2967

test_null(value);

2968

test_compare_got(MEMCACHED_SUCCESS, rc, memcached_strerror(NULL, rc));

2969

2970

/* Test a clean set */

2971

test_compare(MEMCACHED_SUCCESS,

2972

memcached_callback_set(memc, MEMCACHED_CALLBACK_NAMESPACE, (void *)key));

2973

2974

value= (char*)memcached_callback_get(memc, MEMCACHED_CALLBACK_NAMESPACE, &rc);

2975

test_true(value);

2976

test_memcmp(value, key, 4);

2977

test_compare_got(MEMCACHED_SUCCESS, rc, memcached_strerror(NULL, rc));

2978

2979

/* Test that we can turn it off */

2980

test_compare(MEMCACHED_SUCCESS,

2981

memcached_callback_set(memc, MEMCACHED_CALLBACK_NAMESPACE, NULL));

2982

2983

value= (char*)memcached_callback_get(memc, MEMCACHED_CALLBACK_NAMESPACE, &rc);

2984

test_null(value);

2985

test_compare_got(MEMCACHED_SUCCESS, rc, memcached_strerror(NULL, rc));

2986

2987

/* Now setup for main test */

2988

test_compare(MEMCACHED_SUCCESS,

2989

memcached_callback_set(memc, MEMCACHED_CALLBACK_NAMESPACE, (void *)key));

2990

2991

value= (char *)memcached_callback_get(memc, MEMCACHED_CALLBACK_NAMESPACE, &rc);

2992

test_true(value);

2993

test_compare_got(MEMCACHED_SUCCESS, rc, memcached_strerror(NULL, rc));

2994

test_memcmp(value, key, 4);

2995

2996

/* Set to Zero, and then Set to something too large */

2997

{

2998

char long_key[255];

2999

memset(long_key, 0, 255);

3000

3001

test_compare(MEMCACHED_SUCCESS,

3002

memcached_callback_set(memc, MEMCACHED_CALLBACK_NAMESPACE, NULL));

3003

3004

value= (char*)memcached_callback_get(memc, MEMCACHED_CALLBACK_NAMESPACE, &rc);

3005

test_null(value);

3006

test_compare(MEMCACHED_SUCCESS, rc);

3007

3008

/* Test a long key for failure */

3009

/* TODO, extend test to determine based on setting, what result should be */

3010

strncpy(long_key, "Thisismorethentheallottednumberofcharacters", sizeof(long_key));

3011

test_compare(MEMCACHED_SUCCESS,

3012

memcached_callback_set(memc, MEMCACHED_CALLBACK_NAMESPACE, long_key));

3013

3014

/* Now test a key with spaces (which will fail from long key, since bad key is not set) */

3015

strncpy(long_key, "This is more then the allotted number of characters", sizeof(long_key));

3016

test_compare(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) ? MEMCACHED_SUCCESS : MEMCACHED_BAD_KEY_PROVIDED,

3017

memcached_callback_set(memc, MEMCACHED_CALLBACK_NAMESPACE, long_key));

3018

3019

/* Test for a bad prefix, but with a short key */

3020

test_compare(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) ? MEMCACHED_INVALID_ARGUMENTS : MEMCACHED_SUCCESS,

3021

memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_VERIFY_KEY, 1));

3022

3023

test_compare(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) ? MEMCACHED_SUCCESS : MEMCACHED_BAD_KEY_PROVIDED,

3024

memcached_callback_set(memc, MEMCACHED_CALLBACK_NAMESPACE, "dog cat"));

3025

}

3026

3027

return TEST_SUCCESS;

3028

}

3029

3030

test_return_t set_namespace(memcached_st *memc)

3031

{

3032

memcached_return_t rc;

3033

const char *key= "mine";

3034

char *value;

3035

3036

// Make sure we default to a null namespace

3037

value= (char*)memcached_callback_get(memc, MEMCACHED_CALLBACK_NAMESPACE, &rc);

3038

test_null(value);

3039

test_compare_got(MEMCACHED_SUCCESS, rc, memcached_strerror(NULL, rc));

3040

3041

/* Test a clean set */

3042

test_compare(MEMCACHED_SUCCESS,

3043

memcached_callback_set(memc, MEMCACHED_CALLBACK_NAMESPACE, (void *)key));

3044

3045

value= (char*)memcached_callback_get(memc, MEMCACHED_CALLBACK_NAMESPACE, &rc);

3046

test_true(value);

3047

test_memcmp(value, key, 4);

3048

test_compare_got(MEMCACHED_SUCCESS, rc, memcached_strerror(NULL, rc));

3049

3050

return TEST_SUCCESS;

3051

}

3052

3053

test_return_t set_namespace_and_binary(memcached_st *memc)

3054

{

3055

test_return_if(pre_binary(memc));

3056

test_return_if(set_namespace(memc));

3057

3058

return TEST_SUCCESS;

3059

}

3060

3061

#ifdef MEMCACHED_ENABLE_DEPRECATED

3062

test_return_t deprecated_set_memory_alloc(memcached_st *memc)

3063

{

3064

void *test_ptr= NULL;

3065

void *cb_ptr= NULL;

3066

{

3067

memcached_malloc_fn malloc_cb= (memcached_malloc_fn)my_malloc;

3068

cb_ptr= *(void **)&malloc_cb;

3069

memcached_return_t rc;

3070

3071

test_compare(MEMCACHED_SUCCESS,

3072

memcached_callback_set(memc, MEMCACHED_CALLBACK_MALLOC_FUNCTION, cb_ptr));

3073

test_ptr= memcached_callback_get(memc, MEMCACHED_CALLBACK_MALLOC_FUNCTION, &rc);

3074

test_compare(MEMCACHED_SUCCESS, rc);

3075

test_true(test_ptr == cb_ptr);

3076

}

3077

3078

{

3079

memcached_realloc_fn realloc_cb=

3080

(memcached_realloc_fn)my_realloc;

3081

cb_ptr= *(void **)&realloc_cb;

3082

memcached_return_t rc;

3083

3084

test_compare(MEMCACHED_SUCCESS,

3085

memcached_callback_set(memc, MEMCACHED_CALLBACK_REALLOC_FUNCTION, cb_ptr));

3086

test_ptr= memcached_callback_get(memc, MEMCACHED_CALLBACK_REALLOC_FUNCTION, &rc);

3087

test_compare(MEMCACHED_SUCCESS, rc);

3088

test_true(test_ptr == cb_ptr);

3089

}

3090

3091

{

3092

memcached_free_fn free_cb=

3093

(memcached_free_fn)my_free;

3094

cb_ptr= *(void **)&free_cb;

3095

memcached_return_t rc;

3096

3097

test_compare(MEMCACHED_SUCCESS,

3098

memcached_callback_set(memc, MEMCACHED_CALLBACK_FREE_FUNCTION, cb_ptr));

3099

test_ptr= memcached_callback_get(memc, MEMCACHED_CALLBACK_FREE_FUNCTION, &rc);

3100

test_compare(MEMCACHED_SUCCESS, rc);

3101

test_true(test_ptr == cb_ptr);

3102

}

3103

3104

return TEST_SUCCESS;

3105

}

3106

#endif

3107

3108

3109

test_return_t set_memory_alloc(memcached_st *memc)

3110

{

3111

test_compare(MEMCACHED_INVALID_ARGUMENTS,

3112

memcached_set_memory_allocators(memc, NULL, my_free,

3113

my_realloc, my_calloc, NULL));

3114

3115

test_compare(MEMCACHED_SUCCESS,

3116

memcached_set_memory_allocators(memc, my_malloc, my_free,

3117

my_realloc, my_calloc, NULL));

3118

3119

memcached_malloc_fn mem_malloc;

3120

memcached_free_fn mem_free;

3121

memcached_realloc_fn mem_realloc;

3122

memcached_calloc_fn mem_calloc;

3123

memcached_get_memory_allocators(memc, &mem_malloc, &mem_free,

3124

&mem_realloc, &mem_calloc);

3125

3126

test_true(mem_malloc == my_malloc);

3127

test_true(mem_realloc == my_realloc);

3128

test_true(mem_calloc == my_calloc);

3129

test_true(mem_free == my_free);

3130

3131

return TEST_SUCCESS;

3132

}

3133

3134

test_return_t enable_consistent_crc(memcached_st *memc)

3135

{

3136

test_return_t rc;

3137

memcached_server_distribution_t value= MEMCACHED_DISTRIBUTION_CONSISTENT;

3138

memcached_hash_t hash;

3139

memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_DISTRIBUTION, value);

3140

if ((rc= pre_crc(memc)) != TEST_SUCCESS)

3141

return rc;

3142

3143

value= (memcached_server_distribution_t)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_DISTRIBUTION);

3144

test_true(value == MEMCACHED_DISTRIBUTION_CONSISTENT);

3145

3146

hash= (memcached_hash_t)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_HASH);

3147

3148

if (hash != MEMCACHED_HASH_CRC)

3149

return TEST_SKIPPED;

3150

3151

return TEST_SUCCESS;

3152

}

3153

3154

test_return_t enable_consistent_hsieh(memcached_st *memc)

3155

{

3156

test_return_t rc;

3157

memcached_server_distribution_t value= MEMCACHED_DISTRIBUTION_CONSISTENT;

3158

memcached_hash_t hash;

3159

memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_DISTRIBUTION, value);

3160

if ((rc= pre_hsieh(memc)) != TEST_SUCCESS)

3161

{

3162

return rc;

3163

}

3164

3165

value= (memcached_server_distribution_t)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_DISTRIBUTION);

3166

test_true(value == MEMCACHED_DISTRIBUTION_CONSISTENT);

3167

3168

hash= (memcached_hash_t)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_HASH);

3169

3170

if (hash != MEMCACHED_HASH_HSIEH)

3171

return TEST_SKIPPED;

3172

3173

3174

return TEST_SUCCESS;

3175

}

3176

3177

test_return_t enable_cas(memcached_st *memc)

2539

3178

{

2540

3179

unsigned int set= 1;

2541

3180

2542

memcached_version(memc);

2543

2544

if (memc->hosts[0].major_version >= 1 &&

2545

memc->hosts[0].minor_version >= 2 &&

2546

memc->hosts[0].micro_version >= 4)

3181

if (libmemcached_util_version_check(memc, 1, 2, 4))

2547

3182

{

2548

3183

memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS, set);

2549

3184

2550

return MEMCACHED_SUCCESS;

3185

return TEST_SUCCESS;

2551

3186

}

2552

3187

2553

return MEMCACHED_FAILURE;

3188

return TEST_SKIPPED;

2554

3189

}

2555

3190

2556

memcached_return check_for_1_2_3(memcached_st *memc)

3191

test_return_t check_for_1_2_3(memcached_st *memc)

2557

3192

{

2558

3193

memcached_version(memc);

2559

3194

2560

if (memc->hosts[0].major_version >= 1 &&

2561

memc->hosts[0].minor_version >= 2 &&

2562

memc->hosts[0].micro_version >= 4)

2563

return MEMCACHED_SUCCESS;

2564

2565

return MEMCACHED_FAILURE;

2566

}

2567

2568

memcached_return pre_unix_socket(memcached_st *memc)

2569

{

2570

memcached_return rc;

2571

struct stat buf;

2572

2573

memcached_server_list_free(memc->hosts);

2574

memc->hosts= NULL;

2575

memc->number_of_hosts= 0;

2576

2577

if (stat("/tmp/memcached.socket", &buf))

2578

return MEMCACHED_FAILURE;

2579

2580

rc= memcached_server_add_unix_socket(memc, "/tmp/memcached.socket");

2581

2582

return rc;

2583

}

2584

2585

memcached_return pre_udp(memcached_st *memc)

2586

{

2587

memcached_return rc;

2588

2589

memcached_server_list_free(memc->hosts);

2590

memc->hosts= NULL;

2591

memc->number_of_hosts= 0;

2592

2593

if (0)

2594

return MEMCACHED_FAILURE;

2595

2596

rc= memcached_server_add_udp(memc, "localhost", MEMCACHED_DEFAULT_PORT);

2597

2598

return rc;

2599

}

2600

2601

memcached_return pre_nodelay(memcached_st *memc)

2602

{

2603

memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, 0);

2604

memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, 0);

2605

2606

return MEMCACHED_SUCCESS;

2607

}

2608

2609

memcached_return poll_timeout(memcached_st *memc)

2610

{

2611

int32_t timeout;

2612

2613

timeout= 100;

3195

memcached_server_instance_st instance=

3196

memcached_server_instance_by_position(memc, 0);

3197

3198

if ((instance->major_version >= 1 && (instance->minor_version == 2 && instance->micro_version >= 4))

3199

or instance->minor_version > 2)

3200

{

3201

return TEST_SUCCESS;

3202

}

3203

3204

return TEST_SKIPPED;

3205

}

3206

3207

test_return_t MEMCACHED_BEHAVIOR_POLL_TIMEOUT_test(memcached_st *memc)

3208

{

3209

const uint64_t timeout= 100; // Not using, just checking that it sets

2614

3210

2615

3211

memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_POLL_TIMEOUT, timeout);

2616

3212

2617

timeout= (int32_t)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_POLL_TIMEOUT);

2618

2619

assert(timeout == 100);

3213

test_compare(timeout, memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_POLL_TIMEOUT));

3214

3215

return TEST_SUCCESS;

3216

}

3217

3218

test_return_t noreply_test(memcached_st *memc)

3219

{

3220

test_compare(MEMCACHED_SUCCESS,

3221

memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NOREPLY, true));

3222

test_compare(MEMCACHED_SUCCESS,

3223

memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, true));

3224

test_compare(MEMCACHED_SUCCESS,

3225

memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS, true));

3226

test_compare(1LLU, memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NOREPLY));

3227

test_compare(1LLU, memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS));

3228

test_compare(1LLU, memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS));

3229

3230

memcached_return_t ret;

3231

for (int count= 0; count < 5; ++count)

3232

{

3233

for (size_t x= 0; x < 100; ++x)

3234

{

3235

char key[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH +1];

3236

int check_length= (size_t)snprintf(key, sizeof(key), "%lu", (unsigned long)x);

3237

test_false((size_t)check_length >= sizeof(key) || check_length < 0);

3238

3239

size_t len= (size_t)check_length;

3240

3241

switch (count)

3242

{

3243

case 0:

3244

ret= memcached_add(memc, key, len, key, len, 0, 0);

3245

break;

3246

case 1:

3247

ret= memcached_replace(memc, key, len, key, len, 0, 0);

3248

break;

3249

case 2:

3250

ret= memcached_set(memc, key, len, key, len, 0, 0);

3251

break;

3252

case 3:

3253

ret= memcached_append(memc, key, len, key, len, 0, 0);

3254

break;

3255

case 4:

3256

ret= memcached_prepend(memc, key, len, key, len, 0, 0);

3257

break;

3258

default:

3259

test_true(count);

3260

break;

3261

}

3262

test_true_got(ret == MEMCACHED_SUCCESS or ret == MEMCACHED_BUFFERED,

3263

memcached_strerror(NULL, ret));

3264

}

3265

3266

3267

** NOTE: Don't ever do this in your code! this is not a supported use of the

3268

** API and is _ONLY_ done this way to verify that the library works the

3269

** way it is supposed to do!!!!

3270

3271

#if 0

3272

int no_msg=0;

3273

for (uint32_t x= 0; x < memcached_server_count(memc); ++x)

3274

{

3275

memcached_server_instance_st instance=

3276

memcached_server_instance_by_position(memc, x);

3277

no_msg+=(int)(instance->cursor_active);

3278

}

3279

3280

test_true(no_msg == 0);

3281

#endif

3282

test_compare(MEMCACHED_SUCCESS, memcached_flush_buffers(memc));

3283

3284

3285

** Now validate that all items was set properly!

3286

3287

for (size_t x= 0; x < 100; ++x)

3288

{

3289

char key[10];

3290

3291

int check_length= (size_t)snprintf(key, sizeof(key), "%lu", (unsigned long)x);

3292

3293

test_false((size_t)check_length >= sizeof(key) || check_length < 0);

3294

3295

size_t len= (size_t)check_length;

3296

size_t length;

3297

uint32_t flags;

3298

char* value=memcached_get(memc, key, strlen(key),

3299

&length, &flags, &ret);

3300

test_true_got(ret == MEMCACHED_SUCCESS && value != NULL, memcached_strerror(NULL, ret));

3301

switch (count)

3302

{

3303

case 0: /* FALLTHROUGH */

3304

case 1: /* FALLTHROUGH */

3305

case 2:

3306

test_true(strncmp(value, key, len) == 0);

3307

test_true(len == length);

3308

break;

3309

case 3:

3310

test_true(length == len * 2);

3311

break;

3312

case 4:

3313

test_true(length == len * 3);

3314

break;

3315

default:

3316

test_true(count);

3317

break;

3318

}

3319

free(value);

3320

}

3321

}

3322

3323

/* Try setting an illegal cas value (should not return an error to

3324

* the caller (because we don't expect a return message from the server)

3325

3326

const char* keys[]= {"0"};

3327

size_t lengths[]= {1};

3328

size_t length;

3329

uint32_t flags;

3330

memcached_result_st results_obj;

3331

memcached_result_st *results;

3332

test_compare(MEMCACHED_SUCCESS,

3333

memcached_mget(memc, keys, lengths, 1));

3334

3335

results= memcached_result_create(memc, &results_obj);

3336

test_true(results);

3337

results= memcached_fetch_result(memc, &results_obj, &ret);

3338

test_true(results);

3339

test_compare(MEMCACHED_SUCCESS, ret);

3340

uint64_t cas= memcached_result_cas(results);

3341

memcached_result_free(&results_obj);

3342

3343

test_compare(MEMCACHED_SUCCESS,

3344

memcached_cas(memc, keys[0], lengths[0], keys[0], lengths[0], 0, 0, cas));

3345

3346

3347

* The item will have a new cas value, so try to set it again with the old

3348

* value. This should fail!

3349

3350

test_compare(MEMCACHED_SUCCESS,

3351

memcached_cas(memc, keys[0], lengths[0], keys[0], lengths[0], 0, 0, cas));

3352

test_true(memcached_flush_buffers(memc) == MEMCACHED_SUCCESS);

3353

char* value=memcached_get(memc, keys[0], lengths[0], &length, &flags, &ret);

3354

test_true(ret == MEMCACHED_SUCCESS && value != NULL);

3355

free(value);

3356

3357

return TEST_SUCCESS;

3358

}

3359

3360

test_return_t analyzer_test(memcached_st *memc)

3361

{

3362

memcached_analysis_st *report;

3363

memcached_return_t rc;

3364

3365

memcached_stat_st *memc_stat= memcached_stat(memc, NULL, &rc);

3366

test_compare(MEMCACHED_SUCCESS, rc);

3367

test_true(memc_stat);

3368

3369

report= memcached_analyze(memc, memc_stat, &rc);

3370

test_compare(MEMCACHED_SUCCESS, rc);

3371

test_true(report);

3372

3373

free(report);

3374

memcached_stat_free(NULL, memc_stat);

3375

3376

return TEST_SUCCESS;

3377

}

3378

3379

test_return_t util_version_test(memcached_st *memc)

3380

{

3381

test_compare_hint(MEMCACHED_SUCCESS, memcached_version(memc), memcached_last_error_message(memc));

3382

test_true(libmemcached_util_version_check(memc, 0, 0, 0));

3383

3384

bool if_successful= libmemcached_util_version_check(memc, 9, 9, 9);

3385

3386

// We expect failure

3387

if (if_successful)

3388

{

3389

fprintf(stderr, "\n----------------------------------------------------------------------\n");

3390

fprintf(stderr, "\nDumping Server Information\n\n");

3391

memcached_server_fn callbacks[1];

3392

3393

callbacks[0]= dump_server_information;

3394

memcached_server_cursor(memc, callbacks, (void *)stderr, 1);

3395

fprintf(stderr, "\n----------------------------------------------------------------------\n");

3396

}

3397

test_true(if_successful == false);

3398

3399

memcached_server_instance_st instance=

3400

memcached_server_instance_by_position(memc, 0);

3401

3402

memcached_version(memc);

3403

3404

// We only use one binary when we test, so this should be just fine.

3405

if_successful= libmemcached_util_version_check(memc, instance->major_version, instance->minor_version, instance->micro_version);

3406

test_true(if_successful == true);

3407

3408

if (instance->micro_version > 0)

3409

{

3410

if_successful= libmemcached_util_version_check(memc, instance->major_version, instance->minor_version, (uint8_t)(instance->micro_version -1));

3411

}

3412

else if (instance->minor_version > 0)

3413

{

3414

if_successful= libmemcached_util_version_check(memc, instance->major_version, (uint8_t)(instance->minor_version - 1), instance->micro_version);

3415

}

3416

else if (instance->major_version > 0)

3417

{

3418

if_successful= libmemcached_util_version_check(memc, (uint8_t)(instance->major_version -1), instance->minor_version, instance->micro_version);

3419

}

3420

3421

test_true(if_successful == true);

3422

3423

if (instance->micro_version > 0)

3424

{

3425

if_successful= libmemcached_util_version_check(memc, instance->major_version, instance->minor_version, (uint8_t)(instance->micro_version +1));

3426

}

3427

else if (instance->minor_version > 0)

3428

{

3429

if_successful= libmemcached_util_version_check(memc, instance->major_version, (uint8_t)(instance->minor_version +1), instance->micro_version);

3430

}

3431

else if (instance->major_version > 0)

3432

{

3433

if_successful= libmemcached_util_version_check(memc, (uint8_t)(instance->major_version +1), instance->minor_version, instance->micro_version);

3434

}

3435

3436

test_true(if_successful == false);

3437

3438

return TEST_SUCCESS;

3439

}

3440

3441

test_return_t getpid_connection_failure_test(memcached_st *memc)

3442

{

3443

test_skip(memc->servers[0].type, MEMCACHED_CONNECTION_TCP);

3444

memcached_return_t rc;

3445

memcached_server_instance_st instance=

3446

memcached_server_instance_by_position(memc, 0);

3447

3448

// Test both the version that returns a code, and the one that does not.

3449

test_true(libmemcached_util_getpid(memcached_server_name(instance),

3450

memcached_server_port(instance) -1, NULL) == -1);

3451

3452

test_true(libmemcached_util_getpid(memcached_server_name(instance),

3453

memcached_server_port(instance) -1, &rc) == -1);

3454

test_compare_got(MEMCACHED_CONNECTION_FAILURE, rc, memcached_strerror(memc, rc));

3455

3456

return TEST_SUCCESS;

3457

}

3458

3459

3460

test_return_t getpid_test(memcached_st *memc)

3461

{

3462

memcached_return_t rc;

3463

memcached_server_instance_st instance=

3464

memcached_server_instance_by_position(memc, 0);

3465

3466

// Test both the version that returns a code, and the one that does not.

3467

test_true(libmemcached_util_getpid(memcached_server_name(instance),

3468

memcached_server_port(instance), NULL) > -1);

3469

3470

test_true(libmemcached_util_getpid(memcached_server_name(instance),

3471

memcached_server_port(instance), &rc) > -1);

3472

test_compare(MEMCACHED_SUCCESS, rc);

3473

3474

return TEST_SUCCESS;

3475

}

3476

3477

test_return_t ping_test(memcached_st *memc)

3478

{

3479

memcached_return_t rc;

3480

memcached_server_instance_st instance=

3481

memcached_server_instance_by_position(memc, 0);

3482

3483

// Test both the version that returns a code, and the one that does not.

3484

test_true(libmemcached_util_ping(memcached_server_name(instance),

3485

memcached_server_port(instance), NULL));

3486

3487

test_true(libmemcached_util_ping(memcached_server_name(instance),

3488

memcached_server_port(instance), &rc));

3489

3490

test_compare(MEMCACHED_SUCCESS, rc);

3491

3492

return TEST_SUCCESS;

3493

}

3494

3495

3496

#if 0

3497

test_return_t hash_sanity_test (memcached_st *memc)

3498

{

3499

(void)memc;

3500

3501

assert(MEMCACHED_HASH_DEFAULT == MEMCACHED_HASH_DEFAULT);

3502

assert(MEMCACHED_HASH_MD5 == MEMCACHED_HASH_MD5);

3503

assert(MEMCACHED_HASH_CRC == MEMCACHED_HASH_CRC);

3504

assert(MEMCACHED_HASH_FNV1_64 == MEMCACHED_HASH_FNV1_64);

3505

assert(MEMCACHED_HASH_FNV1A_64 == MEMCACHED_HASH_FNV1A_64);

3506

assert(MEMCACHED_HASH_FNV1_32 == MEMCACHED_HASH_FNV1_32);

3507

assert(MEMCACHED_HASH_FNV1A_32 == MEMCACHED_HASH_FNV1A_32);

3508

#ifdef HAVE_HSIEH_HASH

3509

assert(MEMCACHED_HASH_HSIEH == MEMCACHED_HASH_HSIEH);

3510

#endif

3511

assert(MEMCACHED_HASH_MURMUR == MEMCACHED_HASH_MURMUR);

3512

assert(MEMCACHED_HASH_JENKINS == MEMCACHED_HASH_JENKINS);

3513

assert(MEMCACHED_HASH_MAX == MEMCACHED_HASH_MAX);

3514

3515

return TEST_SUCCESS;

3516

}

3517

#endif

3518

3519

test_return_t hsieh_avaibility_test (memcached_st *memc)

3520

{

3521

test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_HSIEH));

3522

3523

test_compare(MEMCACHED_SUCCESS,

3524

memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH,

3525

(uint64_t)MEMCACHED_HASH_HSIEH));

3526

3527

return TEST_SUCCESS;

3528

}

3529

3530

test_return_t murmur_avaibility_test (memcached_st *memc)

3531

{

3532

test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_MURMUR));

3533

3534

test_compare(MEMCACHED_SUCCESS,

3535

memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_MURMUR));

3536

3537

return TEST_SUCCESS;

3538

}

3539

3540

test_return_t one_at_a_time_run (memcached_st *)

3541

{

3542

uint32_t x;

3543

const char **ptr;

3544

3545

for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)

3546

{

3547

test_compare(one_at_a_time_values[x],

3548

memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_DEFAULT));

3549

}

3550

3551

return TEST_SUCCESS;

3552

}

3553

3554

test_return_t md5_run (memcached_st *)

3555

{

3556

uint32_t x;

3557

const char **ptr;

3558

3559

for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)

3560

{

3561

test_compare(md5_values[x],

3562

memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_MD5));

3563

}

3564

3565

return TEST_SUCCESS;

3566

}

3567

3568

test_return_t crc_run (memcached_st *)

3569

{

3570

uint32_t x;

3571

const char **ptr;

3572

3573

for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)

3574

{

3575

test_compare(crc_values[x],

3576

memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_CRC));

3577

}

3578

3579

return TEST_SUCCESS;

3580

}

3581

3582

test_return_t fnv1_64_run (memcached_st *)

3583

{

3584

test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_FNV1_64));

3585

3586

uint32_t x;

3587

const char **ptr;

3588

3589

for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)

3590

{

3591

test_compare(fnv1_64_values[x],

3592

memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_FNV1_64));

3593

}

3594

3595

return TEST_SUCCESS;

3596

}

3597

3598

test_return_t fnv1a_64_run (memcached_st *)

3599

{

3600

test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_FNV1A_64));

3601

3602

uint32_t x;

3603

const char **ptr;

3604

3605

for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)

3606

{

3607

test_compare(fnv1a_64_values[x],

3608

memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_FNV1A_64));

3609

}

3610

3611

return TEST_SUCCESS;

3612

}

3613

3614

test_return_t fnv1_32_run (memcached_st *)

3615

{

3616

uint32_t x;

3617

const char **ptr;

3618

3619

for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)

3620

{

3621

test_compare(fnv1_32_values[x],

3622

memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_FNV1_32));

3623

}

3624

3625

return TEST_SUCCESS;

3626

}

3627

3628

test_return_t fnv1a_32_run (memcached_st *)

3629

{

3630

uint32_t x;

3631

const char **ptr;

3632

3633

for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)

3634

{

3635

test_compare(fnv1a_32_values[x],

3636

memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_FNV1A_32));

3637

}

3638

3639

return TEST_SUCCESS;

3640

}

3641

3642

test_return_t hsieh_run (memcached_st *)

3643

{

3644

test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_HSIEH));

3645

3646

uint32_t x;

3647

const char **ptr;

3648

3649

for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)

3650

{

3651

test_compare(hsieh_values[x],

3652

memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_HSIEH));

3653

}

3654

3655

return TEST_SUCCESS;

3656

}

3657

3658

test_return_t murmur_run (memcached_st *)

3659

{

3660

test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_MURMUR));

3661

3662

#ifdef WORDS_BIGENDIAN

3663

(void)murmur_values;

3664

return TEST_SKIPPED;

3665

#else

3666

uint32_t x;

3667

const char **ptr;

3668

3669

for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)

3670

{

3671

test_compare(murmur_values[x],

3672

memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_MURMUR));

3673

}

3674

3675

return TEST_SUCCESS;

3676

#endif

3677

}

3678

3679

test_return_t jenkins_run (memcached_st *)

3680

{

3681

uint32_t x;

3682

const char **ptr;

3683

3684

for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)

3685

{

3686

test_compare(jenkins_values[x],

3687

memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_JENKINS));

3688

}

3689

3690

return TEST_SUCCESS;

3691

}

3692

3693

static uint32_t hash_md5_test_function(const char *string, size_t string_length, void *)

3694

{

3695

return libhashkit_md5(string, string_length);

3696

}

3697

3698

static uint32_t hash_crc_test_function(const char *string, size_t string_length, void *)

3699

{

3700

return libhashkit_crc32(string, string_length);

3701

}

3702

3703

test_return_t memcached_get_hashkit_test (memcached_st *)

3704

{

3705

uint32_t x;

3706

const char **ptr;

3707

hashkit_st new_kit;

3708

3709

memcached_st *memc= memcached(test_literal_param("--server=localhost:1 --server=localhost:2 --server=localhost:3 --server=localhost:4 --server=localhost5 --DISTRIBUTION=modula"));

3710

3711

uint32_t md5_hosts[]= {4U, 1U, 0U, 1U, 4U, 2U, 0U, 3U, 0U, 0U, 3U, 1U, 0U, 0U, 1U, 3U, 0U, 0U, 0U, 3U, 1U, 0U, 4U, 4U, 3U};

3712

uint32_t crc_hosts[]= {2U, 4U, 1U, 0U, 2U, 4U, 4U, 4U, 1U, 2U, 3U, 4U, 3U, 4U, 1U, 3U, 3U, 2U, 0U, 0U, 0U, 1U, 2U, 4U, 0U};

3713

3714

const hashkit_st *kit= memcached_get_hashkit(memc);

3715

3716

hashkit_clone(&new_kit, kit);

3717

test_compare(HASHKIT_SUCCESS, hashkit_set_custom_function(&new_kit, hash_md5_test_function, NULL));

3718

3719

memcached_set_hashkit(memc, &new_kit);

3720

3721

3722

Verify Setting the hash.

3723

3724

for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)

3725

{

3726

uint32_t hash_val;

3727

3728

hash_val= hashkit_digest(kit, *ptr, strlen(*ptr));

3729

test_compare_got(md5_values[x], hash_val, *ptr);

3730

}

3731

3732

3733

3734

Now check memcached_st.

3735

3736

for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)

3737

{

3738

uint32_t hash_val;

3739

3740

hash_val= memcached_generate_hash(memc, *ptr, strlen(*ptr));

3741

test_compare_got(md5_hosts[x], hash_val, *ptr);

3742

}

3743

3744

test_compare(HASHKIT_SUCCESS, hashkit_set_custom_function(&new_kit, hash_crc_test_function, NULL));

3745

3746

memcached_set_hashkit(memc, &new_kit);

3747

3748

3749

Verify Setting the hash.

3750

3751

for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)

3752

{

3753

uint32_t hash_val;

3754

3755

hash_val= hashkit_digest(kit, *ptr, strlen(*ptr));

3756

test_true(crc_values[x] == hash_val);

3757

}

3758

3759

for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)

3760

{

3761

uint32_t hash_val;

3762

3763

hash_val= memcached_generate_hash(memc, *ptr, strlen(*ptr));

3764

test_compare(crc_hosts[x], hash_val);

3765

}

3766

3767

memcached_free(memc);

3768

3769

return TEST_SUCCESS;

3770

}

3771

3772

3773

Test case adapted from John Gorman <johngorman2@gmail.com>

3774

3775

We are testing the error condition when we connect to a server via memcached_get()

3776

but find that the server is not available.

3777

3778

test_return_t memcached_get_MEMCACHED_ERRNO(memcached_st *)

3779

{

3780

size_t len;

3781

uint32_t flags;

3782

memcached_return rc;

3783

3784

// Create a handle.

3785

memcached_st *tl_memc_h= memcached(test_literal_param("--server=localhost:9898 --server=localhost:9899")); // This server should not exist

3786

3787

// See if memcached is reachable.

3788

char *value= memcached_get(tl_memc_h,

3789

test_literal_param(__func__),

3790

&len, &flags, &rc);

3791

3792

test_false(value);

3793

test_zero(len);

3794

test_true(memcached_failed(rc));

3795

3796

memcached_free(tl_memc_h);

3797

3798

return TEST_SUCCESS;

3799

}

3800

3801

3802

We connect to a server which exists, but search for a key that does not exist.

3803

3804

test_return_t memcached_get_MEMCACHED_NOTFOUND(memcached_st *memc)

3805

{

3806

size_t len;

3807

uint32_t flags;

3808

memcached_return rc;

3809

3810

// See if memcached is reachable.

3811

char *value= memcached_get(memc,

3812

test_literal_param(__func__),

3813

&len, &flags, &rc);

3814

3815

test_false(value);

3816

test_zero(len);

3817

test_compare(MEMCACHED_NOTFOUND, rc);

3818

3819

return TEST_SUCCESS;

3820

}

3821

3822

3823

Test case adapted from John Gorman <johngorman2@gmail.com>

3824

3825

We are testing the error condition when we connect to a server via memcached_get_by_key()

3826

but find that the server is not available.

3827

3828

test_return_t memcached_get_by_key_MEMCACHED_ERRNO(memcached_st *)

3829

{

3830

size_t len;

3831

uint32_t flags;

3832

memcached_return rc;

3833

3834

// Create a handle.

3835

memcached_st *tl_memc_h= memcached_create(NULL);

3836

memcached_server_st *servers= memcached_servers_parse("localhost:9898,localhost:9899"); // This server should not exist

3837

memcached_server_push(tl_memc_h, servers);

3838

memcached_server_list_free(servers);

3839

3840

// See if memcached is reachable.

3841

char *value= memcached_get_by_key(tl_memc_h,

3842

test_literal_param(__func__), // Key

3843

test_literal_param(__func__), // Value

3844

&len, &flags, &rc);

3845

3846

test_false(value);

3847

test_zero(len);

3848

test_true(memcached_failed(rc));

3849

3850

memcached_free(tl_memc_h);

3851

3852

return TEST_SUCCESS;

3853

}

3854

3855

3856

We connect to a server which exists, but search for a key that does not exist.

3857

3858

test_return_t memcached_get_by_key_MEMCACHED_NOTFOUND(memcached_st *memc)

3859

{

3860

size_t len;

3861

uint32_t flags;

3862

memcached_return rc;

3863

3864

// See if memcached is reachable.

3865

char *value= memcached_get_by_key(memc,

3866

test_literal_param(__func__), // Key

3867

test_literal_param(__func__), // Value

3868

&len, &flags, &rc);

3869

3870

test_false(value);

3871

test_zero(len);

3872

test_compare(MEMCACHED_NOTFOUND, rc);

3873

3874

return TEST_SUCCESS;

3875

}

3876

3877

test_return_t regression_bug_434484(memcached_st *memc)

3878

{

3879

test_skip(TEST_SUCCESS, pre_binary(memc));

3880

3881

test_compare(MEMCACHED_NOTSTORED,

3882

memcached_append(memc,

3883

test_literal_param(__func__), // Key

3884

test_literal_param(__func__), // Value

3885

0, 0));

3886

3887

libtest::vchar_t data;

3888

data.resize(2048 * 1024);

3889

test_compare(MEMCACHED_E2BIG,

3890

memcached_set(memc,

3891

test_literal_param(__func__), // Key

3892

&data[0], data.size(), 0, 0));

3893

3894

return TEST_SUCCESS;

3895

}

3896

3897

test_return_t regression_bug_434843(memcached_st *original_memc)

3898

{

3899

test_skip(TEST_SUCCESS, pre_binary(original_memc));

3900

3901

memcached_return_t rc;

3902

size_t counter= 0;

3903

memcached_execute_fn callbacks[]= { &callback_counter };

3904

3905

3906

* I only want to hit only _one_ server so I know the number of requests I'm

3907

* sending in the pipleine to the server. Let's try to do a multiget of

3908

* 1024 (that should satisfy most users don't you think?). Future versions

3909

* will include a mget_execute function call if you need a higher number.

3910

3911

memcached_st *memc= create_single_instance_memcached(original_memc, "--BINARY-PROTOCOL");

3912

3913

keys_st keys(1024);

3914

3915

3916

* Run two times.. the first time we should have 100% cache miss,

3917

* and the second time we should have 100% cache hits

3918

3919

for (ptrdiff_t y= 0; y < 2; y++)

3920

{

3921

test_compare(MEMCACHED_SUCCESS,

3922

memcached_mget(memc, keys.keys_ptr(), keys.lengths_ptr(), keys.size()));

3923

3924

// One the first run we should get a NOT_FOUND, but on the second some data

3925

// should be returned.

3926

test_compare(y ? MEMCACHED_SUCCESS : MEMCACHED_NOTFOUND,

3927

memcached_fetch_execute(memc, callbacks, (void *)&counter, 1));

3928

3929

if (y == 0)

3930

{

3931

/* The first iteration should give me a 100% cache miss. verify that*/

3932

char blob[1024]= { 0 };

3933

3934

test_false(counter);

3935

3936

for (size_t x= 0; x < keys.size(); ++x)

3937

{

3938

rc= memcached_add(memc,

3939

keys.key_at(x), keys.length_at(x),

3940

blob, sizeof(blob), 0, 0);

3941

test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);

3942

}

3943

}

3944

else

3945

{

3946

/* Verify that we received all of the key/value pairs */

3947

test_compare(counter, keys.size());

3948

}

3949

}

3950

3951

memcached_free(memc);

3952

3953

return TEST_SUCCESS;

3954

}

3955

3956

test_return_t regression_bug_434843_buffered(memcached_st *memc)

3957

{

3958

test_compare(MEMCACHED_SUCCESS, memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, true));

3959

3960

return regression_bug_434843(memc);

3961

}

3962

3963

test_return_t regression_bug_421108(memcached_st *memc)

3964

{

3965

memcached_return_t rc;

3966

memcached_stat_st *memc_stat= memcached_stat(memc, NULL, &rc);

3967

test_compare(MEMCACHED_SUCCESS, rc);

3968

3969

char *bytes_str= memcached_stat_get_value(memc, memc_stat, "bytes", &rc);

3970

test_compare(MEMCACHED_SUCCESS, rc);

3971

test_true(bytes_str);

3972

char *bytes_read_str= memcached_stat_get_value(memc, memc_stat,

3973

"bytes_read", &rc);

3974

test_compare(MEMCACHED_SUCCESS, rc);

3975

test_true(bytes_read_str);

3976

3977

char *bytes_written_str= memcached_stat_get_value(memc, memc_stat,

3978

"bytes_written", &rc);

3979

test_compare(MEMCACHED_SUCCESS, rc);

3980

test_true(bytes_written_str);

3981

3982

unsigned long long bytes= strtoull(bytes_str, 0, 10);

3983

unsigned long long bytes_read= strtoull(bytes_read_str, 0, 10);

3984

unsigned long long bytes_written= strtoull(bytes_written_str, 0, 10);

3985

3986

test_true(bytes != bytes_read);

3987

test_true(bytes != bytes_written);

3988

3989

/* Release allocated resources */

3990

free(bytes_str);

3991

free(bytes_read_str);

3992

free(bytes_written_str);

3993

memcached_stat_free(NULL, memc_stat);

3994

3995

return TEST_SUCCESS;

3996

}

3997

3998

3999

* The test case isn't obvious so I should probably document why

4000

* it works the way it does. Bug 442914 was caused by a bug

4001

* in the logic in memcached_purge (it did not handle the case

4002

* where the number of bytes sent was equal to the watermark).

4003

* In this test case, create messages so that we hit that case

4004

* and then disable noreply mode and issue a new command to

4005

* verify that it isn't stuck. If we change the format for the

4006

* delete command or the watermarks, we need to update this

4007

* test....

4008

4009

test_return_t regression_bug_442914(memcached_st *original_memc)

4010

{

4011

test_skip(original_memc->servers[0].type, MEMCACHED_CONNECTION_TCP);

4012

4013

memcached_st* memc= create_single_instance_memcached(original_memc, "--NOREPLY --TCP-NODELAY");

4014

4015

for (uint32_t x= 0; x < 250; ++x)

4016

{

4017

char key[250];

4018

size_t len= (size_t)snprintf(key, sizeof(key), "%0250u", x);

4019

memcached_return_t rc= memcached_delete(memc, key, len, 0);

4020

char error_buffer[2048]= { 0 };

4021

snprintf(error_buffer, sizeof(error_buffer), "%s key: %s", memcached_last_error_message(memc), key);

4022

test_true_got(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED, error_buffer);

4023

}

4024

4025

// Delete, and then delete again to look for not found

4026

{

4027

char key[250];

4028

size_t len= snprintf(key, sizeof(key), "%037u", 251U);

4029

memcached_return_t rc= memcached_delete(memc, key, len, 0);

4030

test_true(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED);

4031

4032

test_compare(MEMCACHED_SUCCESS, memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NOREPLY, false));

4033

test_compare(MEMCACHED_NOTFOUND, memcached_delete(memc, key, len, 0));

4034

}

4035

4036

memcached_free(memc);

4037

4038

return TEST_SUCCESS;

4039

}

4040

4041

test_return_t regression_bug_447342(memcached_st *memc)

4042

{

4043

if (memcached_server_count(memc) < 3 or pre_replication(memc) != TEST_SUCCESS)

4044

{

4045

return TEST_SKIPPED;

4046

}

4047

4048

test_compare(MEMCACHED_SUCCESS,

4049

memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS, 2));

4050

4051

keys_st keys(100);

4052

4053

for (size_t x= 0; x < keys.size(); ++x)

4054

{

4055

test_compare(MEMCACHED_SUCCESS,

4056

memcached_set(memc,

4057

keys.key_at(x), keys.length_at(x), // Keys

4058

keys.key_at(x), keys.length_at(x), // Values

4059

0, 0));

4060

}

4061

4062

4063

** We are using the quiet commands to store the replicas, so we need

4064

** to ensure that all of them are processed before we can continue.

4065

** In the test we go directly from storing the object to trying to

4066

** receive the object from all of the different servers, so we

4067

** could end up in a race condition (the memcached server hasn't yet

4068

** processed the quiet command from the replication set when it process

4069

** the request from the other client (created by the clone)). As a

4070

** workaround for that we call memcached_quit to send the quit command

4071

** to the server and wait for the response ;-) If you use the test code

4072

** as an example for your own code, please note that you shouldn't need

4073

** to do this ;-)

4074

4075

memcached_quit(memc);

4076

4077

/* Verify that all messages are stored, and we didn't stuff too much

4078

* into the servers

4079

4080

test_compare(MEMCACHED_SUCCESS,

4081

memcached_mget(memc,

4082

keys.keys_ptr(), keys.lengths_ptr(), keys.size()));

4083

4084

unsigned int counter= 0;

4085

memcached_execute_fn callbacks[]= { &callback_counter };

4086

test_compare(MEMCACHED_SUCCESS,

4087

memcached_fetch_execute(memc, callbacks, (void *)&counter, 1));

4088

4089

/* Verify that we received all of the key/value pairs */

4090

test_compare(counter, keys.size());

4091

4092

memcached_quit(memc);

4093

4094

* Don't do the following in your code. I am abusing the internal details

4095

* within the library, and this is not a supported interface.

4096

* This is to verify correct behavior in the library. Fake that two servers

4097

* are dead..

4098

4099

memcached_server_instance_st instance_one= memcached_server_instance_by_position(memc, 0);

4100

memcached_server_instance_st instance_two= memcached_server_instance_by_position(memc, 2);

4101

in_port_t port0= instance_one->port;

4102

in_port_t port2= instance_two->port;

4103

4104

((memcached_server_write_instance_st)instance_one)->port= 0;

4105

((memcached_server_write_instance_st)instance_two)->port= 0;

4106

4107

test_compare(MEMCACHED_SUCCESS,

4108

memcached_mget(memc,

4109

keys.keys_ptr(), keys.lengths_ptr(), keys.size()));

4110

4111

counter= 0;

4112

test_compare(MEMCACHED_SUCCESS,

4113

memcached_fetch_execute(memc, callbacks, (void *)&counter, 1));

4114

test_compare(counter, keys.size());

4115

4116

/* restore the memc handle */

4117

((memcached_server_write_instance_st)instance_one)->port= port0;

4118

((memcached_server_write_instance_st)instance_two)->port= port2;

4119

4120

memcached_quit(memc);

4121

4122

/* Remove half of the objects */

4123

for (size_t x= 0; x < keys.size(); ++x)

4124

{

4125

if (x & 1)

4126

{

4127

test_compare(MEMCACHED_SUCCESS,

4128

memcached_delete(memc, keys.key_at(x), keys.length_at(x), 0));

4129

}

4130

}

4131

4132

memcached_quit(memc);

4133

((memcached_server_write_instance_st)instance_one)->port= 0;

4134

((memcached_server_write_instance_st)instance_two)->port= 0;

4135

4136

/* now retry the command, this time we should have cache misses */

4137

test_compare(MEMCACHED_SUCCESS,

4138

memcached_mget(memc,

4139

keys.keys_ptr(), keys.lengths_ptr(), keys.size()));

4140

4141

counter= 0;

4142

test_compare(MEMCACHED_SUCCESS,

4143

memcached_fetch_execute(memc, callbacks, (void *)&counter, 1));

4144

test_compare(counter, (unsigned int)(keys.size() >> 1));

4145

4146

/* restore the memc handle */

4147

((memcached_server_write_instance_st)instance_one)->port= port0;

4148

((memcached_server_write_instance_st)instance_two)->port= port2;

4149

4150

return TEST_SUCCESS;

4151

}

4152

4153

test_return_t regression_bug_463297(memcached_st *memc)

4154

{

4155

test_compare(MEMCACHED_INVALID_ARGUMENTS, memcached_delete(memc, "foo", 3, 1));

4156

4157

// Since we blocked timed delete, this test is no longer valid.

4158

#if 0

4159

memcached_st *memc_clone= memcached_clone(NULL, memc);

4160

test_true(memc_clone);

4161

test_true(memcached_version(memc_clone) == MEMCACHED_SUCCESS);

4162

4163

memcached_server_instance_st instance=

4164

memcached_server_instance_by_position(memc_clone, 0);

4165

4166

if (instance->major_version > 1 ||

4167

(instance->major_version == 1 &&

4168

instance->minor_version > 2))

4169

{

4170

/* Binary protocol doesn't support deferred delete */

4171

memcached_st *bin_clone= memcached_clone(NULL, memc);

4172

test_true(bin_clone);

4173

test_compare(MEMCACHED_SUCCESS, memcached_behavior_set(bin_clone, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 1));

4174

test_compare(MEMCACHED_INVALID_ARGUMENTS, memcached_delete(bin_clone, "foo", 3, 1));

4175

memcached_free(bin_clone);

4176

4177

memcached_quit(memc_clone);

4178

4179

/* If we know the server version, deferred delete should fail

4180

* with invalid arguments */

4181

test_compare(MEMCACHED_INVALID_ARGUMENTS, memcached_delete(memc_clone, "foo", 3, 1));

4182

4183

/* If we don't know the server version, we should get a protocol error */

4184

memcached_return_t rc= memcached_delete(memc, "foo", 3, 1);

4185

4186

/* but there is a bug in some of the memcached servers (1.4) that treats

4187

* the counter as noreply so it doesn't send the proper error message

4188

4189

test_true_got(rc == MEMCACHED_PROTOCOL_ERROR || rc == MEMCACHED_NOTFOUND || rc == MEMCACHED_CLIENT_ERROR || rc == MEMCACHED_INVALID_ARGUMENTS, memcached_strerror(NULL, rc));

4190

4191

/* And buffered mode should be disabled and we should get protocol error */

4192

test_true(memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, 1) == MEMCACHED_SUCCESS);

4193

rc= memcached_delete(memc, "foo", 3, 1);

4194

test_true_got(rc == MEMCACHED_PROTOCOL_ERROR || rc == MEMCACHED_NOTFOUND || rc == MEMCACHED_CLIENT_ERROR || rc == MEMCACHED_INVALID_ARGUMENTS, memcached_strerror(NULL, rc));

4195

4196

/* Same goes for noreply... */

4197

test_compare(MEMCACHED_SUCCESS, memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NOREPLY, 1));

4198

rc= memcached_delete(memc, "foo", 3, 1);

4199

test_true_got(rc == MEMCACHED_PROTOCOL_ERROR || rc == MEMCACHED_NOTFOUND || rc == MEMCACHED_CLIENT_ERROR || rc == MEMCACHED_INVALID_ARGUMENTS, memcached_strerror(NULL, rc));

4200

4201

/* but a normal request should go through (and be buffered) */

4202

test_compare(MEMCACHED_BUFFERED, (rc= memcached_delete(memc, "foo", 3, 0)));

4203

test_compare(MEMCACHED_SUCCESS, memcached_flush_buffers(memc));

4204

4205

test_compare(MEMCACHED_SUCCESS, memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, 0));

4206

/* unbuffered noreply should be success */

4207

test_compare(MEMCACHED_SUCCESS, memcached_delete(memc, "foo", 3, 0));

4208

/* unbuffered with reply should be not found... */

4209

test_compare(MEMCACHED_SUCCESS, memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NOREPLY, 0));

4210

test_compare(MEMCACHED_NOTFOUND, memcached_delete(memc, "foo", 3, 0));

4211

}

4212

4213

memcached_free(memc_clone);

4214

#endif

4215

4216

return TEST_SUCCESS;

4217

}

4218

4219

4220

/* Test memcached_server_get_last_disconnect

4221

* For a working server set, shall be NULL

4222

* For a set of non existing server, shall not be NULL

4223

4224

test_return_t test_get_last_disconnect(memcached_st *memc)

4225

{

4226

memcached_return_t rc;

4227

memcached_server_instance_st disconnected_server;

4228

4229

/* With the working set of server */

4230

const char *key= "marmotte";

4231

const char *value= "milka";

4232

4233

memcached_reset_last_disconnected_server(memc);

4234

test_false(memc->last_disconnected_server);

4235

rc= memcached_set(memc, key, strlen(key),

4236

value, strlen(value),

4237

(time_t)0, (uint32_t)0);

4238

test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);

4239

4240

disconnected_server = memcached_server_get_last_disconnect(memc);

4241

test_false(disconnected_server);

4242

4243

/* With a non existing server */

4244

memcached_st *mine;

4245

memcached_server_st *servers;

4246

4247

const char *server_list= "localhost:9";

4248

4249

servers= memcached_servers_parse(server_list);

4250

test_true(servers);

4251

mine= memcached_create(NULL);

4252

rc= memcached_server_push(mine, servers);

4253

test_compare(MEMCACHED_SUCCESS, rc);

4254

memcached_server_list_free(servers);

4255

test_true(mine);

4256

4257

rc= memcached_set(mine, key, strlen(key),

4258

value, strlen(value),

4259

(time_t)0, (uint32_t)0);

4260

test_true(memcached_failed(rc));

4261

4262

disconnected_server= memcached_server_get_last_disconnect(mine);

4263

test_true_got(disconnected_server, memcached_strerror(mine, rc));

4264

test_compare(in_port_t(9), memcached_server_port(disconnected_server));

4265

test_false(strncmp(memcached_server_name(disconnected_server),"localhost",9));

4266

4267

memcached_quit(mine);

4268

memcached_free(mine);

4269

4270

return TEST_SUCCESS;

4271

}

4272

4273

test_return_t test_multiple_get_last_disconnect(memcached_st *)

4274

{

4275

const char *server_string= "--server=localhost:8888 --server=localhost:8889 --server=localhost:8890 --server=localhost:8891 --server=localhost:8892";

4276

char buffer[BUFSIZ];

4277

4278

test_compare(MEMCACHED_SUCCESS,

4279

libmemcached_check_configuration(server_string, strlen(server_string), buffer, sizeof(buffer)));

4280

4281

memcached_st *memc= memcached(server_string, strlen(server_string));

4282

test_true(memc);

4283

4284

// We will just use the error strings as our keys

4285

uint32_t counter= 100;

4286

while (--counter)

4287

{

4288

for (int x= int(MEMCACHED_SUCCESS); x < int(MEMCACHED_MAXIMUM_RETURN); ++x)

4289

{

4290

const char *msg= memcached_strerror(memc, memcached_return_t(x));

4291

memcached_return_t ret= memcached_set(memc, msg, strlen(msg), NULL, 0, (time_t)0, (uint32_t)0);

4292

test_true_got((ret == MEMCACHED_CONNECTION_FAILURE or ret == MEMCACHED_SERVER_TEMPORARILY_DISABLED), memcached_last_error_message(memc));

4293

4294

memcached_server_instance_st disconnected_server= memcached_server_get_last_disconnect(memc);

4295

test_true(disconnected_server);

4296

test_strcmp("localhost", memcached_server_name(disconnected_server));

4297

test_true(memcached_server_port(disconnected_server) >= 8888 and memcached_server_port(disconnected_server) <= 8892);

4298

4299

if (random() % 2)

4300

{

4301

memcached_reset_last_disconnected_server(memc);

4302

}

4303

}

4304

}

4305

4306

memcached_free(memc);

4307

4308

return TEST_SUCCESS;

4309

}

4310

4311

test_return_t test_verbosity(memcached_st *memc)

4312

{

4313

memcached_verbosity(memc, 3);

4314

4315

return TEST_SUCCESS;

4316

}

4317

4318

4319

static memcached_return_t stat_printer(memcached_server_instance_st server,

4320

const char *key, size_t key_length,

4321

const char *value, size_t value_length,

4322

void *context)

4323

{

4324

(void)server;

4325

(void)context;

4326

(void)key;

4327

(void)key_length;

4328

(void)value;

4329

(void)value_length;

2620

4330

2621

4331

return MEMCACHED_SUCCESS;

2622

4332

}

2623

4333

2624

2625

/* Clean the server before beginning testing */

2626

test_st tests[] ={

2627

{"flush", 0, flush_test },

2628

{"init", 0, init_test },

2629

{"allocation", 0, allocation_test },

2630

{"server_list_null_test", 0, server_list_null_test},

2631

{"server_unsort", 0, server_unsort_test},

2632

{"server_sort", 0, server_sort_test},

2633

{"clone_test", 0, clone_test },

2634

{"error", 0, error_test },

2635

{"set", 0, set_test },

2636

{"set2", 0, set_test2 },

2637

{"set3", 0, set_test3 },

2638

{"add", 1, add_test },

2639

{"replace", 1, replace_test },

2640

{"delete", 1, delete_test },

2641

{"get", 1, get_test },

2642

{"get2", 0, get_test2 },

2643

{"get3", 0, get_test3 },

2644

{"get4", 0, get_test4 },

2645

{"stats_servername", 0, stats_servername_test },

2646

{"increment", 0, increment_test },

2647

{"decrement", 0, decrement_test },

2648

{"quit", 0, quit_test },

2649

{"mget", 1, mget_test },

2650

{"mget_result", 1, mget_result_test },

2651

{"mget_result_alloc", 1, mget_result_alloc_test },

2652

{"mget_result_function", 1, mget_result_function },

2653

{"get_stats", 0, get_stats },

2654

{"add_host_test", 0, add_host_test },

2655

{"get_stats_keys", 0, get_stats_keys },

2656

{"behavior_test", 0, get_stats_keys },

2657

{"callback_test", 0, get_stats_keys },

2658

{"version_string_test", 0, version_string_test},

2659

{"bad_key", 1, bad_key_test },

2660

{"memcached_server_cursor", 1, memcached_server_cursor_test },

2661

{"read_through", 1, read_through },

2662

{"delete_through", 1, delete_through },

2663

{0, 0, 0}

2664

};

2665

2666

test_st async_tests[] ={

2667

{"add", 1, add_wrapper },

2668

{0, 0, 0}

2669

};

2670

2671

test_st string_tests[] ={

2672

{"string static with null", 0, string_static_null },

2673

{"string alloc with null", 0, string_alloc_null },

2674

{"string alloc with 1K", 0, string_alloc_with_size },

2675

{"string alloc with malloc failure", 0, string_alloc_with_size_toobig },

2676

{"string append", 0, string_alloc_append },

2677

{"string append failure (too big)", 0, string_alloc_append_toobig },

2678

{0, 0, 0}

2679

};

2680

2681

test_st result_tests[] ={

2682

{"result static", 0, result_static},

2683

{"result alloc", 0, result_alloc},

2684

{0, 0, 0}

2685

};

2686

2687

test_st version_1_2_3[] ={

2688

{"append", 0, append_test },

2689

{"prepend", 0, prepend_test },

2690

{"cas", 0, cas_test },

2691

{"cas2", 0, cas2_test },

2692

{"append_binary", 0, append_binary_test },

2693

{0, 0, 0}

2694

};

2695

2696

test_st user_tests[] ={

2697

{"user_supplied_bug1", 0, user_supplied_bug1 },

2698

{"user_supplied_bug2", 0, user_supplied_bug2 },

2699

{"user_supplied_bug3", 0, user_supplied_bug3 },

2700

{"user_supplied_bug4", 0, user_supplied_bug4 },

2701

{"user_supplied_bug5", 1, user_supplied_bug5 },

2702

{"user_supplied_bug6", 1, user_supplied_bug6 },

2703

{"user_supplied_bug7", 1, user_supplied_bug7 },

2704

{"user_supplied_bug8", 1, user_supplied_bug8 },

2705

{"user_supplied_bug9", 1, user_supplied_bug9 },

2706

{"user_supplied_bug10", 1, user_supplied_bug10 },

2707

{"user_supplied_bug11", 1, user_supplied_bug11 },

2708

{"user_supplied_bug12", 1, user_supplied_bug12 },

2709

{"user_supplied_bug13", 1, user_supplied_bug13 },

2710

{"user_supplied_bug14", 1, user_supplied_bug14 },

2711

{"user_supplied_bug15", 1, user_supplied_bug15 },

2712

{0, 0, 0}

2713

};

2714

2715

test_st generate_tests[] ={

2716

{"generate_pairs", 1, generate_pairs },

2717

{"generate_data", 1, generate_data },

2718

{"get_read", 0, get_read },

2719

{"delete_generate", 0, delete_generate },

2720

{"generate_buffer_data", 1, generate_buffer_data },

2721

{"delete_buffer", 0, delete_buffer_generate},

2722

{"generate_data", 1, generate_data },

2723

{"mget_read", 0, mget_read },

2724

{"mget_read_result", 0, mget_read_result },

2725

{"mget_read_function", 0, mget_read_function },

2726

{"cleanup", 1, cleanup_pairs },

2727

{"generate_large_pairs", 1, generate_large_pairs },

2728

{"generate_data", 1, generate_data },

2729

{"generate_buffer_data", 1, generate_buffer_data },

2730

{"cleanup", 1, cleanup_pairs },

2731

{0, 0, 0}

2732

};

2733

2734

test_st consistent_tests[] ={

2735

{"generate_pairs", 1, generate_pairs },

2736

{"generate_data", 1, generate_data },

2737

{"get_read", 0, get_read_count },

2738

{"cleanup", 1, cleanup_pairs },

2739

{0, 0, 0}

2740

};

2741

2742

collection_st collection[] ={

2743

{"block", 0, 0, tests},

2744

{"nonblock", pre_nonblock, 0, tests},

2745

{"nodelay", pre_nodelay, 0, tests},

2746

{"md5", pre_md5, 0, tests},

2747

{"crc", pre_crc, 0, tests},

2748

{"hsieh", pre_hsieh, 0, tests},

2749

{"fnv1_64", pre_hash_fnv1_64, 0, tests},

2750

{"fnv1a_64", pre_hash_fnv1a_64, 0, tests},

2751

{"fnv1_32", pre_hash_fnv1_32, 0, tests},

2752

{"fnv1a_32", pre_hash_fnv1a_32, 0, tests},

2753

{"ketama", pre_behavior_ketama, 0, tests},

2754

{"unix_socket", pre_unix_socket, 0, tests},

2755

{"unix_socket_nodelay", pre_nodelay, 0, tests},

2756

{"poll_timeout", poll_timeout, 0, tests},

2757

{"gets", enable_cas, 0, tests},

2758

{"consistent", enable_consistent, 0, tests},

2759

{"wheel", enable_wheel, 0, tests},

2760

{"memory_allocators", set_memory_alloc, 0, tests},

2761

// {"udp", pre_udp, 0, tests},

2762

{"version_1_2_3", check_for_1_2_3, 0, version_1_2_3},

2763

{"string", 0, 0, string_tests},

2764

{"result", 0, 0, result_tests},

2765

{"async", pre_nonblock, 0, async_tests},

2766

{"user", 0, 0, user_tests},

2767

{"generate", 0, 0, generate_tests},

2768

{"generate_hsieh", pre_hsieh, 0, generate_tests},

2769

{"generate_ketama", pre_behavior_ketama, 0, generate_tests},

2770

{"generate_hsieh_consistent", enable_consistent, 0, generate_tests},

2771

{"generate_md5", pre_md5, 0, generate_tests},

2772

{"generate_murmur", pre_murmur, 0, generate_tests},

2773

{"generate_nonblock", pre_nonblock, 0, generate_tests},

2774

{"consistent_not", 0, 0, consistent_tests},

2775

{"consistent_ketama", pre_behavior_ketama, 0, consistent_tests},

2776

{"consistent_wheel", enable_wheel, 0, consistent_tests},

2777

{0, 0, 0, 0}

2778

};

2779

2780

#define SERVERS_TO_CREATE 5

2781

2782

void *world_create(void)

2783

{

2784

server_startup_st *construct;

2785

2786

construct= (server_startup_st *)malloc(sizeof(server_startup_st));

2787

memset(construct, 0, sizeof(server_startup_st));

2788

construct->count= SERVERS_TO_CREATE;

2789

construct->udp= 0;

2790

server_startup(construct);

2791

2792

return construct;

2793

}

2794

2795

void world_destroy(void *p)

2796

{

2797

server_startup_st *construct= (server_startup_st *)p;

2798

memcached_server_st *servers= (memcached_server_st *)construct->servers;

2799

memcached_server_list_free(servers);

2800

2801

server_shutdown(construct);

2802

free(construct);

2803

}

2804

2805

void get_world(world_st *world)

2806

{

2807

world->collections= collection;

2808

world->create= world_create;

2809

world->destroy= world_destroy;

4334

test_return_t memcached_stat_execute_test(memcached_st *memc)

4335

{

4336

memcached_return_t rc= memcached_stat_execute(memc, NULL, stat_printer, NULL);

4337

test_compare(MEMCACHED_SUCCESS, rc);

4338

4339

test_compare(MEMCACHED_SUCCESS,

4340

memcached_stat_execute(memc, "slabs", stat_printer, NULL));

4341

4342

test_compare(MEMCACHED_SUCCESS,

4343

memcached_stat_execute(memc, "items", stat_printer, NULL));

4344

4345

test_compare(MEMCACHED_SUCCESS,

4346

memcached_stat_execute(memc, "sizes", stat_printer, NULL));

4347

4348

return TEST_SUCCESS;

4349

}

4350

4351

4352

* This test ensures that the failure counter isn't incremented during

4353

* normal termination of the memcached instance.

4354

4355

test_return_t wrong_failure_counter_test(memcached_st *original_memc)

4356

{

4357

memcached_st* memc= create_single_instance_memcached(original_memc, NULL);

4358

4359

/* Ensure that we are connected to the server by setting a value */

4360

memcached_return_t rc= memcached_set(memc,

4361

test_literal_param(__func__), // Key

4362

test_literal_param(__func__), // Value

4363

time_t(0), uint32_t(0));

4364

test_true(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED);

4365

4366

4367

memcached_server_instance_st instance= memcached_server_instance_by_position(memc, 0);

4368

4369

/* The test is to see that the memcached_quit doesn't increase the

4370

* the server failure conter, so let's ensure that it is zero

4371

* before sending quit

4372

4373

((memcached_server_write_instance_st)instance)->server_failure_counter= 0;

4374

4375

memcached_quit(memc);

4376

4377

/* Verify that it memcached_quit didn't increment the failure counter

4378

* Please note that this isn't bullet proof, because an error could

4379

* occur...

4380

4381

test_zero(instance->server_failure_counter);

4382

4383

memcached_free(memc);

4384

4385

return TEST_SUCCESS;

4386

}

4387

4388

4389

* This tests ensures expected disconnections (for some behavior changes

4390

* for instance) do not wrongly increase failure counter

4391

4392

test_return_t wrong_failure_counter_two_test(memcached_st *memc)

4393

{

4394

/* Set value to force connection to the server */

4395

const char *key= "marmotte";

4396

const char *value= "milka";

4397

4398

test_compare_hint(MEMCACHED_SUCCESS,

4399

memcached_set(memc, key, strlen(key),

4400

value, strlen(value),

4401

(time_t)0, (uint32_t)0),

4402

memcached_last_error_message(memc));

4403

4404

4405

/* put failure limit to 1 */

4406

test_compare(MEMCACHED_SUCCESS,

4407

memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT, true));

4408

4409

/* Put a retry timeout to effectively activate failure_limit effect */

4410

test_compare(MEMCACHED_SUCCESS,

4411

memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT, true));

4412

4413

/* change behavior that triggers memcached_quit()*/

4414

test_compare(MEMCACHED_SUCCESS,

4415

memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, true));

4416

4417

4418

/* Check if we still are connected */

4419

uint32_t flags;

4420

size_t string_length;

4421

memcached_return rc;

4422

char *string= memcached_get(memc, key, strlen(key),

4423

&string_length, &flags, &rc);

4424

4425

test_compare_got(MEMCACHED_SUCCESS, rc, memcached_strerror(NULL, rc));

4426

test_true(string);

4427

free(string);

4428

4429

return TEST_SUCCESS;

4430

}

4431

4432

4433

4434

* Test that ensures mget_execute does not end into recursive calls that finally fails

4435

4436

test_return_t regression_bug_490486(memcached_st *original_memc)

4437

{

4438

4439

#ifdef __APPLE__

4440

return TEST_SKIPPED; // My MAC can't handle this test

4441

#endif

4442

4443

test_skip(TEST_SUCCESS, pre_binary(original_memc));

4444

4445

4446

* I only want to hit _one_ server so I know the number of requests I'm

4447

* sending in the pipeline.

4448

4449

memcached_st *memc= create_single_instance_memcached(original_memc, "--BINARY-PROTOCOL --POLL-TIMEOUT=1000 --REMOVE-FAILED-SERVERS=1 --RETRY-TIMEOUT=3600");

4450

test_true(memc);

4451

4452

keys_st keys(20480);

4453

4454

/* First add all of the items.. */

4455

char blob[1024]= { 0 };

4456

for (size_t x= 0; x < keys.size(); ++x)

4457

{

4458

memcached_return rc= memcached_set(memc,

4459

keys.key_at(x), keys.length_at(x),

4460

blob, sizeof(blob), 0, 0);

4461

test_true(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED); // MEMCACHED_TIMEOUT <-- hash been observed on OSX

4462

}

4463

4464

{

4465

4466

/* Try to get all of them with a large multiget */

4467

size_t counter= 0;

4468

memcached_execute_function callbacks[]= { &callback_counter };

4469

memcached_return_t rc= memcached_mget_execute(memc,

4470

keys.keys_ptr(), keys.lengths_ptr(), keys.size(),

4471

callbacks, &counter, 1);

4472

test_compare(MEMCACHED_SUCCESS, rc);

4473

4474

char* the_value= NULL;

4475

char the_key[MEMCACHED_MAX_KEY];

4476

size_t the_key_length;

4477

size_t the_value_length;

4478

uint32_t the_flags;

4479

4480

do {

4481

the_value= memcached_fetch(memc, the_key, &the_key_length, &the_value_length, &the_flags, &rc);

4482

4483

if ((the_value!= NULL) && (rc == MEMCACHED_SUCCESS))

4484

{

4485

++counter;

4486

free(the_value);

4487

}

4488

4489

} while ( (the_value!= NULL) && (rc == MEMCACHED_SUCCESS));

4490

4491

4492

test_compare(MEMCACHED_END, rc);

4493

4494

/* Verify that we got all of the items */

4495

test_compare(counter, keys.size());

4496

}

4497

4498

memcached_free(memc);

4499

4500

return TEST_SUCCESS;

4501

}

4502

4503

test_return_t regression_bug_583031(memcached_st *)

4504

{

4505

memcached_st *memc= memcached_create(NULL);

4506

test_true(memc);

4507

test_compare(MEMCACHED_SUCCESS, memcached_server_add(memc, "10.2.3.4", 11211));

4508

4509

memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_CONNECT_TIMEOUT, 1000);

4510

memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT, 1000);

4511

memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SND_TIMEOUT, 1000);

4512

memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_RCV_TIMEOUT, 1000);

4513

memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_POLL_TIMEOUT, 1000);

4514

memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT, 3);

4515

4516

memcached_return_t rc;

4517

size_t length;

4518

uint32_t flags;

4519

4520

const char *value= memcached_get(memc, "dsf", 3, &length, &flags, &rc);

4521

test_false(value);

4522

test_zero(length);

4523

4524

test_compare_got(MEMCACHED_TIMEOUT, rc, memcached_last_error_message(memc));

4525

4526

memcached_free(memc);

4527

4528

return TEST_SUCCESS;

4529

}

4530

4531

test_return_t regression_bug_581030(memcached_st *)

4532

{

4533

#ifndef DEBUG

4534

memcached_stat_st *local_stat= memcached_stat(NULL, NULL, NULL);

4535

test_false(local_stat);

4536

4537

memcached_stat_free(NULL, NULL);

4538

#endif

4539

4540

return TEST_SUCCESS;

4541

}

4542

4543

#define regression_bug_655423_COUNT 6000

4544

test_return_t regression_bug_655423(memcached_st *memc)

4545

{

4546

memcached_st *clone= memcached_clone(NULL, memc);

4547

memc= NULL; // Just to make sure it is not used

4548

test_true(clone);

4549

char payload[100];

4550

4551

#ifdef __APPLE__

4552

return TEST_SKIPPED;

4553

#endif

4554

4555

test_skip(MEMCACHED_SUCCESS, memcached_behavior_set(clone, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 1));

4556

test_skip(MEMCACHED_SUCCESS, memcached_behavior_set(clone, MEMCACHED_BEHAVIOR_SUPPORT_CAS, 1));

4557

test_skip(MEMCACHED_SUCCESS, memcached_behavior_set(clone, MEMCACHED_BEHAVIOR_TCP_NODELAY, 1));

4558

test_skip(MEMCACHED_SUCCESS, memcached_behavior_set(clone, MEMCACHED_BEHAVIOR_IO_KEY_PREFETCH, 1));

4559

4560

memset(payload, int('x'), sizeof(payload));

4561

4562

keys_st keys(regression_bug_655423_COUNT);

4563

4564

for (size_t x= 0; x < keys.size(); x++)

4565

{

4566

test_compare(MEMCACHED_SUCCESS, memcached_set(clone,

4567

keys.key_at(x),

4568

keys.length_at(x),

4569

payload, sizeof(payload), 0, 0));

4570

}

4571

4572

for (size_t x= 0; x < keys.size(); x++)

4573

{

4574

size_t value_length;

4575

memcached_return_t rc;

4576

char *value= memcached_get(clone,

4577

keys.key_at(x),

4578

keys.length_at(x),

4579

&value_length, NULL, &rc);

4580

4581

if (rc == MEMCACHED_NOTFOUND)

4582

{

4583

test_false(value);

4584

test_zero(value_length);

4585

continue;

4586

}

4587

4588

test_compare(MEMCACHED_SUCCESS, rc);

4589

test_true(value);

4590

test_compare(100LLU, value_length);

4591

free(value);

4592

}

4593

4594

test_compare(MEMCACHED_SUCCESS,

4595

memcached_mget(clone,

4596

keys.keys_ptr(), keys.lengths_ptr(),

4597

keys.size()));

4598

4599

uint32_t count= 0;

4600

memcached_result_st *result= NULL;

4601

while ((result= memcached_fetch_result(clone, result, NULL)))

4602

{

4603

test_compare(size_t(100), memcached_result_length(result));

4604

count++;

4605

}

4606

4607

test_true(count > 100); // If we don't get back atleast this, something is up

4608

4609

memcached_free(clone);

4610

4611

return TEST_SUCCESS;

4612

}

4613

4614

4615

* Test that ensures that buffered set to not trigger problems during io_flush

4616

4617

#define regression_bug_490520_COUNT 200480

4618

test_return_t regression_bug_490520(memcached_st *original_memc)

4619

{

4620

memcached_st* memc= create_single_instance_memcached(original_memc, NULL);

4621

4622

memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK,1);

4623

memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS,1);

4624

memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_POLL_TIMEOUT, 1000);

4625

memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT,1);

4626

memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT, 3600);

4627

4628

/* First add all of the items.. */

4629

char blob[3333] = {0};

4630

for (uint32_t x= 0; x < regression_bug_490520_COUNT; ++x)

4631

{

4632

char key[251];

4633

int key_length= snprintf(key, sizeof(key), "0200%u", x);

4634

4635

memcached_return rc= memcached_set(memc, key, key_length, blob, sizeof(blob), 0, 0);

4636

test_true_got(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED, memcached_last_error_message(memc));

4637

}

4638

4639

memcached_free(memc);

4640

4641

return TEST_SUCCESS;

4642

}

4643

4644

4645

test_return_t regression_bug_854604(memcached_st *)

4646

{

4647

char buffer[1024];

4648

4649

test_compare(MEMCACHED_INVALID_ARGUMENTS, libmemcached_check_configuration(0, 0, buffer, 0));

4650

4651

test_compare(MEMCACHED_PARSE_ERROR, libmemcached_check_configuration(test_literal_param("syntax error"), buffer, 0));

4652

4653

test_compare(MEMCACHED_PARSE_ERROR, libmemcached_check_configuration(test_literal_param("syntax error"), buffer, 1));

4654

test_compare(buffer[0], 0);

4655

4656

test_compare(MEMCACHED_PARSE_ERROR, libmemcached_check_configuration(test_literal_param("syntax error"), buffer, 10));

4657

test_true(strlen(buffer));

4658

4659

test_compare(MEMCACHED_PARSE_ERROR, libmemcached_check_configuration(test_literal_param("syntax error"), buffer, sizeof(buffer)));

4660

test_true(strlen(buffer));

4661

4662

return TEST_SUCCESS;

4663

}

4664

4665

static void memcached_die(memcached_st* mc, memcached_return error, const char* what, uint32_t it)

4666

{

4667

fprintf(stderr, "Iteration #%u: ", it);

4668

4669

if (error == MEMCACHED_ERRNO)

4670

{

4671

fprintf(stderr, "system error %d from %s: %s\n",

4672

errno, what, strerror(errno));

4673

}

4674

else

4675

{

4676

fprintf(stderr, "error %d from %s: %s\n", error, what,

4677

memcached_strerror(mc, error));

4678

}

4679

}

4680

4681

#define TEST_CONSTANT_CREATION 200

4682

4683

test_return_t regression_bug_(memcached_st *memc)

4684

{

4685

const char *remote_server;

4686

(void)memc;

4687

4688

if (! (remote_server= getenv("LIBMEMCACHED_REMOTE_SERVER")))

4689

{

4690

return TEST_SKIPPED;

4691

}

4692

4693

for (uint32_t x= 0; x < TEST_CONSTANT_CREATION; x++)

4694

{

4695

memcached_st* mc= memcached_create(NULL);

4696

memcached_return rc;

4697

4698

rc= memcached_behavior_set(mc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 1);

4699

if (rc != MEMCACHED_SUCCESS)

4700

{

4701

memcached_die(mc, rc, "memcached_behavior_set", x);

4702

}

4703

4704

rc= memcached_behavior_set(mc, MEMCACHED_BEHAVIOR_CACHE_LOOKUPS, 1);

4705

if (rc != MEMCACHED_SUCCESS)

4706

{

4707

memcached_die(mc, rc, "memcached_behavior_set", x);

4708

}

4709

4710

rc= memcached_server_add(mc, remote_server, 0);

4711

if (rc != MEMCACHED_SUCCESS)

4712

{

4713

memcached_die(mc, rc, "memcached_server_add", x);

4714

}

4715

4716

const char *set_key= "akey";

4717

const size_t set_key_len= strlen(set_key);

4718

const char *set_value= "a value";

4719

const size_t set_value_len= strlen(set_value);

4720

4721

if (rc == MEMCACHED_SUCCESS)

4722

{

4723

if (x > 0)

4724

{

4725

size_t get_value_len;

4726

char *get_value;

4727

uint32_t get_value_flags;

4728

4729

get_value= memcached_get(mc, set_key, set_key_len, &get_value_len,

4730

&get_value_flags, &rc);

4731

if (rc != MEMCACHED_SUCCESS)

4732

{

4733

memcached_die(mc, rc, "memcached_get", x);

4734

}

4735

else

4736

{

4737

4738

if (x != 0 &&

4739

(get_value_len != set_value_len

4740

|| 0!=strncmp(get_value, set_value, get_value_len)))

4741

{

4742

fprintf(stderr, "Values don't match?\n");

4743

rc= MEMCACHED_FAILURE;

4744

}

4745

free(get_value);

4746

}

4747

}

4748

4749

rc= memcached_set(mc,

4750

set_key, set_key_len,

4751

set_value, set_value_len,

4752

0, /* time */

4753

0 /* flags */

4754

);

4755

if (rc != MEMCACHED_SUCCESS)

4756

{

4757

memcached_die(mc, rc, "memcached_set", x);

4758

}

4759

}

4760

4761

memcached_quit(mc);

4762

memcached_free(mc);

4763

4764

if (rc != MEMCACHED_SUCCESS)

4765

{

4766

break;

4767

}

4768

}

4769

4770

return TEST_SUCCESS;

4771

}

4772

4773

test_return_t kill_HUP_TEST(memcached_st *original_memc)

4774

{

4775

memcached_st *memc= create_single_instance_memcached(original_memc, 0);

4776

test_true(memc);

4777

4778

memcached_server_instance_st instance= memcached_server_instance_by_position(memc, 0);

4779

4780

pid_t pid;

4781

test_true((pid= libmemcached_util_getpid(memcached_server_name(instance),

4782

memcached_server_port(instance), NULL)) > -1);

4783

4784

4785

test_compare(MEMCACHED_SUCCESS,

4786

memcached_set(memc,

4787

test_literal_param(__func__), // Keys

4788

test_literal_param(__func__), // Values

4789

0, 0));

4790

test_true_got(kill(pid, SIGHUP) == 0, strerror(errno));

4791

4792

test_compare(MEMCACHED_SUCCESS,

4793

memcached_set(memc,

4794

test_literal_param(__func__), // Keys

4795

test_literal_param(__func__), // Values

4796

0, 0));

4797

4798

memcached_free(memc);

4799

4800

return TEST_SUCCESS;

2810

4801

}

Older »