~ps10gel/ubuntu/xenial/trafficserver/6.2.0

SDK_RPRINT(test, "TSPluginDirGet", "TestCase2", TC_FAIL, "plugin dir(%s) is incorrect, expected (%s) in path. Are you using the default layout?",plugin_dir,"libexec/trafficserver");

166

*pstatus = REGRESSION_TEST_FAILED;

167

return;

168

}

169

170

if (strstr(plugin_dir, install_dir) == NULL) {

171

SDK_RPRINT(test, "TSInstallDirGet", "TestCase2", TC_FAIL, "install dir is incorrect");

172

*pstatus = REGRESSION_TEST_FAILED;

173

return;

174

}

175

176

SDK_RPRINT(test, "TSPluginDirGet", "TestCase1", TC_PASS, "ok");

177

SDK_RPRINT(test, "TSInstallDirGet", "TestCase1", TC_PASS, "ok");

178

*pstatus = REGRESSION_TEST_PASSED;

179

return;

180

}

181

182

183

/* TSConfig */

184

////////////////////////////////////////////////

185

// SDK_API_TSConfig

186

187

// Unit Test for API: TSConfigSet

188

// TSConfigGet

189

// TSConfigRelease

190

// TSConfigDataGet

191

////////////////////////////////////////////////

192

static int my_config_id = -1;

193

typedef struct

194

{

195

const char *a;

196

const char *b;

197

} ConfigData;

198

199

static void

200

config_destroy_func(void *data)

201

{

202

ConfigData *config = (ConfigData *) data;

203

TSfree(config);

204

return;

205

}

206

207

REGRESSION_TEST(SDK_API_TSConfig) (RegressionTest * test, int atype, int *pstatus)

208

{

209

NOWARN_UNUSED(atype);

210

*pstatus = REGRESSION_TEST_INPROGRESS;

211

ConfigData *config = (ConfigData *) TSmalloc(sizeof(ConfigData));

212

config->a = "unit";

213

config->b = "test";

214

215

my_config_id = TSConfigSet(0, config, config_destroy_func);

216

217

TSConfig test_config = NULL;

218

test_config = TSConfigGet(my_config_id);

219

220

if (!test_config) {

221

SDK_RPRINT(test, "TSConfigSet", "TestCase1", TC_FAIL, "can't correctly set global config structure");

222

SDK_RPRINT(test, "TSConfigGet", "TestCase1", TC_FAIL, "can't correctly get global config structure");

223

TSConfigRelease(my_config_id, config);

224

*pstatus = REGRESSION_TEST_FAILED;

225

return;

226

}

227

228

if (TSConfigDataGet(test_config) != config) {

229

SDK_RPRINT(test, "TSConfigDataGet", "TestCase1", TC_FAIL, "failed to get config data");

230

TSConfigRelease(my_config_id, config);

231

*pstatus = REGRESSION_TEST_FAILED;

232

return;

233

}

234

235

SDK_RPRINT(test, "TSConfigGet", "TestCase1", TC_PASS, "ok");

236

SDK_RPRINT(test, "TSConfigSet", "TestCase1", TC_PASS, "ok");

237

SDK_RPRINT(test, "TSConfigDataGet", "TestCase1", TC_PASS, "ok");

238

239

TSConfigRelease(my_config_id, config);

240

*pstatus = REGRESSION_TEST_PASSED;

241

return;

242

}

243

244

/* TSNetVConn */

245

//////////////////////////////////////////////

246

// SDK_API_TSNetVConn

247

248

// Unit Test for API: TSNetVConnRemoteIPGet

249

// TSNetVConnRemotePortGet

250

// TSNetAccept

251

// TSNetConnect

252

//////////////////////////////////////////////

253

#define IP(a,b,c,d) htonl((a) << 24 | (b) << 16 | (c) << 8 | (d))

254

const unsigned short server_port = 12345;

255

RegressionTest *SDK_NetVConn_test;

256

int *SDK_NetVConn_pstatus;

257

258

int

259

server_handler(TSCont contp, TSEvent event, void *data)

260

{

261

NOWARN_UNUSED(data);

262

if (event == TS_EVENT_VCONN_EOS)

263

TSContDestroy(contp);

264

265

return 1;

266

}

267

268

int

269

client_handler(TSCont contp, TSEvent event, void *data)

270

{

271

if (event == TS_EVENT_NET_CONNECT_FAILED) {

272

SDK_RPRINT(SDK_NetVConn_test, "TSNetAccept", "TestCase1", TC_FAIL, "can't connect to server");

273

SDK_RPRINT(SDK_NetVConn_test, "TSNetConnect", "TestCase1", TC_FAIL, "can't connect to server");

274

275

// no need to continue, return

276

TSContDestroy(contp);

277

// Fix me: how to deal with server side cont?

278

*SDK_NetVConn_pstatus = REGRESSION_TEST_FAILED;

279

280

return 1;

281

} else {

282

SDK_RPRINT(SDK_NetVConn_test, "TSNetAccept", "TestCase1", TC_PASS, "ok");

283

SDK_RPRINT(SDK_NetVConn_test, "TSNetConnect", "TestCase1", TC_PASS, "ok");

284

285

unsigned int input_server_ip = 0;

286

int input_server_port = 0;

287

TSNetVConnRemoteIPGet((TSVConn) data, &input_server_ip);

288

TSNetVConnRemotePortGet((TSVConn) data, &input_server_port);

289

290

if (input_server_ip != htonl(LOCAL_IP)) {

291

SDK_RPRINT(SDK_NetVConn_test, "TSNetVConnRemoteIPGet", "TestCase1", TC_FAIL, "server ip is incorrect");

292

293

TSContDestroy(contp);

294

// Fix me: how to deal with server side cont?

295

*SDK_NetVConn_pstatus = REGRESSION_TEST_FAILED;

296

return 1;

297

} else

298

SDK_RPRINT(SDK_NetVConn_test, "TSNetVConnRemoteIPGet", "TestCase1", TC_PASS, "ok");

299

300

if (input_server_port != server_port) {

301

SDK_RPRINT(SDK_NetVConn_test, "TSNetVConnRemotePortGet", "TestCase1", TC_FAIL, "server port is incorrect");

302

303

TSContDestroy(contp);

304

// Fix me: how to deal with server side cont?

305

*SDK_NetVConn_pstatus = REGRESSION_TEST_FAILED;

306

return 1;

307

} else

308

SDK_RPRINT(SDK_NetVConn_test, "TSNetVConnRemotePortGet", "TestCase1", TC_PASS, "ok");

309

310

TSVConnClose((TSVConn) data);

311

}

312

313

TSContDestroy(contp);

314

315

*SDK_NetVConn_pstatus = REGRESSION_TEST_PASSED;

316

return 1;

317

}

318

319

REGRESSION_TEST(SDK_API_TSNetVConn) (RegressionTest * test, int atype, int *pstatus)

320

{

321

NOWARN_UNUSED(atype);

322

*pstatus = REGRESSION_TEST_INPROGRESS;

323

SDK_NetVConn_test = test;

324

SDK_NetVConn_pstatus = pstatus;

325

326

TSMutex server_mutex = TSMutexCreate();

327

TSMutex client_mutex = TSMutexCreate();

328

329

TSCont server_cont = TSContCreate(server_handler, server_mutex);

330

TSCont client_cont = TSContCreate(client_handler, client_mutex);

331

332

TSNetAccept(server_cont, server_port);

333

334

unsigned int server_ip = IP(127, 0, 0, 1);

335

TSNetConnect(client_cont, server_ip, server_port);

336

}

337

338

/* TSCache, TSVConn, TSVIO */

339

//////////////////////////////////////////////

340

// SDK_API_TSCache

341

342

// Unit Test for API: TSCacheReady

343

// TSCacheWrite

344

// TSCacheRead

345

// TSCacheKeyCreate

346

// TSCacheKeyDigestSet

347

// TSVConnCacheObjectSizeGet

348

// TSVConnClose

349

// TSVConnClosedGet

350

// TSVConnRead

351

// TSVConnReadVIOGet

352

// TSVConnWrite

353

// TSVConnWriteVIOGet

354

// TSVIOBufferGet

355

// TSVIOContGet

356

// TSVIOMutexGet

357

// TSVIONBytesGet

358

// TSVIONBytesSet

359

// TSVIONDoneGet

360

// TSVIONDoneSet

361

// TSVIONTodoGet

362

// TSVIOReaderGet

363

// TSVIOReenable

364

// TSVIOVConnGet

365

//////////////////////////////////////////////

366

367

// TSVConnAbort can't be tested

368

// Fix me: test TSVConnShutdown, TSCacheKeyDataTypeSet,

369

// TSCacheKeyHostNameSet, TSCacheKeyPinnedSet

370

371

// Logic of the test:

372

// - write OBJECT_SIZE bytes in the cache in 3 shots

373

// (OBJECT_SIZE/2, then OBJECT_SIZE-100 and finally OBJECT_SIZE)

374

// - read object from the cache

375

// - remove it from the cache

376

// - try to read it (should faild)

377

378

379

#define OBJECT_SIZE 100000 // size of the object we'll write/read/remove in cache

380

381

382

RegressionTest *SDK_Cache_test;

383

int *SDK_Cache_pstatus;

384

static char content[OBJECT_SIZE];

385

static int read_counter = 0;

386

387

typedef struct

388

{

389

TSIOBuffer bufp;

390

TSIOBuffer out_bufp;

391

TSIOBufferReader readerp;

392

TSIOBufferReader out_readerp;

393

394

TSVConn write_vconnp;

395

TSVConn read_vconnp;

396

TSVIO read_vio;

397

TSVIO write_vio;

398

399

TSCacheKey key;

400

} CacheVConnStruct;

401

402

int

403

cache_handler(TSCont contp, TSEvent event, void *data)

404

{

405

Debug("sdk_ut_cache_write", "Event %d data %p", event, data);

406

407

CacheVConnStruct *cache_vconn = (CacheVConnStruct *) TSContDataGet(contp);

408

409

TSIOBufferBlock blockp;

410

char *ptr_block;

411

int64_t ntodo, ndone, nbytes, towrite, avail, content_length;

412

413

switch (event) {

414

case TS_EVENT_CACHE_OPEN_WRITE:

415

Debug(UTDBG_TAG "_cache_event", "TS_EVENT_CACHE_OPEN_WRITE %d %p", event, data);

416

SDK_RPRINT(SDK_Cache_test, "TSCacheWrite", "TestCase1", TC_PASS, "ok");

417

418

// data is write_vc

419

cache_vconn->write_vconnp = (TSVConn) data;

420

421

// Create buffers/readers to write and read data into the cache

422

cache_vconn->bufp = TSIOBufferCreate();

423

cache_vconn->readerp = TSIOBufferReaderAlloc(cache_vconn->bufp);

424

cache_vconn->out_bufp = TSIOBufferCreate();

425

cache_vconn->out_readerp = TSIOBufferReaderAlloc(cache_vconn->out_bufp);

426

427

// Write content into upstream IOBuffer

428

ntodo = OBJECT_SIZE;

429

ndone = 0;

430

while (ntodo > 0) {

431

blockp = TSIOBufferStart(cache_vconn->bufp);

432

ptr_block = TSIOBufferBlockWriteStart(blockp, &avail);

433

towrite = ((ntodo < avail) ? ntodo : avail);

434

memcpy(ptr_block, content + ndone, towrite);

435

TSIOBufferProduce(cache_vconn->bufp, towrite);

436

ntodo -= towrite;

437

ndone += towrite;

438

}

439

440

// first write half of the data. To test TSVIOReenable

441

cache_vconn->write_vio = TSVConnWrite((TSVConn) data, contp, cache_vconn->readerp, OBJECT_SIZE / 2);

442

return 1;

443

444

case TS_EVENT_CACHE_OPEN_WRITE_FAILED:

445

Debug(UTDBG_TAG "_cache_event", "TS_EVENT_CACHE_OPEN_WRITE_FAILED %d %p", event, data);

446

SDK_RPRINT(SDK_Cache_test, "TSCacheWrite", "TestCase1", TC_FAIL, "can't open cache vc, edtata = %p", data);

447

TSReleaseAssert(!"cache");

448

449

// no need to continue, return

450

*SDK_Cache_pstatus = REGRESSION_TEST_FAILED;

451

return 1;

452

453

case TS_EVENT_CACHE_OPEN_READ:

454

Debug(UTDBG_TAG "_cache_event", "TS_EVENT_CACHE_OPEN_READ %d %p", event, data);

455

if (read_counter == 2) {

456

SDK_RPRINT(SDK_Cache_test, "TSCacheRead", "TestCase2", TC_FAIL, "shouldn't open cache vc");

457

458

// no need to continue, return

459

*SDK_Cache_pstatus = REGRESSION_TEST_FAILED;

460

return 1;

461

}

462

463

SDK_RPRINT(SDK_Cache_test, "TSCacheRead", "TestCase1", TC_PASS, "ok");

464

465

cache_vconn->read_vconnp = (TSVConn) data;

466

TSVConnCacheObjectSizeGet(cache_vconn->read_vconnp, &content_length);

467

Debug(UTDBG_TAG "_cache_read", "In cache open read [Content-Length: %d]", content_length);

468

if (content_length != OBJECT_SIZE) {

469

SDK_RPRINT(SDK_Cache_test, "TSVConnCacheObjectSizeGet", "TestCase1", TC_FAIL, "cached data size is incorrect");

470

471

// no need to continue, return

472

*SDK_Cache_pstatus = REGRESSION_TEST_FAILED;

473

return 1;

474

} else {

475

SDK_RPRINT(SDK_Cache_test, "TSVConnCacheObjectSizeGet", "TestCase1", TC_PASS, "ok");

476

cache_vconn->read_vio = TSVConnRead((TSVConn) data, contp, cache_vconn->out_bufp, content_length);

477

}

478

return 1;

479

480

case TS_EVENT_CACHE_OPEN_READ_FAILED:

481

Debug(UTDBG_TAG "_cache_event", "TS_EVENT_CACHE_OPEN_READ_FAILED %d %p", event, data);

482

if (read_counter == 1) {

483

SDK_RPRINT(SDK_Cache_test, "TSCacheRead", "TestCase1", TC_FAIL, "can't open cache vc");

484

485

// no need to continue, return

486

*SDK_Cache_pstatus = REGRESSION_TEST_FAILED;

487

return 1;

488

}

489

SDK_RPRINT(SDK_Cache_test, "TSCacheRead", "TestCase2", TC_PASS, "ok");

490

491

// ok, all tests passed!

492

break;

493

494

case TS_EVENT_CACHE_REMOVE:

495

Debug(UTDBG_TAG "_cache_event", "TS_EVENT_CACHE_REMOVE %d %p", event, data);

496

SDK_RPRINT(SDK_Cache_test, "TSCacheRemove", "TestCase1", TC_PASS, "ok");

497

498

// read the data which has been removed

499

read_counter++;

500

TSCacheRead(contp, cache_vconn->key);

501

return 1;

502

503

case TS_EVENT_CACHE_REMOVE_FAILED:

504

Debug(UTDBG_TAG "_cache_event", "TS_EVENT_CACHE_REMOVE_FAILED %d %p", event, data);

505

SDK_RPRINT(SDK_Cache_test, "TSCacheRemove", "TestCase1", TC_FAIL, "can't remove cached item");

506

507

// no need to continue, return

508

*SDK_Cache_pstatus = REGRESSION_TEST_FAILED;

509

return 1;

510

511

case TS_EVENT_VCONN_WRITE_COMPLETE:

512

Debug(UTDBG_TAG "_cache_event", "TS_EVENT_VCONN_WRITE_COMPLETE %d %p", event, data);

513

514

// VConn/VIO APIs

515

nbytes = TSVIONBytesGet(cache_vconn->write_vio);

516

ndone = TSVIONDoneGet(cache_vconn->write_vio);

517

ntodo = TSVIONTodoGet(cache_vconn->write_vio);

518

Debug(UTDBG_TAG "_cache_write", "Nbytes=%d Ndone=%d Ntodo=%d", nbytes, ndone, ntodo);

519

520

if (ndone == (OBJECT_SIZE / 2)) {

521

TSVIONBytesSet(cache_vconn->write_vio, (OBJECT_SIZE - 100));

522

TSVIOReenable(cache_vconn->write_vio);

523

Debug(UTDBG_TAG "_cache_write", "Increment write_counter in write_complete [a]");

524

return 1;

525

} else if (ndone == (OBJECT_SIZE - 100)) {

526

TSVIONBytesSet(cache_vconn->write_vio, OBJECT_SIZE);

527

TSVIOReenable(cache_vconn->write_vio);

528

Debug(UTDBG_TAG "_cache_write", "Increment write_counter in write_complete [b]");

529

return 1;

530

} else if (ndone == OBJECT_SIZE) {

531

Debug(UTDBG_TAG "_cache_write", "finishing up [c]");

532

533

SDK_RPRINT(SDK_Cache_test, "TSVIOReenable", "TestCase2", TC_PASS, "ok");

534

SDK_RPRINT(SDK_Cache_test, "TSVIONBytesSet", "TestCase1", TC_PASS, "ok");

535

SDK_RPRINT(SDK_Cache_test, "TSVConnWrite", "TestCase1", TC_PASS, "ok");

536

} else {

537

SDK_RPRINT(SDK_Cache_test, "TSCacheWrite", "TestCase1", TC_FAIL, "Did not write expected # of bytes");

538

// no need to continue, return

539

*SDK_Cache_pstatus = REGRESSION_TEST_FAILED;

540

return 1;

541

}

542

543

if ((TSVIO) data != cache_vconn->write_vio) {

544

SDK_RPRINT(SDK_Cache_test, "TSVConnWrite", "TestCase1", TC_FAIL, "write_vio corrupted");

545

// no need to continue, return

546

*SDK_Cache_pstatus = REGRESSION_TEST_FAILED;

547

return 1;

548

}

549

Debug(UTDBG_TAG "_cache_write", "finishing up [d]");

550

551

552

if (TSVIOBufferGet(cache_vconn->write_vio) != cache_vconn->bufp) {

553

SDK_RPRINT(SDK_Cache_test, "TSVIOBufferGet", "TestCase1", TC_FAIL, "write_vio corrupted");

554

*SDK_Cache_pstatus = REGRESSION_TEST_FAILED;

555

return 1;

556

} else {

557

SDK_RPRINT(SDK_Cache_test, "TSVIOBufferGet", "TestCase1", TC_PASS, "ok");

558

}

559

560

if (TSVIOContGet(cache_vconn->write_vio) != contp) {

561

SDK_RPRINT(SDK_Cache_test, "TSVIOContGet", "TestCase1", TC_FAIL, "write_vio corrupted");

562

*SDK_Cache_pstatus = REGRESSION_TEST_FAILED;

563

return 1;

564

} else {

565

SDK_RPRINT(SDK_Cache_test, "TSVIOContGet", "TestCase1", TC_PASS, "ok");

566

}

567

568

Debug(UTDBG_TAG "_cache_write", "finishing up [f]");

569

570

if (TSVIOMutexGet(cache_vconn->write_vio) != TSContMutexGet(contp)) {

571

SDK_RPRINT(SDK_Cache_test, "TSVIOMutexGet", "TestCase1", TC_FAIL, "write_vio corrupted");

572

*SDK_Cache_pstatus = REGRESSION_TEST_FAILED;

573

return 1;

574

} else {

575

SDK_RPRINT(SDK_Cache_test, "TSVIOMutexGet", "TestCase1", TC_PASS, "ok");

576

}

577

578

if (TSVIOVConnGet(cache_vconn->write_vio) != cache_vconn->write_vconnp) {

579

SDK_RPRINT(SDK_Cache_test, "TSVIOVConnGet", "TestCase1", TC_FAIL, "write_vio corrupted");

580

*SDK_Cache_pstatus = REGRESSION_TEST_FAILED;

581

return 1;

582

} else {

583

SDK_RPRINT(SDK_Cache_test, "TSVIOVConnGet", "TestCase1", TC_PASS, "ok");

584

}

585

586

Debug(UTDBG_TAG "_cache_write", "finishing up [g]");

587

588

if (TSVIOReaderGet(cache_vconn->write_vio) != cache_vconn->readerp) {

589

SDK_RPRINT(SDK_Cache_test, "TSVIOReaderGet", "TestCase1", TC_FAIL, "write_vio corrupted");

590

*SDK_Cache_pstatus = REGRESSION_TEST_FAILED;

591

return 1;

592

} else {

593

SDK_RPRINT(SDK_Cache_test, "TSVIOReaderGet", "TestCase1", TC_PASS, "ok");

594

}

595

596

// tests for write is done, close write_vconnp

597

TSVConnClose(cache_vconn->write_vconnp);

598

cache_vconn->write_vconnp = NULL;

599

600

Debug(UTDBG_TAG "_cache_write", "finishing up [h]");

601

602

603

// start to read data out of cache

604

read_counter++;

605

TSCacheRead(contp, cache_vconn->key);

606

Debug(UTDBG_TAG "_cache_read", "starting read [i]");

607

return 1;

608

609

610

case TS_EVENT_VCONN_WRITE_READY:

611

Debug(UTDBG_TAG "_cache_event", "TS_EVENT_VCONN_WRITE_READY %d %p", event, data);

612

if ((TSVIO) data != cache_vconn->write_vio) {

613

SDK_RPRINT(SDK_Cache_test, "TSVConnWrite", "TestCase1", TC_FAIL, "write_vio corrupted");

614

*SDK_Cache_pstatus = REGRESSION_TEST_FAILED;

615

return 1;

616

}

617

618

nbytes = TSVIONBytesGet(cache_vconn->write_vio);

619

ndone = TSVIONDoneGet(cache_vconn->write_vio);

620

ntodo = TSVIONTodoGet(cache_vconn->write_vio);

621

Debug(UTDBG_TAG "_cache_write", "Nbytes=%d Ndone=%d Ntodo=%d", nbytes, ndone, ntodo);

622

623

TSVIOReenable(cache_vconn->write_vio);

624

return 1;

625

626

case TS_EVENT_VCONN_READ_COMPLETE:

627

Debug(UTDBG_TAG "_cache_event", "TS_EVENT_VCONN_READ_COMPLETE %d %p", event, data);

628

if ((TSVIO) data != cache_vconn->read_vio) {

629

SDK_RPRINT(SDK_Cache_test, "TSVConnRead", "TestCase1", TC_FAIL, "read_vio corrupted");

630

631

// no need to continue, return

632

*SDK_Cache_pstatus = REGRESSION_TEST_FAILED;

633

return 1;

634

}

635

636

nbytes = TSVIONBytesGet(cache_vconn->read_vio);

637

ntodo = TSVIONTodoGet(cache_vconn->read_vio);

638

ndone = TSVIONDoneGet(cache_vconn->read_vio);

639

Debug(UTDBG_TAG "_cache_read", "Nbytes=%d Ndone=%d Ntodo=%d", nbytes, ndone, ntodo);

640

641

if (nbytes != (ndone + ntodo)) {

642

SDK_RPRINT(SDK_Cache_test, "TSVIONBytesGet", "TestCase1", TC_FAIL, "read_vio corrupted");

643

SDK_RPRINT(SDK_Cache_test, "TSVIONTodoGet", "TestCase1", TC_FAIL, "read_vio corrupted");

644

SDK_RPRINT(SDK_Cache_test, "TSVIONDoneGet", "TestCase1", TC_FAIL, "read_vio corrupted");

645

646

// no need to continue, return

647

*SDK_Cache_pstatus = REGRESSION_TEST_FAILED;

648

return 1;

649

} else {

650

SDK_RPRINT(SDK_Cache_test, "TSVIONBytesGet", "TestCase1", TC_PASS, "ok");

651

SDK_RPRINT(SDK_Cache_test, "TSVIONTodoGet", "TestCase1", TC_PASS, "ok");

652

SDK_RPRINT(SDK_Cache_test, "TSVIONDoneGet", "TestCase1", TC_PASS, "ok");

653

654

TSVIONDoneSet(cache_vconn->read_vio, 0);

655

if (TSVIONDoneGet(cache_vconn->read_vio) != 0) {

656

SDK_RPRINT(SDK_Cache_test, "TSVIONDoneSet", "TestCase1", TC_FAIL, "fail to set");

657

658

// no need to continue, return

659

*SDK_Cache_pstatus = REGRESSION_TEST_FAILED;

660

return 1;

661

} else

662

SDK_RPRINT(SDK_Cache_test, "TSVIONDoneSet", "TestCase1", TC_PASS, "ok");

663

664

Debug(UTDBG_TAG "_cache_write", "finishing up [i]");

665

666

// now waiting for 100ms to make sure the key is

667

// written in directory remove the content

668

TSContSchedule(contp, 100, TS_THREAD_POOL_DEFAULT);

669

}

670

671

return 1;

672

673

case TS_EVENT_VCONN_READ_READY:

674

Debug(UTDBG_TAG "_cache_event", "TS_EVENT_VCONN_READ_READY %d %p", event, data);

675

if ((TSVIO) data != cache_vconn->read_vio) {

676

SDK_RPRINT(SDK_Cache_test, "TSVConnRead", "TestCase1", TC_FAIL, "read_vio corrupted");

677

678

// no need to continue, return

679

*SDK_Cache_pstatus = REGRESSION_TEST_FAILED;

680

return 1;

681

}

682

683

nbytes = TSVIONBytesGet(cache_vconn->read_vio);

684

ntodo = TSVIONTodoGet(cache_vconn->read_vio);

685

ndone = TSVIONDoneGet(cache_vconn->read_vio);

686

Debug(UTDBG_TAG "_cache_read", "Nbytes=%d Ndone=%d Ntodo=%d", nbytes, ndone, ntodo);

687

688

if (nbytes != (ndone + ntodo)) {

689

SDK_RPRINT(SDK_Cache_test, "TSVIONBytesGet", "TestCase1", TC_FAIL, "read_vio corrupted");

690

SDK_RPRINT(SDK_Cache_test, "TSVIONTodoGet", "TestCase1", TC_FAIL, "read_vio corrupted");

691

SDK_RPRINT(SDK_Cache_test, "TSVIONDoneGet", "TestCase1", TC_FAIL, "read_vio corrupted");

692

693

// no need to continue, return

694

*SDK_Cache_pstatus = REGRESSION_TEST_FAILED;

695

return 1;

696

} else {

697

SDK_RPRINT(SDK_Cache_test, "TSVIONBytesGet", "TestCase1", TC_PASS, "ok");

698

SDK_RPRINT(SDK_Cache_test, "TSVIONTodoGet", "TestCase1", TC_PASS, "ok");

699

SDK_RPRINT(SDK_Cache_test, "TSVIONDoneGet", "TestCase1", TC_PASS, "ok");

700

}

701

702

// Fix for bug INKqa12276: Must consume data from iobuffer

703

nbytes = TSIOBufferReaderAvail(cache_vconn->out_readerp);

704

TSIOBufferReaderConsume(cache_vconn->out_readerp, nbytes);

705

TSDebug(UTDBG_TAG "_cache_read", "Consuming %d bytes from cache read VC", nbytes);

706

707

TSVIOReenable(cache_vconn->read_vio);

708

Debug(UTDBG_TAG "_cache_read", "finishing up [j]");

709

return 1;

710

711

case TS_EVENT_TIMEOUT:

712

Debug(UTDBG_TAG "_cache_event", "TS_EVENT_TIMEOUT %d %p", event, data);

713

// do remove cached doc

714

TSCacheRemove(contp, cache_vconn->key);

715

return 1;

716

717

default:

718

TSReleaseAssert(!"Test SDK_API_TSCache: unexpected event");

719

}

720

721

Debug(UTDBG_TAG "_cache_event", "DONE DONE DONE");

722

723

// destroy the data structure

724

Debug(UTDBG_TAG "_cache_write", "all tests passed [z]");

725

TSIOBufferDestroy(cache_vconn->bufp);

726

TSIOBufferDestroy(cache_vconn->out_bufp);

727

TSCacheKeyDestroy(cache_vconn->key);

728

TSfree(cache_vconn);

729

*SDK_Cache_pstatus = REGRESSION_TEST_PASSED;

730

731

return 1;

732

}

733

734

REGRESSION_TEST(SDK_API_TSCache) (RegressionTest * test, int atype, int *pstatus)

735

{

736

NOWARN_UNUSED(atype);

737

*pstatus = REGRESSION_TEST_INPROGRESS;

738

SDK_Cache_test = test;

739

SDK_Cache_pstatus = pstatus;

740

int is_ready = 0;

741

742

// Check if Cache is ready

743

TSCacheReady(&is_ready);

744

if (!is_ready) {

745

SDK_RPRINT(test, "TSCacheReady", "TestCase1", TC_FAIL, "cache is not ready");

746

747

// no need to continue, return

748

*pstatus = REGRESSION_TEST_FAILED;

749

return;

750

} else {

751

SDK_RPRINT(test, "TSCacheReady", "TestCase1", TC_PASS, "ok");

752

}

753

754

// Create CacheKey

755

char key_name[] = "key_for_regression_test";

756

TSCacheKey key, key_cmp;

757

TSCacheKeyCreate(&key);

758

TSCacheKeyCreate(&key_cmp);

759

if (key == NULL) {

760

SDK_RPRINT(test, "TSCacheKeyCreate", "TestCase1", TC_FAIL, "can't malloc memory for key");

761

762

// no need to continue, return

763

*pstatus = REGRESSION_TEST_FAILED;

764

if (key_cmp != NULL)

765

TSCacheKeyDestroy(key_cmp);

766

return;

767

} else {

768

SDK_RPRINT(test, "TSCacheKeyCreate", "TestCase1", TC_PASS, "ok");

769

}

770

TSCacheKeyDigestSet(key, key_name, strlen(key_name));

771

TSCacheKeyDigestSet(key_cmp, key_name, strlen(key_name));

772

773

if (memcmp(key, key_cmp, sizeof(TSCacheKey)) != 0) {

774

SDK_RPRINT(test, "TSCacheKeySetDigest", "TestCase1", TC_FAIL, "digest is wrong");

775

776

// no need to continue, return

777

*pstatus = REGRESSION_TEST_FAILED;

778

TSCacheKeyDestroy(key);

779

TSCacheKeyDestroy(key_cmp);

780

return;

781

} else {

782

SDK_RPRINT(test, "TSCacheKeySetDigest", "TestCase1", TC_PASS, "ok");

783

TSCacheKeyDestroy(key_cmp);

784

}

785

786

// prepare caching content

787

// string, null-terminated.

788

for (int i = 0; i < (OBJECT_SIZE - 1); i++) {

789

content[i] = 'a';

790

}

791

content[OBJECT_SIZE - 1] = '\0';

792

793

//Write data to cache.

794

TSCont contp = TSContCreate(cache_handler, TSMutexCreate());

795

CacheVConnStruct *cache_vconn = (CacheVConnStruct *) TSmalloc(sizeof(CacheVConnStruct));

796

cache_vconn->key = key;

797

TSContDataSet(contp, cache_vconn);

798

799

TSCacheWrite(contp, key);

800

}

801

802

/* TSfopen */

803

804

//////////////////////////////////////////////

805

// SDK_API_TSfopen

806

807

// Unit Test for API: TSfopen

808

// TSclose

809

// TSfflush

810

// TSfgets

811

// TSfread

812

// TSfwrite

813

//////////////////////////////////////////////

814

815

// Used to create tmp file

816

//#define TMP_DIR "/var/tmp"

817

#define PFX "plugin.config"

818

819

REGRESSION_TEST(SDK_API_TSfopen) (RegressionTest * test, int atype, int *pstatus)

820

{

821

NOWARN_UNUSED(atype);

822

*pstatus = REGRESSION_TEST_INPROGRESS;

823

824

char write_file_name[PATH_NAME_MAX + 1];

825

826

TSFile source_read_file; // existing file

827

TSFile write_file; // to be created

828

TSFile cmp_read_file; // read & compare

829

830

char input_buffer[BUFSIZ];

831

char cmp_buffer[BUFSIZ];

832

struct stat stat_buffer_pre, stat_buffer_post, stat_buffer_input;

833

char *ret_val;

834

int error_counter = 0, read = 0, wrote = 0;

835

int64_t read_amount = 0;

836

char INPUT_TEXT_FILE[] = "plugin.config";

837

char input_file_full_path[BUFSIZ];

838

839

840

841

// Set full path to file at run time.

842

// TODO: This can never fail since we are

843

// returning the char[]

844

// Better check the dir itself.

845

846

if (TSInstallDirGet() == NULL) {

847

error_counter++;

848

*pstatus = REGRESSION_TEST_FAILED;

849

return;

850

}

851

// Add "etc/trafficserver" to point to config directory

852

ink_filepath_make(input_file_full_path, sizeof(input_file_full_path), TSConfigDirGet(), INPUT_TEXT_FILE);

853

854

// open existing file for reading

855

if (!(source_read_file = TSfopen(input_file_full_path, "r"))) {

856

SDK_RPRINT(test, "TSfopen", "TestCase1", TC_FAIL, "can't open file for reading");

857

error_counter++;

858

859

// no need to continue, return

860

*pstatus = REGRESSION_TEST_FAILED;

861

return;

862

} else

863

SDK_RPRINT(test, "TSfopen", "TestCase1", TC_PASS, "ok");

864

865

// Create unique tmp _file_name_, do not use any TS file_name

866

snprintf(write_file_name, PATH_NAME_MAX, "/tmp/%sXXXXXX", PFX);

867

int write_file_fd; // this file will be reopened below

868

if ((write_file_fd = mkstemp(write_file_name)) <= 0) {

869

SDK_RPRINT(test, "mkstemp", "std func", TC_FAIL, "can't create file for writing");

870

error_counter++;

871

872

// no need to continue, return

873

*pstatus = REGRESSION_TEST_FAILED;

874

if (source_read_file != NULL)

875

TSfclose(source_read_file);

876

return;

877

}

878

close(write_file_fd);

879

880

// open file for writing, the file doesn't have to exist.

881

if (!(write_file = TSfopen(write_file_name, "w"))) {

882

SDK_RPRINT(test, "TSfopen", "TestCase2", TC_FAIL, "can't open file for writing");

883

error_counter++;

884

885

// no need to continue, return

886

*pstatus = REGRESSION_TEST_FAILED;

887

if (source_read_file != NULL)

888

TSfclose(source_read_file);

889

return;

890

}

891

SDK_RPRINT(test, "TSfopen", "TestCase2", TC_PASS, "ok");

892

893

memset(input_buffer, '\0', BUFSIZ);

894

895

// source_read_file and input_file_full_path are the same file

896

if (stat(input_file_full_path, &stat_buffer_input) != 0) {

897

SDK_RPRINT(test, "stat", "std func", TC_FAIL, "source file and input file messed up");

898

error_counter++;

899

900

// no need to continue, return

901

*pstatus = REGRESSION_TEST_FAILED;

902

if (source_read_file != NULL)

903

TSfclose(source_read_file);

904

if (write_file != NULL)

905

TSfclose(write_file);

906

return;

907

}

908

909

read_amount = (stat_buffer_input.st_size <= (off_t)sizeof(input_buffer)) ?

910

(stat_buffer_input.st_size) : (sizeof(input_buffer));

911

912

// TSfgets

913

if ((ret_val = TSfgets(source_read_file, input_buffer, read_amount))

914

== NULL) {

915

SDK_RPRINT(test, "TSfgets", "TestCase1", TC_FAIL, "can't read from file");

916

error_counter++;

917

918

// no need to continue, return

919

*pstatus = REGRESSION_TEST_FAILED;

920

if (source_read_file != NULL)

921

TSfclose(source_read_file);

922

if (write_file != NULL)

923

TSfclose(write_file);

924

return;

925

} else {

926

if (ret_val != input_buffer) {

927

SDK_RPRINT(test, "TSfgets", "TestCase2", TC_FAIL, "reading error");

928

error_counter++;

929

930

// no need to continue, return

931

*pstatus = REGRESSION_TEST_FAILED;

932

if (source_read_file != NULL)

933

TSfclose(source_read_file);

934

if (write_file != NULL)

935

TSfclose(write_file);

936

return;

937

} else

938

SDK_RPRINT(test, "TSfgets", "TestCase1", TC_PASS, "ok");

939

}

940

941

// TSfwrite

942

wrote = TSfwrite(write_file, input_buffer, read_amount);

943

if (wrote != read_amount) {

944

SDK_RPRINT(test, "TSfwrite", "TestCase1", TC_FAIL, "writing error");

945

error_counter++;

946

947

// no need to continue, return

948

*pstatus = REGRESSION_TEST_FAILED;

949

if (source_read_file != NULL)

950

TSfclose(source_read_file);

951

if (write_file != NULL)

952

TSfclose(write_file);

953

return;

954

}

955

956

SDK_RPRINT(test, "TSfwrite", "TestCase1", TC_PASS, "ok");

957

958

// TSfflush

959

if (stat(write_file_name, &stat_buffer_pre) != 0) {

960

SDK_RPRINT(test, "stat", "std func", TC_FAIL, "TSfwrite error");

961

error_counter++;

962

963

// no need to continue, return

964

*pstatus = REGRESSION_TEST_FAILED;

965

if (source_read_file != NULL)

966

TSfclose(source_read_file);

967

if (write_file != NULL)

968

TSfclose(write_file);

969

return;

970

}

971

972

TSfflush(write_file); // write_file should point to write_file_name

973

974

if (stat(write_file_name, &stat_buffer_post) != 0) {

975

SDK_RPRINT(test, "stat", "std func", TC_FAIL, "TSfflush error");

976

error_counter++;

977

978

// no need to continue, return

979

*pstatus = REGRESSION_TEST_FAILED;

980

if (source_read_file != NULL)

981

TSfclose(source_read_file);

982

if (write_file != NULL)

983

TSfclose(write_file);

984

return;

985

}

986

987

if ((stat_buffer_pre.st_size == 0) && (stat_buffer_post.st_size == read_amount)) {

988

SDK_RPRINT(test, "TSfflush", "TestCase1", TC_PASS, "ok");

989

} else {

990

SDK_RPRINT(test, "TSfflush", "TestCase1", TC_FAIL, "TSfflush error");

991

error_counter++;

992

993

// no need to continue, return

994

*pstatus = REGRESSION_TEST_FAILED;

995

if (source_read_file != NULL)

996

TSfclose(source_read_file);

997

if (write_file != NULL)

998

TSfclose(write_file);

999

return;

1000

}

1001

1002

// TSfread

1003

// open again for reading

1004

cmp_read_file = TSfopen(write_file_name, "r");

1005

if (cmp_read_file == NULL) {

1006

SDK_RPRINT(test, "TSfopen", "TestCase3", TC_FAIL, "can't open file for reading");

1007

error_counter++;

1008

1009

// no need to continue, return

1010

*pstatus = REGRESSION_TEST_FAILED;

1011

if (source_read_file != NULL)

1012

TSfclose(source_read_file);

1013

if (write_file != NULL)

1014

TSfclose(write_file);

1015

return;

1016

}

1017

1018

read_amount = (stat_buffer_input.st_size <= (off_t)sizeof(cmp_buffer)) ? (stat_buffer_input.st_size) : (sizeof(cmp_buffer));

1019

1020

// TSfread on read file

1021

read = TSfread(cmp_read_file, cmp_buffer, read_amount);

1022

if (read != read_amount) {

1023

SDK_RPRINT(test, "TSfread", "TestCase1", TC_FAIL, "can't reading");

1024

error_counter++;

1025

1026

// no need to continue, return

1027

*pstatus = REGRESSION_TEST_FAILED;

1028

if (source_read_file != NULL)

1029

TSfclose(source_read_file);

1030

if (write_file != NULL)

1031

TSfclose(write_file);

1032

if (cmp_read_file != NULL)

1033

TSfclose(cmp_read_file);

1034

return;

1035

} else

1036

SDK_RPRINT(test, "TSfread", "TestCase1", TC_PASS, "ok");

1037

1038

// compare input_buffer and cmp_buffer buffers

1039

if (memcmp(input_buffer, cmp_buffer, read_amount) != 0) {

1040

SDK_RPRINT(test, "TSfread", "TestCase2", TC_FAIL, "reading error");

1041

error_counter++;

1042

1043

// no need to continue, return

1044

*pstatus = REGRESSION_TEST_FAILED;

1045

if (source_read_file != NULL)

1046

TSfclose(source_read_file);

1047

if (write_file != NULL)

1048

TSfclose(write_file);

1049

if (cmp_read_file != NULL)

1050

TSfclose(cmp_read_file);

1051

return;

1052

} else

1053

SDK_RPRINT(test, "TSfread", "TestCase2", TC_PASS, "ok");

1054

1055

// remove the tmp file

1056

if (unlink(write_file_name) != 0) {

1057

SDK_RPRINT(test, "unlink", "std func", TC_FAIL, "can't remove temp file");

1058

}

1059

// TSfclose on read file

1060

TSfclose(source_read_file);

1061

SDK_RPRINT(test, "TSfclose", "TestCase1", TC_PASS, "ok");

1062

1063

// TSfclose on write file

1064

TSfclose(write_file);

1065

SDK_RPRINT(test, "TSfclose", "TestCase2", TC_PASS, "ok");

1066

1067

if (error_counter == 0) {

1068

*pstatus = REGRESSION_TEST_PASSED;

1069

} else {

1070

*pstatus = REGRESSION_TEST_FAILED;

1071

}

1072

if (cmp_read_file != NULL)

1073

TSfclose(cmp_read_file);

1074

}

1075

1076

/* TSThread */

1077

1078

//////////////////////////////////////////////

1079

// SDK_API_TSThread

1080

1081

// Unit Test for API: TSThread

1082

// TSThreadCreate

1083

// TSThreadSelf

1084

//////////////////////////////////////////////

1085

static int thread_err_count = 0;

1086

static RegressionTest *SDK_Thread_test;

1087

static int *SDK_Thread_pstatus;

1088

static void *thread_create_handler(void *arg);

1089

1090

static void *

1091

thread_create_handler(void *arg)

1092

{

1093

NOWARN_UNUSED(arg);

1094

TSThread athread;

1095

//Fix me: do more useful work

1096

sleep(10);

1097

1098

athread = TSThreadSelf();

1099

if (athread == 0) {

1100

thread_err_count++;

1101

SDK_RPRINT(SDK_Thread_test, "TSThreadCreate", "TestCase2", TC_FAIL, "can't get thread");

1102

} else {

1103

SDK_RPRINT(SDK_Thread_test, "TSThreadCreate", "TestCase2", TC_PASS, "ok");

1104

}

1105

1106

if (thread_err_count > 0)

1107

*SDK_Thread_pstatus = REGRESSION_TEST_FAILED;

1108

else

1109

*SDK_Thread_pstatus = REGRESSION_TEST_PASSED;

1110

1111

return NULL;

1112

}

1113

1114

// Fix me: Solaris threads/Win2K threads tests

1115

1116

// Argument data passed to thread init functions

1117

// cannot be allocated on the stack.

1118

1119

REGRESSION_TEST(SDK_API_TSThread) (RegressionTest * test, int atype, int *pstatus)

1120

{

1121

NOWARN_UNUSED(atype);

1122

*pstatus = REGRESSION_TEST_INPROGRESS;

1123

SDK_Thread_test = test;

1124

SDK_Thread_pstatus = pstatus;

1125

1126

TSThread curr_thread = 0;

1127

// TSThread created_thread = 0;

1128

pthread_t curr_tid;

1129

1130

curr_tid = pthread_self();

1131

1132

// TSThreadSelf

1133

curr_thread = TSThreadSelf();

1134

if (curr_thread == 0) {

1135

SDK_RPRINT(test, "TSThreadSelf", "TestCase1", TC_FAIL, "can't get the current thread");

1136

thread_err_count++;

1137

} else {

1138

SDK_RPRINT(test, "TSThreadSelf", "TestCase1", TC_PASS, "ok");

1139

}

1140

1141

// TSThreadCreate

1142

TSThread created_thread = TSThreadCreate(thread_create_handler, (void *) curr_tid);

1143

if (created_thread == NULL) {

1144

thread_err_count++;

1145

SDK_RPRINT(test, "TSThreadCreate", "TestCase1", TC_FAIL, "can't create thread");

1146

} else {

1147

SDK_RPRINT(test, "TSThreadCreate", "TestCase1", TC_PASS, "ok");

1148

}

1149

}

1150

1151

1152

//////////////////////////////////////////////

1153

// SDK_API_TSThread

1154

1155

// Unit Test for API: TSThreadInit

1156

// TSThreadDestroy

1157

//////////////////////////////////////////////

1158

static int thread_init_err_count = 0;

1159

static RegressionTest *SDK_ThreadInit_test;

1160

static int *SDK_ThreadInit_pstatus;

1161

static void *pthread_start_func(void *arg);

1162

1163

static void *

1164

pthread_start_func(void *arg)

1165

{

1166

NOWARN_UNUSED(arg);

1167

TSThread temp_thread = 0;

1168

1169

// TSThreadInit

1170

temp_thread = TSThreadInit();

1171

1172

if (!temp_thread) {

1173

SDK_RPRINT(SDK_ThreadInit_test, "TSThreadInit", "TestCase2", TC_FAIL, "can't init thread");

1174

thread_init_err_count++;

1175

} else

1176

SDK_RPRINT(SDK_ThreadInit_test, "TSThreadInit", "TestCase2", TC_PASS, "ok");

1177

1178

// Clean up this thread

1179

if (temp_thread)

1180

TSThreadDestroy(temp_thread);

1181

1182

if (thread_init_err_count > 0)

1183

*SDK_ThreadInit_pstatus = REGRESSION_TEST_FAILED;

1184

else

1185

*SDK_ThreadInit_pstatus = REGRESSION_TEST_PASSED;

1186

1187

return NULL;

1188

}

1189

1190

REGRESSION_TEST(SDK_API_TSThreadInit) (RegressionTest * test, int atype, int *pstatus)

1191

{

1192

NOWARN_UNUSED(atype);

1193

*pstatus = REGRESSION_TEST_INPROGRESS;

1194

SDK_ThreadInit_test = test;

1195

SDK_ThreadInit_pstatus = pstatus;

1196

1197

pthread_t curr_tid, new_tid;

1198

1199

curr_tid = pthread_self();

1200

1201

int ret;

1202

errno = 0;

1203

ret = pthread_create(&new_tid, NULL, pthread_start_func, (void *) curr_tid);

1204

if (ret != 0) {

1205

thread_init_err_count++;

1206

SDK_RPRINT(test, "TSThreadInit", "TestCase1", TC_FAIL, "can't create pthread");

1207

} else

1208

SDK_RPRINT(test, "TSThreadInit", "TestCase1", TC_PASS, "ok");

1209

1210

}

1211

1212

/* Action */

1213

1214

//////////////////////////////////////////////

1215

// SDK_API_TSAction

1216

1217

// Unit Test for API: TSActionCancel

1218

//////////////////////////////////////////////

1219

1220

static RegressionTest *SDK_ActionCancel_test;

1221

static int *SDK_ActionCancel_pstatus;

1222

1223

int

1224

action_cancel_handler(TSCont contp, TSEvent event, void *edata)

1225

{

1226

NOWARN_UNUSED(edata);

1227

if (event == TS_EVENT_IMMEDIATE) // called from schedule_imm OK

1228

{

1229

SDK_RPRINT(SDK_ActionCancel_test, "TSActionCancel", "TestCase1", TC_PASS, "ok");

1230

*SDK_ActionCancel_pstatus = REGRESSION_TEST_PASSED;

1231

} else if (event == TS_EVENT_TIMEOUT) //called from schedule_in Not OK.

1232

{

1233

SDK_RPRINT(SDK_ActionCancel_test, "TSActionCancel", "TestCase1", TC_FAIL, "bad action");

1234

*SDK_ActionCancel_pstatus = REGRESSION_TEST_FAILED;

1235

} else // there is sth wrong

1236

{

1237

SDK_RPRINT(SDK_ActionCancel_test, "TSActionCancel", "TestCase1", TC_FAIL, "bad event");

1238

*SDK_ActionCancel_pstatus = REGRESSION_TEST_FAILED;

1239

}

1240

1241

TSContDestroy(contp);

1242

return 0;

1243

}

1244

1245

REGRESSION_TEST(SDK_API_TSActionCancel) (RegressionTest * test, int atype, int *pstatus)

1246

{

1247

NOWARN_UNUSED(atype);

1248

*pstatus = REGRESSION_TEST_INPROGRESS;

1249

1250

SDK_ActionCancel_test = test;

1251

SDK_ActionCancel_pstatus = pstatus;

1252

1253

TSMutex cont_mutex = TSMutexCreate();

1254

TSCont contp = TSContCreate(action_cancel_handler, cont_mutex);

1255

TSAction actionp = TSContSchedule(contp, 10000, TS_THREAD_POOL_DEFAULT);

1256

1257

TSMutexLock(cont_mutex);

1258

if (TSActionDone(actionp)) {

1259

*pstatus = REGRESSION_TEST_FAILED;

1260

TSMutexUnlock(cont_mutex);

1261

return;

1262

} else {

1263

TSActionCancel(actionp);

1264

}

1265

TSMutexUnlock(cont_mutex);

1266

1267

TSContSchedule(contp, 0, TS_THREAD_POOL_DEFAULT);

1268

}

1269

1270

//////////////////////////////////////////////

1271

// SDK_API_TSAction

1272

1273

// Unit Test for API: TSActionDone

1274

//////////////////////////////////////////////

1275

/* Currently, don't know how to test it because TSAction

1276

is at "done" status only "shortly" after finish

1277

executing action_done_handler. Another possibility is

1278

to use reentrant call. But in both cases it's not

1279

guaranteed to get ActionDone.

1280

1281

1282

/* Continuations */

1283

1284

//////////////////////////////////////////////

1285

// SDK_API_TSCont

1286

1287

// Unit Test for API: TSContCreate

1288

// TSContCall

1289

//////////////////////////////////////////////

1290

1291

// this is needed for asynchronous APIs

1292

static RegressionTest *SDK_ContCreate_test;

1293

static int *SDK_ContCreate_pstatus;

1294

1295

int

1296

cont_handler(TSCont contp, TSEvent event, void *edata)

1297

{

1298

NOWARN_UNUSED(contp);

1299

NOWARN_UNUSED(event);

1300

NOWARN_UNUSED(edata);

1301

SDK_RPRINT(SDK_ContCreate_test, "TSContCreate", "TestCase1", TC_PASS, "ok");

1302

SDK_RPRINT(SDK_ContCreate_test, "TSContCall", "TestCase1", TC_PASS, "ok");

1303

1304

*SDK_ContCreate_pstatus = REGRESSION_TEST_PASSED;

1305

1306

return 0;

1307

}

1308

1309

1310

REGRESSION_TEST(SDK_API_TSContCreate) (RegressionTest * test, int atype, int *pstatus)

1311

{

1312

NOWARN_UNUSED(atype);

1313

*pstatus = REGRESSION_TEST_INPROGRESS;

1314

1315

// For asynchronous APIs, use static vars to store test and pstatus

1316

SDK_ContCreate_test = test;

1317

SDK_ContCreate_pstatus = pstatus;

1318

1319

TSMutex mutexp = TSMutexCreate();

1320

TSCont contp = TSContCreate(cont_handler, mutexp);

1321

int lock = 0;

1322

1323

TSMutexLockTry(mutexp, &lock);

1324

if (lock) //mutex is grabbed

1325

{

1326

TSContCall(contp, (TSEvent) 0, NULL);

1327

TSMutexUnlock(mutexp);

1328

} else //mutex has problems

1329

{

1330

SDK_RPRINT(SDK_ContCreate_test, "TSContCreate", "TestCase1", TC_FAIL, "continuation creation has problems");

1331

SDK_RPRINT(SDK_ContCreate_test, "TSContCall", "TestCase1", TC_FAIL, "continuation has problems");

1332

1333

*pstatus = REGRESSION_TEST_FAILED;

1334

}

1335

1336

TSContDestroy(contp);

1337

}

1338

1339

1340

//////////////////////////////////////////////

1341

// SDK_API_TSCont

1342

1343

// Unit Test for API: TSContDataGet

1344

// TSContDataSet

1345

//////////////////////////////////////////////

1346

1347

// this is needed for asynchronous APIs

1348

static RegressionTest *SDK_ContData_test;

1349

static int *SDK_ContData_pstatus;

1350

1351

// this is specific for this test

1352

typedef struct

1353

{

1354

int data1;

1355

int data2;

1356

} MyData;

1357

1358

int

1359

cont_data_handler(TSCont contp, TSEvent event, void *edata)

1360

{

1361

NOWARN_UNUSED(event);

1362

NOWARN_UNUSED(edata);

1363

MyData *my_data = (MyData *) TSContDataGet(contp);

1364

1365

if (my_data->data1 == 1 && my_data->data2 == 2) {

1366

SDK_RPRINT(SDK_ContData_test, "TSContDataSet", "TestCase1", TC_PASS, "ok");

1367

SDK_RPRINT(SDK_ContData_test, "TSContDataGet", "TestCase1", TC_PASS, "ok");

1368

1369

*SDK_ContData_pstatus = REGRESSION_TEST_PASSED;

1370

} else {

1371

// If we get bad data, it's a failure

1372

SDK_RPRINT(SDK_ContData_test, "TSContDataSet", "TestCase1", TC_FAIL, "bad data");

1373

SDK_RPRINT(SDK_ContData_test, "TSContDataGet", "TestCase1", TC_FAIL, "bad data");

1374

1375

*SDK_ContData_pstatus = REGRESSION_TEST_FAILED;

1376

}

1377

1378

TSfree(my_data);

1379

TSContDestroy(contp);

1380

return 0;

1381

}

1382

1383

1384

REGRESSION_TEST(SDK_API_TSContDataGet) (RegressionTest * test, int atype, int *pstatus)

1385

{

1386

NOWARN_UNUSED(atype);

1387

*pstatus = REGRESSION_TEST_INPROGRESS;

1388

1389

// For asynchronous APIs, use static vars to store test and pstatus

1390

SDK_ContData_test = test;

1391

SDK_ContData_pstatus = pstatus;

1392

1393

TSCont contp = TSContCreate(cont_data_handler, TSMutexCreate());

1394

1395

MyData *my_data = (MyData *) TSmalloc(sizeof(MyData));

1396

my_data->data1 = 1;

1397

my_data->data2 = 2;

1398

1399

TSContDataSet(contp, (void *) my_data);

1400

1401

TSContSchedule(contp, 0, TS_THREAD_POOL_DEFAULT);

1402

}

1403

1404

1405

1406

//////////////////////////////////////////////

1407

// SDK_API_TSCont

1408

1409

// Unit Test for API: TSContMutexGet

1410

//////////////////////////////////////////////

1411

1412

REGRESSION_TEST(SDK_API_TSContMutexGet) (RegressionTest * test, int atype, int *pstatus)

1413

{

1414

NOWARN_UNUSED(atype);

1415

bool test_passed = false;

1416

*pstatus = REGRESSION_TEST_INPROGRESS;

1417

1418

TSMutex mutexp_input;

1419

TSMutex mutexp_output;

1420

TSCont contp;

1421

1422

mutexp_input = TSMutexCreate();

1423

contp = TSContCreate(cont_handler, mutexp_input);

1424

1425

mutexp_output = TSContMutexGet(contp);

1426

1427

if (mutexp_input == mutexp_output) {

1428

SDK_RPRINT(test, "TSContMutexGet", "TestCase1", TC_PASS, "ok");

1429

test_passed = true;

1430

} else

1431

SDK_RPRINT(test, "TSContMutexGet", "TestCase1", TC_FAIL, "Continutation's mutex corrupted");

1432

1433

// Status of the whole test

1434

*pstatus = ((test_passed == true) ? REGRESSION_TEST_PASSED : REGRESSION_TEST_FAILED);

1435

1436

TSContDestroy(contp);

1437

1438

}

1439

1440

//////////////////////////////////////////////

1441

// SDK_API_TSCont

1442

1443

// Unit Test for API: TSContSchedule

1444

//////////////////////////////////////////////

1445

1446

// this is needed for asynchronous APIs

1447

static RegressionTest *SDK_ContSchedule_test;

1448

static int *SDK_ContSchedule_pstatus;

1449

1450

// this is specific for this test

1451

static int tc1_count = 0;

1452

static int tc2_count = 0;

1453

1454

int

1455

cont_schedule_handler(TSCont contp, TSEvent event, void *edata)

1456

{

1457

NOWARN_UNUSED(edata);

1458

if (event == TS_EVENT_IMMEDIATE) {

1459

// Test Case 1

1460

SDK_RPRINT(SDK_ContSchedule_test, "TSContSchedule", "TestCase1", TC_PASS, "ok");

1461

tc1_count++;

1462

} else if (event == TS_EVENT_TIMEOUT) {

1463

// Test Case 2

1464

SDK_RPRINT(SDK_ContSchedule_test, "TSContSchedule", "TestCase2", TC_PASS, "ok");

1465

tc2_count++;

1466

} else {

1467

// If we receive a bad event, it's a failure

1468

SDK_RPRINT(SDK_ContSchedule_test, "TSContSchedule", "TestCase1|2",

1469

TC_FAIL, "received unexpected event number %d", event);

1470

*SDK_ContSchedule_pstatus = REGRESSION_TEST_FAILED;

1471

return 0;

1472

}

1473

1474

// We expect to be called once for TC1 and once for TC2

1475

if ((tc1_count == 1) && (tc2_count == 1)) {

1476

*SDK_ContSchedule_pstatus = REGRESSION_TEST_PASSED;

1477

}

1478

// If TC1 or TC2 executed more than once, something is fishy..

1479

else if (tc1_count + tc2_count >= 2) {

1480

*SDK_ContSchedule_pstatus = REGRESSION_TEST_FAILED;

1481

}

1482

1483

TSContDestroy(contp);

1484

return 0;

1485

}

1486

1487

/* Mutex */

1488

1489

1490

Fix me: test for grabbing the mutex from two

1491

different threads.

1492

1493

1494

//////////////////////////////////////////////

1495

// SDK_API_TSMutex

1496

1497

// Unit Test for API: TSMutexCreate

1498

// TSMutexLock

1499

// TSMutexUnLock

1500

//////////////////////////////////////////////

1501

1502

REGRESSION_TEST(SDK_API_TSMutexCreate) (RegressionTest * test, int atype, int *pstatus)

1503

{

1504

NOWARN_UNUSED(atype);

1505

bool test_passed = false;

1506

*pstatus = REGRESSION_TEST_INPROGRESS;

1507

1508

TSMutex mutexp = TSMutexCreate();

1509

1510

TSMutexLock(mutexp);

1511

1512

/* This is normal because all locking is from the same thread */

1513

int lock = 0;

1514

1515

TSMutexLockTry(mutexp, &lock);

1516

TSMutexLockTry(mutexp, &lock);

1517

1518

if (lock) {

1519

SDK_RPRINT(test, "TSMutexCreate", "TestCase1", TC_PASS, "ok");

1520

SDK_RPRINT(test, "TSMutexLock", "TestCase1", TC_PASS, "ok");

1521

SDK_RPRINT(test, "TSMutexLockTry", "TestCase1", TC_PASS, "ok");

1522

test_passed = true;

1523

} else {

1524

SDK_RPRINT(test, "TSMutexCreate", "TestCase1", TC_FAIL, "mutex can't be grabbed twice from the same thread");

1525

SDK_RPRINT(test, "TSMutexLock", "TestCase1", TC_FAIL, "mutex can't be grabbed twice from the same thread");

1526

SDK_RPRINT(test, "TSMutexLockTry", "TestCase1", TC_FAIL, "mutex can't be grabbed twice from the same thread");

1527

1528

}

1529

1530

TSMutexUnlock(mutexp);

1531

SDK_RPRINT(test, "TSMutexUnLock", "TestCase1", TC_PASS, "ok");

1532

1533

if (test_passed) {

1534

*pstatus = REGRESSION_TEST_PASSED;

1535

} else {

1536

*pstatus = REGRESSION_TEST_FAILED;

1537

}

1538

1539

}

1540

1541

/* IOBuffer */

1542

1543

//////////////////////////////////////////////

1544

// SDK_API_TSIOBuffer

1545

1546

// Unit Test for API: TSIOBufferCreate

1547

// TSIOBufferWaterMarkGet

1548

// TSIOBufferWaterMarkSet

1549

//////////////////////////////////////////////

1550

1551

REGRESSION_TEST(SDK_API_TSIOBufferCreate) (RegressionTest * test, int atype, int *pstatus)

1552

{

1553

NOWARN_UNUSED(atype);

1554

bool test_passed = false;

1555

*pstatus = REGRESSION_TEST_INPROGRESS;

1556

1557

int64_t watermark = 1000;

1558

1559

TSIOBuffer bufp = TSIOBufferCreate();

1560

1561

TSIOBufferWaterMarkSet(bufp, watermark);

1562

1563

watermark = 0;

1564

TSIOBufferWaterMarkGet(bufp, &watermark);

1565

1566

if (watermark == 1000) {

1567

SDK_RPRINT(test, "TSIOBufferCreate", "TestCase1", TC_PASS, "ok");

1568

SDK_RPRINT(test, "TSIOBufferWaterMarkGet", "TestCase1", TC_PASS, "ok");

1569

SDK_RPRINT(test, "TSIOBufferWaterMarkSet", "TestCase1", TC_PASS, "ok");

1570

test_passed = true;

1571

} else {

1572

SDK_RPRINT(test, "TSIOBufferCreate", "TestCase1", TC_FAIL, "watermark failed");

1573

SDK_RPRINT(test, "TSIOBufferWaterMarkGet", "TestCase1", TC_FAIL, "watermark failed");

1574

SDK_RPRINT(test, "TSIOBufferWaterMarkSet", "TestCase1", TC_FAIL, "watermark failed");

1575

}

1576

1577

TSIOBufferDestroy(bufp);

1578

1579

// Status of the whole test

1580

*pstatus = ((test_passed == true) ? REGRESSION_TEST_PASSED : REGRESSION_TEST_FAILED);

1581

return;

1582

1583

}

1584

1585

1586

//////////////////////////////////////////////

1587

// SDK_API_TSIOBuffer

1588

1589

// Unit Test for API: TSIOBufferSizedCreate

1590

// TSIOBufferProduce

1591

// TSIOBufferReaderAlloc

1592

// TSIOBufferReaderAvail

1593

//////////////////////////////////////////////

1594

1595

REGRESSION_TEST(SDK_API_TSIOBufferProduce) (RegressionTest * test, int atype, int *pstatus)

1596

{

1597

NOWARN_UNUSED(atype);

1598

bool test_passed = false;

1599

*pstatus = REGRESSION_TEST_INPROGRESS;

1600

1601

TSIOBuffer bufp = TSIOBufferSizedCreate(TS_IOBUFFER_SIZE_INDEX_4K); //size is 4096

1602

1603

TSIOBufferReader readerp = TSIOBufferReaderAlloc(bufp);

1604

1605

TSIOBufferProduce(bufp, 10);

1606

1607

int64_t reader_avail = TSIOBufferReaderAvail(readerp);

1608

if (reader_avail == 10) {

1609

SDK_RPRINT(test, "TSIOBufferProduce", "TestCase1", TC_PASS, "ok");

1610

SDK_RPRINT(test, "TSIOBufferReaderAlloc", "TestCase1", TC_PASS, "ok");

1611

SDK_RPRINT(test, "TSIOBufferReaderAvail", "TestCase1", TC_PASS, "ok");

1612

test_passed = true;

1613

} else {

1614

SDK_RPRINT(test, "TSIOBufferProduce", "TestCase1", TC_FAIL, "failed");

1615

SDK_RPRINT(test, "TSIOBufferReaderAlloc", "TestCase1", TC_FAIL, "failed");

1616

SDK_RPRINT(test, "TSIOBufferReaderAvail", "TestCase1", TC_FAIL, "failed");

1617

}

1618

1619

// Status of the whole test

1620

*pstatus = ((test_passed == true) ? REGRESSION_TEST_PASSED : REGRESSION_TEST_FAILED);

1621

return;

1622

}

1623

1624

1625

//////////////////////////////////////////////

1626

// SDK_API_TSIOBuffer

1627

1628

// Unit Test for API: TSIOBufferReaderConsume

1629

//////////////////////////////////////////////

1630

1631

REGRESSION_TEST(SDK_API_TSIOBufferReaderConsume) (RegressionTest * test, int atype, int *pstatus)

1632

{

1633

NOWARN_UNUSED(atype);

1634

bool test_passed = false;

1635

*pstatus = REGRESSION_TEST_INPROGRESS;

1636

1637

TSIOBuffer bufp = TSIOBufferSizedCreate(TS_IOBUFFER_SIZE_INDEX_4K);

1638

1639

TSIOBufferReader readerp = TSIOBufferReaderAlloc(bufp);

1640

1641

TSIOBufferProduce(bufp, 10);

1642

TSIOBufferReaderConsume(readerp, 10);

1643

1644

int64_t reader_avail = TSIOBufferReaderAvail(readerp);

1645

if (reader_avail == 0) {

1646

SDK_RPRINT(test, "TSIOBufferReaderConsume", "TestCase1", TC_PASS, "ok");

1647

test_passed = true;

1648

} else {

1649

SDK_RPRINT(test, "TSIOBufferReaderConsume", "TestCase1", TC_FAIL, "failed");

1650

}

1651

1652

// Status of the whole test

1653

*pstatus = ((test_passed == true) ? REGRESSION_TEST_PASSED : REGRESSION_TEST_FAILED);

1654

return;

1655

}

1656

1657

//////////////////////////////////////////////

1658

// SDK_API_TSIOBuffer

1659

1660

// Unit Test for API: TSIOBufferReaderClone

1661

//////////////////////////////////////////////

1662

1663

REGRESSION_TEST(SDK_API_TSIOBufferReaderClone) (RegressionTest * test, int atype, int *pstatus)

1664

{

1665

NOWARN_UNUSED(atype);

1666

bool test_passed = false;

1667

*pstatus = REGRESSION_TEST_INPROGRESS;

1668

1669

TSIOBuffer bufp = TSIOBufferSizedCreate(TS_IOBUFFER_SIZE_INDEX_4K);

1670

1671

TSIOBufferReader readerp = TSIOBufferReaderAlloc(bufp);

1672

1673

TSIOBufferProduce(bufp, 10);

1674

TSIOBufferReaderConsume(readerp, 5);

1675

1676

TSIOBufferReader readerp2 = TSIOBufferReaderClone(readerp);

1677

1678

int64_t reader_avail = TSIOBufferReaderAvail(readerp2);

1679

if (reader_avail == 5) {

1680

SDK_RPRINT(test, "TSIOBufferReaderClone", "TestCase1", TC_PASS, "ok");

1681

test_passed = true;

1682

} else {

1683

SDK_RPRINT(test, "TSIOBufferReaderClone", "TestCase1", TC_FAIL, "failed");

1684

}

1685

1686

// Status of the whole test

1687

*pstatus = ((test_passed == true) ? REGRESSION_TEST_PASSED : REGRESSION_TEST_FAILED);

1688

return;

1689

}

1690

1691

//////////////////////////////////////////////

1692

// SDK_API_TSIOBuffer

1693

1694

// Unit Test for API: TSIOBufferStart

1695

// TSIOBufferReaderStart

1696

//////////////////////////////////////////////

1697

1698

REGRESSION_TEST(SDK_API_TSIOBufferStart) (RegressionTest * test, int atype, int *pstatus)

1699

{

1700

NOWARN_UNUSED(atype);

1701

bool test_passed = false;

1702

*pstatus = REGRESSION_TEST_INPROGRESS;

1703

1704

TSIOBuffer bufp = TSIOBufferSizedCreate(TS_IOBUFFER_SIZE_INDEX_4K);

1705

1706

TSIOBufferReader readerp = TSIOBufferReaderAlloc(bufp);

1707

1708

if (TSIOBufferStart(bufp) == TSIOBufferReaderStart(readerp)) {

1709

SDK_RPRINT(test, "TSIOBufferStart", "TestCase1", TC_PASS, "ok");

1710

SDK_RPRINT(test, "TSIOBufferReaderStart", "TestCase1", TC_PASS, "ok");

1711

test_passed = true;

1712

} else {

1713

SDK_RPRINT(test, "TSIOBufferStart", "TestCase1", TC_FAIL, "failed");

1714

SDK_RPRINT(test, "TSIOBufferReaderStart", "TestCase1", TC_FAIL, "failed");

1715

}

1716

1717

// Status of the whole test

1718

*pstatus = ((test_passed == true) ? REGRESSION_TEST_PASSED : REGRESSION_TEST_FAILED);

1719

return;

1720

}

1721

1722

1723

//////////////////////////////////////////////

1724

// SDK_API_TSIOBuffer

1725

1726

// Unit Test for API: TSIOBufferCopy

1727

// TSIOBufferWrite

1728

// TSIOBufferReaderCopy

1729

//////////////////////////////////////////////

1730

1731

REGRESSION_TEST(SDK_API_TSIOBufferCopy) (RegressionTest * test, int atype, int *pstatus)

1732

{

1733

NOWARN_UNUSED(atype);

1734

bool test_passed = false;

1735

*pstatus = REGRESSION_TEST_INPROGRESS;

1736

1737

char input_buf[] = "This is the test for TSIOBufferCopy, TSIOBufferWrite, TSIOBufferReaderCopy";

1738

char output_buf[1024];

1739

TSIOBuffer bufp = TSIOBufferSizedCreate(TS_IOBUFFER_SIZE_INDEX_4K);

1740

TSIOBuffer bufp2 = TSIOBufferSizedCreate(TS_IOBUFFER_SIZE_INDEX_4K);

1741

1742

TSIOBufferReader readerp = TSIOBufferReaderAlloc(bufp);

1743

TSIOBufferWrite(bufp, input_buf, (strlen(input_buf) + 1));

1744

TSIOBufferCopy(bufp2, readerp, (strlen(input_buf) + 1), 0);

1745

TSIOBufferReaderCopy(readerp, output_buf, (strlen(input_buf) + 1));

1746

1747

if (strcmp(input_buf, output_buf) == 0) {

1748

SDK_RPRINT(test, "TSIOBufferWrite", "TestCase1", TC_PASS, "ok");

1749

SDK_RPRINT(test, "TSIOBufferCopy", "TestCase1", TC_PASS, "ok");

1750

SDK_RPRINT(test, "TSIOBufferReaderCopy", "TestCase1", TC_PASS, "ok");

1751

test_passed = true;

1752

} else {

1753

SDK_RPRINT(test, "TSIOBufferWrite", "TestCase1", TC_FAIL, "failed");

1754

SDK_RPRINT(test, "TSIOBufferCopy", "TestCase1", TC_FAIL, "failed");

1755

SDK_RPRINT(test, "TSIOBufferReaderCopy", "TestCase1", TC_FAIL, "failed");

1756

}

1757

1758

// Status of the whole test

1759

*pstatus = ((test_passed == true) ? REGRESSION_TEST_PASSED : REGRESSION_TEST_FAILED);

1760

return;

1761

}

1762

1763

//////////////////////////////////////////////

1764

// SDK_API_TSIOBuffer

1765

1766

// Unit Test for API: TSIOBuffer

1767

// TSIOBufferWrite

1768

// TSIOBufferReaderCopy

1769

//////////////////////////////////////////////

1770

1771

REGRESSION_TEST(SDK_API_TSIOBufferBlockReadAvail) (RegressionTest * test, int atype, int *pstatus)

1772

{

1773

NOWARN_UNUSED(atype);

1774

bool test_passed_1 = false;

1775

bool test_passed_2 = false;

1776

*pstatus = REGRESSION_TEST_INPROGRESS;

1777

1778

int i = 10000;

1779

TSIOBuffer bufp = TSIOBufferCreate();

1780

TSIOBufferWrite(bufp, (char*)&i, sizeof(int));

1781

TSIOBufferReader readerp = TSIOBufferReaderAlloc(bufp);

1782

1783

int64_t avail_write, avail_read;

1784

1785

// TODO: This is probably not correct any more.

1786

TSIOBufferBlock blockp = TSIOBufferStart(bufp);

1787

1788

if ((TSIOBufferBlockWriteStart(blockp, &avail_write) - TSIOBufferBlockReadStart(blockp, readerp, &avail_read)) ==

1789

sizeof(int)) {

1790

SDK_RPRINT(test, "TSIOBufferBlockReadStart", "TestCase1", TC_PASS, "ok");

1791

SDK_RPRINT(test, "TSIOBufferBlockWriteStart", "TestCase1", TC_PASS, "ok");

1792

test_passed_1 = true;

1793

} else {

1794

SDK_RPRINT(test, "TSIOBufferBlockReadStart", "TestCase1", TC_FAIL, "failed");

1795

SDK_RPRINT(test, "TSIOBufferBlockWriteStart", "TestCase1", TC_FAIL, "failed");

1796

}

1797

1798

if ((TSIOBufferBlockReadAvail(blockp, readerp) + TSIOBufferBlockWriteAvail(blockp)) == 4096) {

1799

SDK_RPRINT(test, "TSIOBufferBlockReadAvail", "TestCase1", TC_PASS, "ok");

1800

SDK_RPRINT(test, "TSIOBufferBlockWriteAvail", "TestCase1", TC_PASS, "ok");

1801

test_passed_2 = true;

1802

} else {

1803

SDK_RPRINT(test, "TSIOBufferBlockReadAvail", "TestCase1", TC_FAIL, "failed");

1804

SDK_RPRINT(test, "TSIOBufferBlockWriteAvail", "TestCase1", TC_FAIL, "failed");

1805

}

1806

1807

if (test_passed_1 && test_passed_2) {

1808

*pstatus = REGRESSION_TEST_PASSED;

1809

} else {

1810

*pstatus = REGRESSION_TEST_FAILED;

1811

}

1812

1813

return;

1814

}

1815

1816

//////////////////////////////////////////////////

1817

// SDK_API_TSIOBuffer

1818

1819

// Unit Test for API: TSIOBufferBlockNext

1820

//////////////////////////////////////////////////

1821

1822

REGRESSION_TEST(SDK_API_TSIOBufferBlockNext) (RegressionTest * test, int atype, int *pstatus)

1823

{

1824

NOWARN_UNUSED(atype);

1825

bool test_passed = false;

1826

*pstatus = REGRESSION_TEST_INPROGRESS;

1827

1828

int i = 10000;

1829

TSIOBuffer bufp = TSIOBufferCreate();

1830

TSIOBufferWrite(bufp, (char*)&i, sizeof(int));

1831

1832

TSIOBufferReader readerp = TSIOBufferReaderAlloc(bufp);

1833

TSIOBufferBlock blockp = TSIOBufferReaderStart(readerp);

1834

1835

// TODO: This is probaby not the best of regression tests right now ...

1836

// Note that this assumes block size is > sizeof(int) bytes.

1837

if (TSIOBufferBlockNext(blockp) == NULL) {

1838

SDK_RPRINT(test, "TSIOBufferBlockNext", "TestCase1", TC_PASS, "ok");

1839

test_passed = true;

1840

} else {

1841

SDK_RPRINT(test, "TSIOBufferBlockNext", "TestCase1", TC_FAIL, "fail");

1842

}

1843

1844

if (test_passed) {

1845

*pstatus = REGRESSION_TEST_PASSED;

1846

} else {

1847

*pstatus = REGRESSION_TEST_FAILED;

1848

}

1849

1850

return;

1851

}

1852

1853

1854

1855

/* Stats */

1856

1857

//////////////////////////////////////////////

1858

// SDK_API_INKStat

1859

1860

// Unit Test for API: INKStatCreate

1861

// INKStatIntSet

1862

//////////////////////////////////////////////

1863

1864

REGRESSION_TEST(SDK_API_INKStatIntSet) (RegressionTest * test, int atype, int *pstatus)

1865

{

1866

NOWARN_UNUSED(atype);

1867

bool test_passed = false;

1868

*pstatus = REGRESSION_TEST_INPROGRESS;

1869

1870

INKStat stat = INKStatCreate("stat_is", INKSTAT_TYPE_INT64);

1871

1872

INKStatIntSet(stat, 100);

1873

int64_t stat_val;

1874

1875

INKStatIntGet(stat, &stat_val);

1876

1877

if (stat_val == 100) {

1878

SDK_RPRINT(test, "INKStatIntSet", "TestCase1", TC_PASS, "ok");

1879

test_passed = true;

1880

} else {

1881

SDK_RPRINT(test, "INKStatIntSet", "TestCase1", TC_FAIL, "can't set to correct integer value");

1882

}

1883

1884

// Status of the whole test

1885

*pstatus = ((test_passed == true) ? REGRESSION_TEST_PASSED : REGRESSION_TEST_FAILED);

1886

1887

}

1888

1889

//////////////////////////////////////////////

1890

// SDK_API_INKStat

1891

1892

// Unit Test for API: INKStatIntAddTo

1893

//////////////////////////////////////////////

1894

1895

REGRESSION_TEST(SDK_API_INKStatIntAddTo) (RegressionTest * test, int atype, int *pstatus)

1896

{

1897

NOWARN_UNUSED(atype);

1898

bool test_passed = false;

1899

*pstatus = REGRESSION_TEST_INPROGRESS;

1900

1901

INKStat stat = INKStatCreate("stat_ia", INKSTAT_TYPE_INT64);

1902

1903

INKStatIntAddTo(stat, 100);

1904

int64_t stat_val;

1905

1906

INKStatIntGet(stat, &stat_val);

1907

1908

if (stat_val == 100) {

1909

SDK_RPRINT(test, "INKStatIntAddTo", "TestCase1", TC_PASS, "ok");

1910

test_passed = true;

1911

} else {

1912

SDK_RPRINT(test, "INKStatIntAddTo", "TestCase1", TC_FAIL, "can't add to correct integer value");

1913

}

1914

1915

// Status of the whole test

1916

*pstatus = ((test_passed == true) ? REGRESSION_TEST_PASSED : REGRESSION_TEST_FAILED);

1917

1918

}

1919

1920

//////////////////////////////////////////////

1921

// SDK_API_INKStat

1922

1923

// Unit Test for API: INKStatFloatAddTo

1924

// INKStatFloatGet

1925

//////////////////////////////////////////////

1926

1927

REGRESSION_TEST(SDK_API_INKStatFloatAddTo) (RegressionTest * test, int atype, int *pstatus)

1928

{

1929

NOWARN_UNUSED(atype);

1930

bool test_passed = false;

1931

*pstatus = REGRESSION_TEST_INPROGRESS;

1932

1933

INKStat stat = INKStatCreate("stat_fa", INKSTAT_TYPE_FLOAT);

1934

1935

INKStatFloatAddTo(stat, 100.0);

1936

float stat_val;

1937

INKStatFloatGet(stat, &stat_val);

1938

1939

if (stat_val == 100.0) {

1940

SDK_RPRINT(test, "INKStatFloatAddTo", "TestCase1", TC_PASS, "ok");

1941

test_passed = true;

1942

} else {

1943

SDK_RPRINT(test, "INKStatFloatAddTo", "TestCase1", TC_FAIL, "can't add to correct float value");

1944

}

1945

1946

// Status of the whole test

1947

*pstatus = ((test_passed == true) ? REGRESSION_TEST_PASSED : REGRESSION_TEST_FAILED);

1948

1949

}

1950

1951

//////////////////////////////////////////////

1952

// SDK_API_INKStat

1953

1954

// Unit Test for API: INKStatFloatSet

1955

//////////////////////////////////////////////

1956

1957

REGRESSION_TEST(SDK_API_INKStatFloatSet) (RegressionTest * test, int atype, int *pstatus)

1958

{

1959

NOWARN_UNUSED(atype);

1960

bool test_passed = false;

1961

*pstatus = REGRESSION_TEST_INPROGRESS;

1962

1963

INKStat stat = INKStatCreate("stat_fs", INKSTAT_TYPE_FLOAT);

1964

1965

INKStatFloatSet(stat, 100.0);

1966

float stat_val;

1967

INKStatFloatGet(stat, &stat_val);

1968

1969

if (stat_val == 100.0) {

1970

SDK_RPRINT(test, "INKStatFloatSet", "TestCase1", TC_PASS, "ok");

1971

test_passed = true;

1972

} else {

1973

SDK_RPRINT(test, "INKStatFloatSet", "TestCase1", TC_FAIL, "can't set to correct float value");

1974

}

1975

1976

// Status of the whole test

1977

*pstatus = ((test_passed == true) ? REGRESSION_TEST_PASSED : REGRESSION_TEST_FAILED);

1978

1979

}

1980

1981

//////////////////////////////////////////////

1982

// SDK_API_INKStat

1983

1984

// Unit Test for API: INKStatIncrement

1985

// INKStatDecrement

1986

//////////////////////////////////////////////

1987

1988

REGRESSION_TEST(SDK_API_INKStatIncrement) (RegressionTest * test, int atype, int *pstatus)

1989

{

1990

NOWARN_UNUSED(atype);

1991

bool test_passed_int_increase = false;

1992

bool test_passed_int_decrease = false;

1993

bool test_passed_float_increase = false;

1994

bool test_passed_float_decrease = false;

1995

*pstatus = REGRESSION_TEST_INPROGRESS;

1996

1997

INKStat stat_1 = INKStatCreate("stat_1", INKSTAT_TYPE_INT64);

1998

INKStat stat_2 = INKStatCreate("stat_2", INKSTAT_TYPE_FLOAT);

1999

2000

INKStatIncrement(stat_1);

2001

int64_t stat1_val;

2002

INKStatIntGet(stat_1, &stat1_val);

2003

2004

if (stat1_val == 1) {

2005

SDK_RPRINT(test, "INKStatIncrement", "TestCase1", TC_PASS, "ok for int stat");

2006

test_passed_int_increase = true;

2007

} else {

2008

SDK_RPRINT(test, "INKStatIncrement", "TestCase1", TC_FAIL, "can't increase to correct integer value");

2009

}

2010

2011

INKStatDecrement(stat_1);

2012

INKStatIntGet(stat_1, &stat1_val);

2013

2014

if (stat1_val == 0) {

2015

SDK_RPRINT(test, "INKStatDecrement", "TestCase1", TC_PASS, "ok for int stat");

2016

test_passed_int_decrease = true;

2017

} else {

2018

SDK_RPRINT(test, "INKStatDecrement", "TestCase1", TC_FAIL, "can't decrease to correct integer value");

2019

}

2020

2021

INKStatIncrement(stat_2);

2022

float stat2_val;

2023

INKStatFloatGet(stat_2, &stat2_val);

2024

2025

if (stat2_val == 1.0) {

2026

SDK_RPRINT(test, "INKStatIncrement", "TestCase2", TC_PASS, "ok for float stat");

2027

test_passed_float_increase = true;

2028

} else {

2029

char message[80];

2030

snprintf(message, sizeof(message), "can't increase to correct float value (1.0 != %.3f)", stat2_val);

2031

SDK_RPRINT(test, "INKStatIncrement", "TestCase2", TC_FAIL, &message[0]);

2032

}

2033

2034

INKStatDecrement(stat_2);

2035

INKStatFloatGet(stat_2, &stat2_val);

2036

2037

if (stat2_val == 0.0) {

2038

SDK_RPRINT(test, "INKStatDecrement", "TestCase2", TC_PASS, "ok for float stat");

2039

test_passed_float_decrease = true;

2040

} else {

2041

SDK_RPRINT(test, "INKStatDecrement", "TestCase2", TC_FAIL, "can't decrease to correct float value");

2042

}

2043

2044

// Status of the whole test

2045

if (test_passed_int_increase && test_passed_int_decrease && test_passed_float_increase && test_passed_float_decrease)

2046

*pstatus = REGRESSION_TEST_PASSED;

2047

else

2048

*pstatus = REGRESSION_TEST_FAILED;

2049

2050

}

2051

2052

////////////////////////////////////////////////////

2053

// SDK_API_INKCoupledStat

2054

2055

// Unit Test for API: INKStatCoupledGlobalCategoryCreate

2056

// INKStatCoupledLoacalCopyCreate

2057

// INKStatCoupledLoacalCopyDestroy

2058

// INKStatCoupledGlobalAdd

2059

// INKStatCoupledLocalAdd

2060

// INKStatsCoupledUpdate

2061

////////////////////////////////////////////////////

2062

2063

REGRESSION_TEST(SDK_API_INKStatCoupled) (RegressionTest * test, int atype, int *pstatus)

2064

{

2065

NOWARN_UNUSED(atype);

2066

*pstatus = REGRESSION_TEST_INPROGRESS;

2067

2068

/* Create global category and its stats */

2069

INKCoupledStat stat_global_category = INKStatCoupledGlobalCategoryCreate("global.category");

2070

2071

INKStat global_stat_sum = INKStatCoupledGlobalAdd(stat_global_category,

2072

"global.statsum",

2073

INKSTAT_TYPE_FLOAT);

2074

2075

INKStat global_stat_1 = INKStatCoupledGlobalAdd(stat_global_category,

2076

"global.stat1",

2077

INKSTAT_TYPE_INT64);

2078

2079

INKStat global_stat_2 = INKStatCoupledGlobalAdd(stat_global_category,

2080

"global.stat2",

2081

INKSTAT_TYPE_INT64);

2082

2083

/* Create local category and its stats */

2084

INKCoupledStat stat_local_copy = INKStatCoupledLocalCopyCreate("local.copy",

2085

stat_global_category);

2086

2087

INKStat local_stat_sum = INKStatCoupledLocalAdd(stat_local_copy,

2088

"local.statsum",

2089

INKSTAT_TYPE_FLOAT);

2090

2091

INKStat local_stat_1 = INKStatCoupledLocalAdd(stat_local_copy,

2092

"local.stat1",

2093

INKSTAT_TYPE_INT64);

2094

2095

INKStat local_stat_2 = INKStatCoupledLocalAdd(stat_local_copy,

2096

"local.stat2",

2097

INKSTAT_TYPE_INT64);

2098

2099

/* stat operation */

2100

INKStatIntSet(local_stat_1, 100);

2101

INKStatIntSet(local_stat_2, 100);

2102

float local_val_1;

2103

INKStatFloatGet(local_stat_1, &local_val_1);

2104

float local_val_2;

2105

INKStatFloatGet(local_stat_2, &local_val_2);

2106

2107

INKStatFloatAddTo(local_stat_sum, local_val_1);

2108

INKStatFloatAddTo(local_stat_sum, local_val_2);

2109

float local_val_sum;

2110

INKStatFloatGet(local_stat_sum, &local_val_sum);

2111

2112

INKStatsCoupledUpdate(stat_local_copy);

2113

INKStatCoupledLocalCopyDestroy(stat_local_copy);

2114

2115

float global_val_sum;

2116

INKStatFloatGet(global_stat_sum, &global_val_sum);

2117

int64_t global_val_1;

2118

INKStatIntGet(global_stat_1, &global_val_1);

2119

int64_t global_val_2;

2120

INKStatIntGet(global_stat_2, &global_val_2);

2121

2122

if (local_val_1 == global_val_1 && local_val_2 == global_val_2 && local_val_sum == global_val_sum) {

2123

SDK_RPRINT(test, "INKStatCoupledGlobalCategoryCreate", "TestCase1", TC_PASS, "ok");

2124

SDK_RPRINT(test, "INKStatCoupledGlobalAdd", "TestCase1", TC_PASS, "ok");

2125

SDK_RPRINT(test, "INKStatCoupledLocalCopyCreate", "TestCase1", TC_PASS, "ok");

2126

SDK_RPRINT(test, "INKStatCoupledLocalAdd", "TestCase1", TC_PASS, "ok");

2127

SDK_RPRINT(test, "INKStatCoupledLocalCopyDestroy", "TestCase1", TC_PASS, "ok");

2128

SDK_RPRINT(test, "INKStatCoupledUpdate", "TestCase1", TC_PASS, "ok");

2129

*pstatus = REGRESSION_TEST_PASSED;

2130

} else {

2131

SDK_RPRINT(test, "INKStatCoupledGlobalCategoryCreate", "TestCase1", TC_FAIL,

2132

"global stats' value is not equal to local one");

2133

SDK_RPRINT(test, "INKStatCoupledGlobalAdd", "TestCase1", TC_FAIL, "global stats' value is not equal to local one");

2134

SDK_RPRINT(test, "INKStatCoupledLocalCopyCreate", "TestCase1", TC_FAIL,

2135

"global stats' value is not equal to local one");

2136

SDK_RPRINT(test, "INKStatCoupledLocalAdd", "TestCase1", TC_FAIL, "global stats' value is not equal to local one");

2137

SDK_RPRINT(test, "INKStatCoupledLocalCopyDestroy", "TestCase1", TC_FAIL,

2138

"global stats' value is not equal to local one");

2139

SDK_RPRINT(test, "INKStatCoupledUpdate", "TestCase1", TC_FAIL, "global stats' value is not equal to local one");

2140

2141

*pstatus = REGRESSION_TEST_FAILED;

2142

}

2143

}

2144

2145

2146

REGRESSION_TEST(SDK_API_TSContSchedule) (RegressionTest * test, int atype, int *pstatus)

2147

{

2148

NOWARN_UNUSED(atype);

2149

*pstatus = REGRESSION_TEST_INPROGRESS;

2150

2151

// For asynchronous APIs, use static vars to store test and pstatus

2152

SDK_ContSchedule_test = test;

2153

SDK_ContSchedule_pstatus = pstatus;

2154

2155

TSCont contp = TSContCreate(cont_schedule_handler, TSMutexCreate());

2156

TSCont contp2 = TSContCreate(cont_schedule_handler, TSMutexCreate());

2157

2158

// Test Case 1: schedule immediate

2159

TSContSchedule(contp, 0, TS_THREAD_POOL_DEFAULT);

2160

2161

// Test Case 2: schedule in 10ms

2162

TSContSchedule(contp2, 10, TS_THREAD_POOL_DEFAULT);

2163

}

2164

2165

//////////////////////////////////////////////////////////////////////////////

2166

// SDK_API_HttpHookAdd

2167

2168

// Unit Test for API: TSHttpHookAdd

2169

// TSHttpTxnReenable

2170

// TSHttpTxnClientIPGet

2171

// TSHttpTxnServerIPGet

2172

// TSHttpTxnClientIncomingPortGet

2173

// TSHttpTxnClientRemotePortGet

2174

// TSHttpTxnClientReqGet

2175

// TSHttpTxnClientRespGet

2176

// TSHttpTxnServerReqGet

2177

// TSHttpTxnServerRespGet

2178

//////////////////////////////////////////////////////////////////////////////

2179

2180

#define HTTP_HOOK_TEST_REQUEST_ID 1

2181

2182

typedef struct

2183

{

2184

RegressionTest *regtest;

2185

int *pstatus;

2186

SocketServer *os;

2187

ClientTxn *browser;

2188

int hook_mask;

2189

int reenable_mask;

2190

bool test_client_ip_get;

2191

bool test_client_incoming_port_get;

2192

bool test_client_remote_port_get;

2193

bool test_client_req_get;

2194

bool test_client_resp_get;

2195

bool test_server_ip_get;

2196

bool test_server_req_get;

2197

bool test_server_resp_get;

2198

bool test_next_hop_ip_get;

2199

2200

unsigned int magic;

2201

} SocketTest;

2202

2203

2204

//This func is called by us from mytest_handler to test TSHttpTxnClientIPGet

2205

static int

2206

checkHttpTxnClientIPGet(SocketTest * test, void *data)

2207

{

2208

2209

int ip;

2210

TSHttpTxn txnp = (TSHttpTxn) data;

2211

int actual_ip = LOCAL_IP; /* 127.0.0.1 is expected because the client is on the same machine */

2212

2213

ip = TSHttpTxnClientIPGet(txnp);

2214

if (ip == 0) {

2215

test->test_client_ip_get = false;

2216

SDK_RPRINT(test->regtest, "TSHttpTxnClientIPGet", "TestCase1", TC_FAIL, "TSHttpTxnClientIPGet returns 0");

2217

return TS_EVENT_CONTINUE;

2218

}

2219

2220

if (ntohl(ip) == (uint32_t) actual_ip) {

2221

test->test_client_ip_get = true;

2222

SDK_RPRINT(test->regtest, "TSHttpTxnClientIPGet", "TestCase1", TC_PASS, "ok");

2223

} else {

2224

test->test_client_ip_get = false;

2225

SDK_RPRINT(test->regtest, "TSHttpTxnClientIPGet", "TestCase1", TC_FAIL, "Value's Mismatch");

2226

}

2227

return TS_EVENT_CONTINUE;

2228

2229

}

2230

2231

//This func is called by us from mytest_handler to check for TSHttpTxnNextHopIPGet

2232

static int

2233

checkHttpTxnNextHopIPGet(SocketTest * test, void *data)

2234

{

2235

TSHttpTxn txnp = (TSHttpTxn) data;

2236

int actual_ip = LOCAL_IP; /* 127.0.0.1 is expected because the client is on the same machine */

2237

int nexthopip;

2238

2239

nexthopip = TSHttpTxnNextHopIPGet(txnp);

2240

if (nexthopip == 0) {

2241

test->test_next_hop_ip_get = false;

2242

SDK_RPRINT(test->regtest, "TSHttpTxnNextHopIPGet", "TestCase1", TC_FAIL, "TSHttpTxnNextHopIPGet returns 0");

2243

return TS_EVENT_CONTINUE;

2244

}

2245

2246

if (ntohl(nexthopip) == (uint32_t) actual_ip) {

2247

test->test_next_hop_ip_get = true;

2248

SDK_RPRINT(test->regtest, "TSHttpTxnNextHopIPGet", "TestCase1", TC_PASS, "ok");

2249

} else {

2250

test->test_next_hop_ip_get = false;

2251

SDK_RPRINT(test->regtest, "TSHttpTxnNextHopIPGet", "TestCase1", TC_FAIL, "Value's Mismatch");

2252

}

2253

2254

return TS_EVENT_CONTINUE;

2255

}

2256

2257

2258

2259

//This func is called by us from mytest_handler to test TSHttpTxnServerIPGet

2260

static int

2261

checkHttpTxnServerIPGet(SocketTest * test, void *data)

2262

{

2263

2264

int ip;

2265

TSHttpTxn txnp = (TSHttpTxn) data;

2266

int actual_ip = ntohl(LOCAL_IP); /* 127.0.0.1 is expected because the client is on the same machine */

2267

2268

ip = TSHttpTxnServerIPGet(txnp);

2269

if (ip == 0) {

2270

test->test_server_ip_get = false;

2271

SDK_RPRINT(test->regtest, "TSHttpTxnServerIPGet", "TestCase1", TC_FAIL, "TSHttpTxnServerIPGet returns 0");

2272

return TS_EVENT_CONTINUE;

2273

}

2274

2275

if (ip == actual_ip) {

2276

test->test_server_ip_get = true;

2277

SDK_RPRINT(test->regtest, "TSHttpTxnServerIPGet", "TestCase1", TC_PASS, "ok");

2278

} else {

2279

test->test_server_ip_get = false;

2280

SDK_RPRINT(test->regtest, "TSHttpTxnServerIPGet", "TestCase1", TC_FAIL, "Value's Mismatch");

2281

}

2282

2283

2284

return TS_EVENT_CONTINUE;

2285

2286

}

2287

2288

//This func is called by us from mytest_handler to test TSHttpTxnClientIncomingPortGet

2289

static int

2290

checkHttpTxnClientIncomingPortGet(SocketTest * test, void *data)

2291

{

2292

2293

int port = -1;

2294

TSMgmtInt port_from_config_file = -1;

2295

TSHttpTxn txnp = (TSHttpTxn) data;

2296

2297

if ((port = TSHttpTxnClientIncomingPortGet(txnp)) < 0) {

2298

SDK_RPRINT(test->regtest, "TSHttpTxnClientIncomingPortGet", "TestCase1", TC_FAIL,

2299

"TSHttpTxnClientIncomingPortGet returns TS_ERROR");

2300

test->test_client_incoming_port_get = false;

2301

return TS_EVENT_CONTINUE;

2302

}

2303

2304

if (TSMgmtIntGet("proxy.config.http.server_port", &port_from_config_file) == 0) {

2305

port_from_config_file = 8080;

2306

}

2307

2308

TSDebug(UTDBG_TAG, "TS HTTP port = %x, Txn incoming client port %x", (int) port_from_config_file, port);

2309

2310

if (port == (int) port_from_config_file) {

2311

SDK_RPRINT(test->regtest, "TSHttpTxnClientIncomingPortGet", "TestCase1", TC_PASS, "ok");

2312

test->test_client_incoming_port_get = true;

2313

} else {

2314

SDK_RPRINT(test->regtest, "TSHttpTxnClientIncomingPortGet", "TestCase1", TC_FAIL,

2315

"Value's Mismatch. From Funtion: %d Expected value: %d", port, port_from_config_file);

2316

test->test_client_incoming_port_get = false;

2317

}

2318

return TS_EVENT_CONTINUE;

2319

}

2320

2321

//This func is called by us from mytest_handler to test TSHttpTxnClientRemotePortGet

2322

static int

2323

checkHttpTxnClientRemotePortGet(SocketTest * test, void *data)

2324

{

2325

2326

int port = -1;

2327

int browser_port = -1;

2328

TSHttpTxn txnp = (TSHttpTxn) data;

2329

2330

browser_port = test->browser->local_port;

2331

2332

if (TSHttpTxnClientRemotePortGet(txnp, &port) != TS_SUCCESS) {

2333

SDK_RPRINT(test->regtest, "TSHttpTxnClientRemotePortGet", "TestCase1", TC_FAIL,

2334

"TSHttpTxnClientRemotePortGet doesn't return TS_SUCCESS");

2335

test->test_client_remote_port_get = false;

2336

return TS_EVENT_CONTINUE;

2337

}

2338

2339

TSDebug(UTDBG_TAG, "Browser port = %x, Txn remote port = %x", browser_port, port);

2340

2341

if ((int)ntohs(port) == browser_port) {

2342

SDK_RPRINT(test->regtest, "TSHttpTxnClientRemotePortGet", "TestCase1", TC_PASS, "ok");

2343

test->test_client_remote_port_get = true;

2344

} else {

2345

SDK_RPRINT(test->regtest, "TSHttpTxnClientRemotePortGet", "TestCase1", TC_FAIL,

2346

"Value's Mismatch. From Function: %d Expected Value: %d", ntohs(port), browser_port);

2347

test->test_client_remote_port_get = false;

2348

}

2349

return TS_EVENT_CONTINUE;

2350

}

2351

2352

// This func is called by us from mytest_handler to test TSHttpTxnClientReqGet

2353

static int

2354

checkHttpTxnClientReqGet(SocketTest * test, void *data)

2355

{

2356

2357

TSMBuffer bufp;

2358

TSMLoc mloc;

2359

TSHttpTxn txnp = (TSHttpTxn) data;

2360

2361

if (!TSHttpTxnClientReqGet(txnp, &bufp, &mloc)) {

2362

test->test_client_req_get = false;

2363

SDK_RPRINT(test->regtest, "TSHttpTxnClientReqGet", "TestCase1", TC_FAIL, "Unable to get handle to client request");

2364

return TS_EVENT_CONTINUE;

2365

}

2366

2367

2368

if ((bufp == (&((HttpSM *) txnp)->t_state.hdr_info.client_request)) &&

2369

(mloc == (((HttpSM *) txnp)->t_state.hdr_info.client_request.m_http))

2370

) {

2371

test->test_client_req_get = true;

2372

SDK_RPRINT(test->regtest, "TSHttpTxnClientReqGet", "TestCase1", TC_PASS, "ok");

2373

} else {

2374

test->test_client_req_get = false;

2375

SDK_RPRINT(test->regtest, "TSHttpTxnClientReqGet", "TestCase1", TC_FAIL, "Value's Mismatch");

2376

}

2377

2378

return TS_EVENT_CONTINUE;

2379

}

2380

2381

// This func is called by us from mytest_handler to test TSHttpTxnClientRespGet

2382

static int

2383

checkHttpTxnClientRespGet(SocketTest * test, void *data)

2384

{

2385

2386

TSMBuffer bufp;

2387

TSMLoc mloc;

2388

TSHttpTxn txnp = (TSHttpTxn) data;

2389

2390

if (!TSHttpTxnClientRespGet(txnp, &bufp, &mloc)) {

2391

test->test_client_resp_get = false;

2392

SDK_RPRINT(test->regtest, "TSHttpTxnClientRespGet", "TestCase1", TC_FAIL,

2393

"Unable to get handle to client response");

2394

return TS_EVENT_CONTINUE;

2395

}

2396

2397

if ((bufp == (&((HttpSM *) txnp)->t_state.hdr_info.client_response)) &&

2398

(mloc == (((HttpSM *) txnp)->t_state.hdr_info.client_response.m_http))

2399

) {

2400

test->test_client_resp_get = true;

2401

SDK_RPRINT(test->regtest, "TSHttpTxnClientRespGet", "TestCase1", TC_PASS, "ok");

2402

} else {

2403

test->test_client_resp_get = false;

2404

SDK_RPRINT(test->regtest, "TSHttpTxnClientRespGet", "TestCase1", TC_FAIL, "Value's Mismatch");

2405

}

2406

2407

return TS_EVENT_CONTINUE;

2408

}

2409

2410

// This func is called by us from mytest_handler to test TSHttpTxnServerReqGet

2411

static int

2412

checkHttpTxnServerReqGet(SocketTest * test, void *data)

2413

{

2414

2415

TSMBuffer bufp;

2416

TSMLoc mloc;

2417

TSHttpTxn txnp = (TSHttpTxn) data;

2418

2419

if (!TSHttpTxnServerReqGet(txnp, &bufp, &mloc)) {

2420

test->test_server_req_get = false;

2421

SDK_RPRINT(test->regtest, "TSHttpTxnServerReqGet", "TestCase1", TC_FAIL, "Unable to get handle to server request");

2422

return TS_EVENT_CONTINUE;

2423

}

2424

2425

if ((bufp == (&((HttpSM *) txnp)->t_state.hdr_info.server_request)) &&

2426

(mloc == (((HttpSM *) txnp)->t_state.hdr_info.server_request.m_http))

2427

) {

2428

test->test_server_req_get = true;

2429

SDK_RPRINT(test->regtest, "TSHttpTxnServerReqGet", "TestCase1", TC_PASS, "ok");

2430

} else {

2431

test->test_server_req_get = false;

2432

SDK_RPRINT(test->regtest, "TSHttpTxnServerReqGet", "TestCase1", TC_FAIL, "Value's Mismatch");

2433

}

2434

2435

return TS_EVENT_CONTINUE;

2436

}

2437

2438

// This func is called by us from mytest_handler to test TSHttpTxnServerRespGet

2439

static int

2440

checkHttpTxnServerRespGet(SocketTest * test, void *data)

2441

{

2442

2443

TSMBuffer bufp;

2444

TSMLoc mloc;

2445

TSHttpTxn txnp = (TSHttpTxn) data;

2446

2447

if (!TSHttpTxnServerRespGet(txnp, &bufp, &mloc)) {

2448

test->test_server_resp_get = false;

2449

SDK_RPRINT(test->regtest, "TSHttpTxnServerRespGet", "TestCase1", TC_FAIL,

2450

"Unable to get handle to server response");

2451

return TS_EVENT_CONTINUE;

2452

}

2453

2454

if ((bufp == (&((HttpSM *) txnp)->t_state.hdr_info.server_response)) &&

2455

(mloc == (((HttpSM *) txnp)->t_state.hdr_info.server_response.m_http))

2456

) {

2457

test->test_server_resp_get = true;

2458

SDK_RPRINT(test->regtest, "TSHttpTxnServerRespGet", "TestCase1", TC_PASS, "ok");

2459

} else {

2460

test->test_server_resp_get = false;

2461

SDK_RPRINT(test->regtest, "TSHttpTxnServerRespGet", "TestCase1", TC_FAIL, "Value's Mismatch");

2462

}

2463

2464

return TS_EVENT_CONTINUE;

2465

}

2466

2467

2468

// This func is called both by us when scheduling EVENT_IMMEDIATE

2469

// And by HTTP SM for registered hooks

2470

static int

2471

mytest_handler(TSCont contp, TSEvent event, void *data)

2472

{

2473

SocketTest *test = (SocketTest *) TSContDataGet(contp);

2474

if (test == NULL) {

2475

if ((event == TS_EVENT_IMMEDIATE) || (event == TS_EVENT_TIMEOUT)) {

2476

return 0;

2477

}

2478

TSHttpTxnReenable((TSHttpTxn) data, TS_EVENT_HTTP_CONTINUE);

2479

return 0;

2480

}

2481

TSAssert(test->magic == MAGIC_ALIVE);

2482

TSAssert(test->browser->magic == MAGIC_ALIVE);

2483

2484

switch (event) {

2485

case TS_EVENT_HTTP_TXN_START:

2486

if (test->hook_mask == 0) {

2487

test->hook_mask |= 1;

2488

}

2489

2490

if (TSHttpTxnReenable((TSHttpTxn) data, TS_EVENT_HTTP_CONTINUE) != TS_SUCCESS) {

2491

SDK_RPRINT(test->regtest, "TSHttpTxnReenable", "TestCase1", TC_FAIL,

2492

"TSHttpTxnReenable doesn't return TS_SUCCESS");

2493

} else {

2494

test->reenable_mask |= 1;

2495

}

2496

break;

2497

2498

case TS_EVENT_HTTP_READ_REQUEST_HDR:

2499

if (test->hook_mask == 1) {

2500

test->hook_mask |= 2;

2501

}

2502

TSSkipRemappingSet((TSHttpTxn) data,1);

2503

checkHttpTxnClientReqGet(test, data);

2504

2505

if (TSHttpTxnReenable((TSHttpTxn) data, TS_EVENT_HTTP_CONTINUE) != TS_SUCCESS) {

2506

SDK_RPRINT(test->regtest, "TSHttpTxnReenable", "TestCase1", TC_FAIL,

2507

"TSHttpTxnReenable doesn't return TS_SUCCESS");

2508

} else {

2509

test->reenable_mask |= 2;

2510

}

2511

2512

break;

2513

2514

case TS_EVENT_HTTP_OS_DNS:

2515

if (test->hook_mask == 7) {

2516

test->hook_mask |= 8;

2517

}

2518

2519

checkHttpTxnClientIncomingPortGet(test, data);

2520

checkHttpTxnClientRemotePortGet(test, data);

2521

2522

checkHttpTxnClientIPGet(test, data);

2523

checkHttpTxnServerIPGet(test, data);

2524

2525

if (TSHttpTxnReenable((TSHttpTxn) data, TS_EVENT_HTTP_CONTINUE) != TS_SUCCESS) {

2526

SDK_RPRINT(test->regtest, "TSHttpTxnReenable", "TestCase1", TC_FAIL,

2527

"TSHttpTxnReenable doesn't return TS_SUCCESS");

2528

} else {

2529

test->reenable_mask |= 8;

2530

}

2531

break;

2532

2533

case TS_EVENT_HTTP_CACHE_LOOKUP_COMPLETE:

2534

if (test->hook_mask == 3) {

2535

test->hook_mask |= 4;

2536

}

2537

if (TSHttpTxnReenable((TSHttpTxn) data, TS_EVENT_HTTP_CONTINUE) != TS_SUCCESS) {

2538

SDK_RPRINT(test->regtest, "TSHttpTxnReenable", "TestCase1", TC_FAIL,

2539

"TSHttpTxnReenable doesn't return TS_SUCCESS");

2540

} else {

2541

test->reenable_mask |= 4;

2542

}

2543

break;

2544

2545

case TS_EVENT_HTTP_SEND_REQUEST_HDR:

2546

if (test->hook_mask == 15) {

2547

test->hook_mask |= 16;

2548

}

2549

2550

checkHttpTxnServerReqGet(test, data);

2551

checkHttpTxnNextHopIPGet(test, data);

2552

2553

if (TSHttpTxnReenable((TSHttpTxn) data, TS_EVENT_HTTP_CONTINUE) != TS_SUCCESS) {

2554

SDK_RPRINT(test->regtest, "TSHttpTxnReenable", "TestCase1", TC_FAIL,

2555

"TSHttpTxnReenable doesn't return TS_SUCCESS");

2556

} else {

2557

test->reenable_mask |= 16;

2558

}

2559

2560

2561

break;

2562

2563

case TS_EVENT_HTTP_READ_RESPONSE_HDR:

2564

if (test->hook_mask == 31) {

2565

test->hook_mask |= 32;

2566

}

2567

checkHttpTxnServerRespGet(test, data);

2568

2569

if (TSHttpTxnReenable((TSHttpTxn) data, TS_EVENT_HTTP_CONTINUE) != TS_SUCCESS) {

2570

SDK_RPRINT(test->regtest, "TSHttpTxnReenable", "TestCase1", TC_FAIL,

2571

"TSHttpTxnReenable doesn't return TS_SUCCESS");

2572

} else {

2573

test->reenable_mask |= 32;

2574

}

2575

2576

break;

2577

2578

case TS_EVENT_HTTP_SEND_RESPONSE_HDR:

2579

if (test->hook_mask == 63) {

2580

test->hook_mask |= 64;

2581

}

2582

2583

checkHttpTxnClientRespGet(test, data);

2584

2585

if (TSHttpTxnReenable((TSHttpTxn) data, TS_EVENT_HTTP_CONTINUE) != TS_SUCCESS) {

2586

SDK_RPRINT(test->regtest, "TSHttpTxnReenable", "TestCase1", TC_FAIL,

2587

"TSHttpTxnReenable doesn't return TS_SUCCESS");

2588

} else {

2589

test->reenable_mask |= 64;

2590

}

2591

2592

break;

2593

2594

case TS_EVENT_HTTP_TXN_CLOSE:

2595

if (test->hook_mask == 127) {

2596

test->hook_mask |= 128;

2597

}

2598

2599

if (TSHttpTxnReenable((TSHttpTxn) data, TS_EVENT_HTTP_CONTINUE) != TS_SUCCESS) {

2600

SDK_RPRINT(test->regtest, "TSHttpTxnReenable", "TestCase1", TC_FAIL,

2601

"TSHttpTxnReenable doesn't return TS_SUCCESS");

2602

} else {

2603

test->reenable_mask |= 128;

2604

}

2605

break;

2606

2607

case TS_EVENT_IMMEDIATE:

2608

case TS_EVENT_TIMEOUT:

2609

/* Browser still waiting the response ? */

2610

if (test->browser->status == REQUEST_INPROGRESS) {

2611

TSContSchedule(contp, 25, TS_THREAD_POOL_DEFAULT);

2612

}

2613

/* Browser got the response. test is over. clean up */

2614

else {

2615

/* Note: response is available using test->browser->response pointer */

2616

if ((test->browser->status == REQUEST_SUCCESS) && (test->hook_mask == 255)) {

2617

*(test->pstatus) = REGRESSION_TEST_PASSED;

2618

SDK_RPRINT(test->regtest, "TSHttpHookAdd", "TestCase1", TC_PASS, "ok");

2619

2620

} else {

2621

*(test->pstatus) = REGRESSION_TEST_FAILED;

2622

SDK_RPRINT(test->regtest, "TSHttpHookAdd", "TestCase1", TC_FAIL,

2623

"Hooks not called or request failure. Hook mask = %d\n %s", test->hook_mask,test->browser->response);

2624

}

2625

2626

if (test->reenable_mask == 255) {

2627

SDK_RPRINT(test->regtest, "TSHttpTxnReenable", "TestCase1", TC_PASS, "ok");

2628

2629

} else {

2630

*(test->pstatus) = REGRESSION_TEST_FAILED;

2631

SDK_RPRINT(test->regtest, "TSHttpTxnReenable", "TestCase1", TC_FAIL, "Txn not reenabled properly");

2632

2633

}

2634

2635

if ((test->test_client_ip_get != true) ||

2636

(test->test_client_incoming_port_get != true) ||

2637

(test->test_client_remote_port_get != true) ||

2638

(test->test_client_req_get != true) ||

2639

(test->test_client_resp_get != true) ||

2640

(test->test_server_ip_get != true) ||

2641

(test->test_server_req_get != true) ||

2642

(test->test_server_resp_get != true) || (test->test_next_hop_ip_get != true)

2643

) {

2644

*(test->pstatus) = REGRESSION_TEST_FAILED;

2645

}

2646

// transaction is over. clean up.

2647

synclient_txn_delete(test->browser);

2648

synserver_delete(test->os);

2649

2650

test->magic = MAGIC_DEAD;

2651

TSfree(test);

2652

TSContDataSet(contp, NULL);

2653

}

2654

break;

2655

2656

default:

2657

*(test->pstatus) = REGRESSION_TEST_FAILED;

2658

SDK_RPRINT(test->regtest, "TSHttpHookAdd", "TestCase1", TC_FAIL, "Unexpected event %d", event);

2659

break;

2660

}

2661

2662

return TS_EVENT_IMMEDIATE;

2663

}

2664

2665

2666

2667

EXCLUSIVE_REGRESSION_TEST(SDK_API_HttpHookAdd) (RegressionTest * test, int atype, int *pstatus)

2668

{

2669

NOWARN_UNUSED(atype);

2670

*pstatus = REGRESSION_TEST_INPROGRESS;

2671

2672

TSCont cont = TSContCreate(mytest_handler, TSMutexCreate());

2673

SocketTest *socktest = (SocketTest *) TSmalloc(sizeof(SocketTest));

2674

2675

socktest->regtest = test;

2676

socktest->pstatus = pstatus;

2677

socktest->hook_mask = 0;

2678

socktest->reenable_mask = 0;

2679

socktest->test_client_ip_get = false;

2680

socktest->test_client_incoming_port_get = false;

2681

socktest->test_client_req_get = false;

2682

socktest->test_client_resp_get = false;

2683

socktest->test_server_ip_get = false;

2684

socktest->test_server_req_get = false;

2685

socktest->test_server_resp_get = false;

2686

socktest->test_next_hop_ip_get = false;

2687

socktest->magic = MAGIC_ALIVE;

2688

TSContDataSet(cont, socktest);

2689

2690

/* Register to HTTP hooks that are called in case of a cache MISS */

2691

TSHttpHookAdd(TS_HTTP_TXN_START_HOOK, cont);

2692

TSHttpHookAdd(TS_HTTP_READ_REQUEST_HDR_HOOK, cont);

2693

TSHttpHookAdd(TS_HTTP_OS_DNS_HOOK, cont);

2694

TSHttpHookAdd(TS_HTTP_CACHE_LOOKUP_COMPLETE_HOOK, cont);

2695

TSHttpHookAdd(TS_HTTP_SEND_REQUEST_HDR_HOOK, cont);

2696

TSHttpHookAdd(TS_HTTP_READ_RESPONSE_HDR_HOOK, cont);

2697

TSHttpHookAdd(TS_HTTP_SEND_RESPONSE_HDR_HOOK, cont);

2698

TSHttpHookAdd(TS_HTTP_TXN_CLOSE_HOOK, cont);

2699

2700

/* Create a new synthetic server */

2701

socktest->os = synserver_create(SYNSERVER_LISTEN_PORT);

2702

synserver_start(socktest->os);

2703

2704

/* Create a client transaction */

2705

socktest->browser = synclient_txn_create();

2706

char *request = generate_request(HTTP_HOOK_TEST_REQUEST_ID); // this request has a no-cache that prevents caching

2707

synclient_txn_send_request(socktest->browser, request);

2708

TSfree(request);

2709

2710

/* Wait until transaction is done */

2711

if (socktest->browser->status == REQUEST_INPROGRESS) {

2712

TSContSchedule(cont, 25, TS_THREAD_POOL_DEFAULT);

2713

}

2714

2715

return;

2716

}

2717

2718

2719

//////////////////////////////////////////////

2720

// SDK_API_TSUrl

2721

2722

// Unit Test for API: TSUrlCreate

2723

// TSUrlDestroy

2724

// TSUrlSchemeGet

2725

// TSUrlSchemeSet

2726

// TSUrlUserGet

2727

// TSUrlUserSet

2728

// TSUrlPasswordGet

2729

// TSUrlPasswordSet

2730

// TSUrlHostGet

2731

// TSUrlHostSet

2732

// TSUrlPortGet

2733

// TSUrlPortSet

2734

// TSUrlPathGet

2735

// TSUrlPathSet

2736

// TSUrlHttpParamsGet

2737

// TSUrlHttpParamsSet

2738

// TSUrlHttpQueryGet

2739

// TSUrlHttpQuerySet

2740

// TSUrlHttpFragmentGet

2741

// TSUrlHttpFragmentSet

2742

// TSUrlCopy

2743

// TSUrlClone

2744

// TSUrlStringGet

2745

// TSUrlPrint

2746

// TSUrlLengthGet

2747

// TSUrlFtpTypeGet

2748

// TSUrlFtpTypeSet

2749

//////////////////////////////////////////////

2750

2751

char *

2752

test_url_print(TSMBuffer bufp, TSMLoc hdr_loc)

2753

{

2754

TSIOBuffer output_buffer;

2755

TSIOBufferReader reader;

2756

int64_t total_avail;

2757

2758

TSIOBufferBlock block;

2759

const char *block_start;

2760

int64_t block_avail;

2761

2762

char *output_string;

2763

int output_len;

2764

2765

output_buffer = TSIOBufferCreate();

2766

2767

if (!output_buffer) {

2768

TSError("couldn't allocate IOBuffer\n");

2769

}

2770

2771

reader = TSIOBufferReaderAlloc(output_buffer);

2772

2773

/* This will print just MIMEFields and not

2774

the http request line */

2775

if (TSUrlPrint(bufp, hdr_loc, output_buffer) != TS_SUCCESS) {

2776

return NULL;

2777

}

2778

2779

/* Find out how the big the complete header is by

2780

seeing the total bytes in the buffer. We need to

2781

look at the buffer rather than the first block to

2782

see the size of the entire header */

2783

total_avail = TSIOBufferReaderAvail(reader);

2784

2785

/* Allocate the string with an extra byte for the string

2786

terminator */

2787

output_string = (char *) TSmalloc(total_avail + 1);

2788

output_len = 0;

2789

2790

/* We need to loop over all the buffer blocks to make

2791

sure we get the complete header since the header can

2792

be in multiple blocks */

2793

block = TSIOBufferReaderStart(reader);

2794

while (block) {

2795

2796

block_start = TSIOBufferBlockReadStart(block, reader, &block_avail);

2797

2798

/* We'll get a block pointer back even if there is no data

2799

left to read so check for this condition and break out of

2800

the loop. A block with no data to read means we've exhausted

2801

buffer of data since if there was more data on a later

2802

block in the chain, this block would have been skipped over */

2803

if (block_avail == 0) {

2804

break;

2805

}

2806

2807

memcpy(output_string + output_len, block_start, block_avail);

2808

output_len += block_avail;

2809

2810

/* Consume the data so that we get to the next block */

2811

TSIOBufferReaderConsume(reader, block_avail);

2812

2813

/* Get the next block now that we've consumed the

2814

data off the last block */

2815

block = TSIOBufferReaderStart(reader);

2816

}

2817

2818

/* Terminate the string */

2819

output_string[output_len] = '\0';

2820

output_len++;

2821

2822

/* Free up the TSIOBuffer that we used to print out the header */

2823

TSIOBufferReaderFree(reader);

2824

TSIOBufferDestroy(output_buffer);

2825

2826

return output_string;

2827

}

2828

2829

REGRESSION_TEST(SDK_API_TSUrl) (RegressionTest * test, int atype, int *pstatus)

2830

{

2831

NOWARN_UNUSED(atype);

2832

TSMBuffer bufp1 = (TSMBuffer) TS_ERROR_PTR;

2833

TSMBuffer bufp2 = (TSMBuffer) TS_ERROR_PTR;

2834

TSMBuffer bufp3 = (TSMBuffer) TS_ERROR_PTR;

2835

TSMLoc url_loc1;

2836

TSMLoc url_loc2;

2837

TSMLoc url_loc3;

2838

const char *scheme = TS_URL_SCHEME_HTTP;

2839

const char *scheme_get;

2840

const char *user = "yyy";

2841

const char *user_get;

2842

const char *password = "xxx";

2843

const char *password_get;

2844

const char *host = "www.example.com";

2845

const char *host_get;

2846

int port = 2021;

2847

char port_char[10];

2848

int port_get = 80;

2849

const char *path = "about/overview.html";

2850

const char *path_get;

2851

const char *params = "abcdef";

2852

const char *params_get;

2853

const char *query = "name=xxx";

2854

const char *query_get;

2855

const char *fragment = "yyy";

2856

const char *fragment_get;

2857

char *url_expected_string;

2858

char *url_string_from_1 = (char *) TS_ERROR_PTR;

2859

char *url_string_from_2 = (char *) TS_ERROR_PTR;

2860

char *url_string_from_3 = (char *) TS_ERROR_PTR;

2861

char *url_string_from_print = (char *) TS_ERROR_PTR;

2862

int url_expected_length;

2863

int url_length_from_1;

2864

int url_length_from_2;

2865

int type = 'a';

2866

int type_get;

2867

2868

bool test_passed_create = false;

2869

bool test_passed_destroy = false;

2870

bool test_passed_scheme = false;

2871

bool test_passed_user = false;

2872

bool test_passed_password = false;

2873

bool test_passed_host = false;

2874

bool test_passed_port = false;

2875

bool test_passed_path = false;

2876

bool test_passed_params = false;

2877

bool test_passed_query = false;

2878

bool test_passed_fragment = false;

2879

bool test_passed_copy = false;

2880

bool test_passed_clone = false;

2881

bool test_passed_string1 = false;

2882

bool test_passed_string2 = false;

2883

bool test_passed_print = false;

2884

bool test_passed_length1 = false;

2885

bool test_passed_length2 = false;

2886

bool test_passed_type = false;

2887

2888

int length;

2889

2890

*pstatus = REGRESSION_TEST_INPROGRESS;

2891

2892

//Initialization

2893

memset(port_char, 0, 10);

2894

snprintf(port_char, sizeof(port_char), "%d", port);

2895

2896

// HTTP URL

2897

2898

url_expected_length = strlen(scheme) + strlen("://") +

2899

((user == NULL) ? 0 : strlen(user)) +

2900

((password == NULL) ? ((user == NULL) ? 0 : strlen("@")) : strlen(":") + strlen(password) + strlen("@")) +

2901

strlen(host) +

2902

((port == 80) ? 0 : strlen(port_char) + strlen(":")) +

2903

strlen("/") + strlen(path) +

2904

((params == NULL) ? 0 : strlen(";") + strlen(params)) +

2905

((query == NULL) ? 0 : strlen("?") + strlen(query)) + ((fragment == NULL) ? 0 : strlen("#") + strlen(fragment));

2906

2907

size_t len = url_expected_length + 1;

2908

url_expected_string = (char *) TSmalloc(len * sizeof(char));

2909

memset(url_expected_string, 0, url_expected_length + 1);

2910

snprintf(url_expected_string, len, "%s://%s%s%s%s%s%s%s/%s%s%s%s%s%s%s",

2911

scheme,

2912

((user == NULL) ? "" : user),

2913

((password == NULL) ? "" : ":"),

2914

((password == NULL) ? "" : password),

2915

(((user == NULL) && (password == NULL)) ? "" : "@"),

2916

host,

2917

((port == 80) ? "" : ":"),

2918

((port == 80) ? "" : port_char),

2919

((path == NULL) ? "" : path),

2920

((params == NULL) ? "" : ";"),

2921

((params == NULL) ? "" : params),

2922

((query == NULL) ? "" : "?"),

2923

((query == NULL) ? "" : query), ((fragment == NULL) ? "" : "#"), ((fragment == NULL) ? "" : fragment)

2924

);

2925

2926

2927

// Set Functions

2928

2929

if ((bufp1 = TSMBufferCreate()) == TS_ERROR_PTR) {

2930

// Cannot proceed with tests.

2931

SDK_RPRINT(test, "TSMBufferCreate", "TestCase1", TC_FAIL, "unable to allocate MBuffer.");

2932

goto print_results;

2933

};

2934

if ((url_loc1 = TSUrlCreate(bufp1)) == TS_ERROR_PTR) {

2935

// Cannot proceed with tests.

2936

SDK_RPRINT(test, "TSUrlCreate", "TestCase1", TC_FAIL, "unable to create URL within buffer.");

2937

goto print_results;

2938

}

2939

//Scheme

2940

if (TSUrlSchemeSet(bufp1, url_loc1, scheme, -1) != TS_SUCCESS) {

2941

SDK_RPRINT(test, "TSUrlSchemeSet", "TestCase1", TC_FAIL, "TSUrlSchemeSet Returned TS_ERROR");

2942

} else {

2943

if ((scheme_get = TSUrlSchemeGet(bufp1, url_loc1, &length)) == TS_ERROR_PTR) {

2944

SDK_RPRINT(test, "TSUrlSchemeSet|Get", "TestCase1", TC_FAIL, "TSUrlSchemeGet Returned TS_ERROR_PTR");

2945

} else {

2946

if (strncmp(scheme_get, scheme, length) == 0) {

2947

SDK_RPRINT(test, "TSUrlSchemeSet&Get", "TestCase1", TC_PASS, "ok");

2948

test_passed_scheme = true;

2949

} else {

2950

SDK_RPRINT(test, "TSUrlSchemeSet&Get", "TestCase1", TC_FAIL, "Values don't match");

2951

}

2952

}

2953

}

2954

2955

//User

2956

if (TSUrlUserSet(bufp1, url_loc1, user, -1) != TS_SUCCESS) {

2957

SDK_RPRINT(test, "TSUrlUserSet", "TestCase1", TC_FAIL, "Returned TS_ERROR");

2958

} else {

2959

if ((user_get = TSUrlUserGet(bufp1, url_loc1, &length)) == TS_ERROR_PTR) {

2960

SDK_RPRINT(test, "TSUrlUserSet|Get", "TestCase1", TC_FAIL, "TSUrlUserGet Returned TS_ERROR_PTR");

2961

} else {

2962

if (((user_get == NULL) && (user == NULL)) || (strncmp(user_get, user, length) == 0)) {

2963

SDK_RPRINT(test, "TSUrlUserSet&Get", "TestCase1", TC_PASS, "ok");

2964

test_passed_user = true;

2965

} else {

2966

SDK_RPRINT(test, "TSUrlUserSet&Get", "TestCase1", TC_FAIL, "Values don't match");

2967

}

2968

}

2969

}

2970

2971

// Password

2972

if (TSUrlPasswordSet(bufp1, url_loc1, password, -1) != TS_SUCCESS) {

2973

SDK_RPRINT(test, "TSUrlPasswordSet", "TestCase1", TC_FAIL, "Returned TS_ERROR");

2974

} else {

2975

if ((password_get = TSUrlPasswordGet(bufp1, url_loc1, &length)) == TS_ERROR_PTR) {

2976

SDK_RPRINT(test, "TSUrlPasswordSet|Get", "TestCase1", TC_FAIL, "TSUrlPasswordGet Returned TS_ERROR_PTR");

2977

} else {

2978

if (((password_get == NULL) && (password == NULL)) || (strncmp(password_get, password, length) == 0)) {

2979

SDK_RPRINT(test, "TSUrlPasswordSet&Get", "TestCase1", TC_PASS, "ok");

2980

test_passed_password = true;

2981

} else {

2982

SDK_RPRINT(test, "TSUrlPasswordSet&Get", "TestCase1", TC_FAIL, "Values don't match");

2983

}

2984

}

2985

}

2986

2987

//Host

2988

if (TSUrlHostSet(bufp1, url_loc1, host, -1) != TS_SUCCESS) {

2989

SDK_RPRINT(test, "TSUrlHostSet", "TestCase1", TC_FAIL, "Returned TS_ERROR");

2990

} else {

2991

if ((host_get = TSUrlHostGet(bufp1, url_loc1, &length)) == TS_ERROR_PTR) {

2992

SDK_RPRINT(test, "TSUrlHostSet|Get", "TestCase1", TC_FAIL, "TSUrlHostGet Returned TS_ERROR_PTR");

2993

} else {

2994

if (strncmp(host_get, host, length) == 0) {

2995

SDK_RPRINT(test, "TSUrlHostSet&Get", "TestCase1", TC_PASS, "ok");

2996

test_passed_host = true;

2997

} else {

2998

SDK_RPRINT(test, "TSUrlHostSet&Get", "TestCase1", TC_FAIL, "Values don't match");

2999

}

3000

}

3001

}

3002

3003

//Port

3004

if (TSUrlPortSet(bufp1, url_loc1, port) != TS_SUCCESS) {

3005

SDK_RPRINT(test, "TSUrlPortSet", "TestCase1", TC_FAIL, "Returned TS_ERROR");

3006

} else {

3007

port_get = 80;

3008

if ((port_get = TSUrlPortGet(bufp1, url_loc1)) == TS_ERROR) {

3009

SDK_RPRINT(test, "TSUrlPortSet|Get", "TestCase1", TC_FAIL, "TSUrlPortGet Returned TS_ERROR");

3010

} else {

3011

if (port_get == port) {

3012

SDK_RPRINT(test, "TSUrlPortSet&Get", "TestCase1", TC_PASS, "ok");

3013

test_passed_port = true;

3014

} else {

3015

SDK_RPRINT(test, "TSUrlPortSet&Get", "TestCase1", TC_FAIL, "Values don't match");

3016

}

3017

}

3018

}

3019

3020

//Path

3021

if (TSUrlPathSet(bufp1, url_loc1, path, -1) != TS_SUCCESS) {

3022

SDK_RPRINT(test, "TSUrlPathSet", "TestCase1", TC_FAIL, "Returned TS_ERROR");

3023

} else {

3024

if ((path_get = TSUrlPathGet(bufp1, url_loc1, &length)) == TS_ERROR_PTR) {

3025

SDK_RPRINT(test, "TSUrlPathSet|Get", "TestCase1", TC_FAIL, "TSUrlPathGet Returned TS_ERROR_PTR");

3026

} else {

3027

if (((path == NULL) && (path_get == NULL)) || (strncmp(path, path_get, length) == 0)) {

3028

SDK_RPRINT(test, "TSUrlPathSet&Get", "TestCase1", TC_PASS, "ok");

3029

test_passed_path = true;

3030

} else {

3031

SDK_RPRINT(test, "TSUrlPathSet&Get", "TestCase1", TC_FAIL, "Values don't match");

3032

}

3033

}

3034

}

3035

3036

//Params

3037

if (TSUrlHttpParamsSet(bufp1, url_loc1, params, -1) != TS_SUCCESS) {

3038

SDK_RPRINT(test, "TSUrlHttpParamsSet", "TestCase1", TC_FAIL, "Returned TS_ERROR");

3039

} else {

3040

if ((params_get = TSUrlHttpParamsGet(bufp1, url_loc1, &length)) == TS_ERROR_PTR) {

3041

SDK_RPRINT(test, "TSUrlHttpParamsSet|Get", "TestCase1", TC_FAIL, "TSUrlHttpParamsGet Returned TS_ERROR_PTR");

3042

} else {

3043

if (((params == NULL) && (params_get == NULL)) || (strncmp(params, params_get, length) == 0)) {

3044

SDK_RPRINT(test, "TSUrlHttpParamsSet&Get", "TestCase1", TC_PASS, "ok");

3045

test_passed_params = true;

3046

} else {

3047

SDK_RPRINT(test, "TSUrlHttpParamsSet&Get", "TestCase1", TC_FAIL, "Values don't match");

3048

}

3049

}

3050

}

3051

3052

//Query

3053

if (TSUrlHttpQuerySet(bufp1, url_loc1, query, -1) != TS_SUCCESS) {

3054

SDK_RPRINT(test, "TSUrlHttpQuerySet", "TestCase1", TC_FAIL, "Returned TS_ERROR");

3055

} else {

3056

if ((query_get = TSUrlHttpQueryGet(bufp1, url_loc1, &length)) == TS_ERROR_PTR) {

3057

SDK_RPRINT(test, "TSUrlHttpQuerySet|Get", "TestCase1", TC_FAIL, "TSUrlHttpQueryGet Returned TS_ERROR_PTR");

3058

} else {

3059

if (((query == NULL) && (query_get == NULL)) || (strncmp(query, query_get, length) == 0)) {

3060

SDK_RPRINT(test, "TSUrlHttpQuerySet&Get", "TestCase1", TC_PASS, "ok");

3061

test_passed_query = true;

3062

} else {

3063

SDK_RPRINT(test, "TSUrlHttpQuerySet&Get", "TestCase1", TC_FAIL, "Values don't match");

3064

}

3065

}

3066

}

3067

3068

//Fragments

3069

if (TSUrlHttpFragmentSet(bufp1, url_loc1, fragment, -1) != TS_SUCCESS) {

3070

SDK_RPRINT(test, "TSUrlHttpFragmentSet", "TestCase1", TC_FAIL, "Returned TS_ERROR");

3071

} else {

3072

if ((fragment_get = TSUrlHttpFragmentGet(bufp1, url_loc1, &length)) == TS_ERROR_PTR) {

3073

SDK_RPRINT(test, "TSUrlHttpFragmentSet|Get", "TestCase1", TC_FAIL,

3074

"TSUrlHttpFragmentGet Returned TS_ERROR_PTR");

3075

} else {

3076

if (((fragment == NULL) && (fragment_get == NULL)) || (strncmp(fragment, fragment_get, length) == 0)) {

3077

SDK_RPRINT(test, "TSUrlHttpFragmentSet&Get", "TestCase1", TC_PASS, "ok");

3078

test_passed_fragment = true;

3079

} else {

3080

SDK_RPRINT(test, "TSUrlHttpFragmentSet&Get", "TestCase1", TC_FAIL, "Values don't match");

3081

}

3082

}

3083

}

3084

3085

//Length

3086

if ((url_length_from_1 = TSUrlLengthGet(bufp1, url_loc1)) == TS_ERROR) {

3087

SDK_RPRINT(test, "TSUrlLengthGet", "TestCase1", TC_FAIL, "Returns TS_ERROR");

3088

} else {

3089

if (url_length_from_1 == url_expected_length) {

3090

SDK_RPRINT(test, "TSUrlLengthGet", "TestCase1", TC_PASS, "ok");

3091

test_passed_length1 = true;

3092

} else {

3093

SDK_RPRINT(test, "TSUrlLengthGet", "TestCase1", TC_FAIL, "Values don't match");

3094

}

3095

}

3096

3097

3098

//String

3099

if ((url_string_from_1 = TSUrlStringGet(bufp1, url_loc1, NULL)) == TS_ERROR_PTR) {

3100

SDK_RPRINT(test, "TSUrlStringGet", "TestCase1", TC_FAIL, "Returns TS_ERROR_PTR");

3101

} else {

3102

if (strcmp(url_string_from_1, url_expected_string) == 0) {

3103

SDK_RPRINT(test, "TSUrlStringGet", "TestCase1", TC_PASS, "ok");

3104

test_passed_string1 = true;

3105

} else {

3106

SDK_RPRINT(test, "TSUrlStringGet", "TestCase1", TC_FAIL, "Values don't match");

3107

}

3108

}

3109

3110

3111

//Copy

3112

if ((bufp2 = TSMBufferCreate()) == TS_ERROR_PTR) {

3113

// Cannot proceed with tests.

3114

SDK_RPRINT(test, "TSMBufferCreate", "TestCase2", TC_FAIL, "unable to allocate MBuffer for TSUrlCopy.");

3115

goto print_results;

3116

};

3117

if ((url_loc2 = TSUrlCreate(bufp2)) == TS_ERROR_PTR) {

3118

// Cannot proceed with tests.

3119

SDK_RPRINT(test, "TSUrlCreate", "TestCase2", TC_FAIL, "unable to create URL within buffer for TSUrlCopy.");

3120

goto print_results;

3121

}

3122

if (TSUrlCopy(bufp2, url_loc2, bufp1, url_loc1) == TS_ERROR) {

3123

SDK_RPRINT(test, "TSUrlCopy", "TestCase1", TC_FAIL, "Returned TS_ERROR");

3124

} else {

3125

//Length Test Case 2

3126

if ((url_length_from_2 = TSUrlLengthGet(bufp2, url_loc2)) == TS_ERROR) {

3127

SDK_RPRINT(test, "TSUrlLengthGet", "TestCase2", TC_FAIL, "Returns TS_ERROR");

3128

} else {

3129

if (url_length_from_2 == url_expected_length) {

3130

SDK_RPRINT(test, "TSUrlLengthGet", "TestCase2", TC_PASS, "ok");

3131

test_passed_length2 = true;

3132

} else {

3133

SDK_RPRINT(test, "TSUrlCopy", "TestCase1", TC_FAIL, "Values don't match");

3134

}

3135

}

3136

3137

3138

//String Test Case 2

3139

if ((url_string_from_2 = TSUrlStringGet(bufp2, url_loc2, NULL)) == TS_ERROR_PTR) {

3140

SDK_RPRINT(test, "TSUrlStringGet", "TestCase2", TC_FAIL, "Returns TS_ERROR_PTR");

3141

} else {

3142

if (strcmp(url_string_from_2, url_expected_string) == 0) {

3143

SDK_RPRINT(test, "TSUrlStringGet", "TestCase2", TC_PASS, "ok");

3144

test_passed_string2 = true;

3145

} else {

3146

SDK_RPRINT(test, "TSUrlStringGet", "TestCase2", TC_FAIL, "Values don't match");

3147

}

3148

}

3149

3150

// Copy Test Case

3151

if (strcmp(url_string_from_1, url_string_from_2) == 0) {

3152

SDK_RPRINT(test, "TSUrlCopy", "TestCase1", TC_PASS, "ok");

3153

test_passed_copy = true;

3154

} else {

3155

SDK_RPRINT(test, "TSUrlCopy", "TestCase1", TC_FAIL, "Values Don't Match");

3156

}

3157

}

3158

3159

//Clone

3160

if ((bufp3 = TSMBufferCreate()) == TS_ERROR_PTR) {

3161

// Cannot proceed with tests.

3162

SDK_RPRINT(test, "TSMBufferCreate", "TestCase2", TC_FAIL, "unable to allocate MBuffer for TSUrlClone.");

3163

goto print_results;

3164

};

3165

if ((url_loc3 = TSUrlClone(bufp3, bufp1, url_loc1)) == TS_ERROR_PTR) {

3166

SDK_RPRINT(test, "TSUrlClone", "TestCase1", TC_FAIL, "Returned TS_ERROR_PTR");

3167

} else {

3168

//String Test Case 2

3169

if ((url_string_from_3 = TSUrlStringGet(bufp3, url_loc3, NULL)) == TS_ERROR_PTR) {

3170

SDK_RPRINT(test, "TSUrlClone", "TestCase2", TC_FAIL, "TSUrlStringGet Returns TS_ERROR_PTR");

3171

} else {

3172

// Copy Test Case

3173

if (strcmp(url_string_from_1, url_string_from_3) == 0) {

3174

SDK_RPRINT(test, "TSUrlClone", "TestCase1", TC_PASS, "ok");

3175

test_passed_clone = true;

3176

} else {

3177

SDK_RPRINT(test, "TSUrlClone", "TestCase1", TC_FAIL, "Values Don't Match");

3178

}

3179

}

3180

}

3181

3182

//UrlPrint

3183

url_string_from_print = test_url_print(bufp1, url_loc1);

3184

if (url_string_from_print == NULL) {

3185

SDK_RPRINT(test, "TSUrlPrint", "TestCase1", TC_FAIL, "TSUrlPrint doesn't return TS_SUCCESS");

3186

} else {

3187

if (strcmp(url_string_from_print, url_expected_string) == 0) {

3188

SDK_RPRINT(test, "TSUrlPrint", "TestCase1", TC_PASS, "ok");

3189

test_passed_print = true;

3190

} else {

3191

SDK_RPRINT(test, "TSUrlPrint", "TestCase1", TC_FAIL, "TSUrlPrint doesn't return TS_SUCCESS");

3192

}

3193

TSfree(url_string_from_print);

3194

}

3195

3196

if (TSUrlFtpTypeSet(bufp1, url_loc1, type) != TS_SUCCESS) {

3197

SDK_RPRINT(test, "TSUrlFtpTypeSet", "TestCase1", TC_FAIL, "TSUrlFtpTypeSet Returned TS_ERROR");

3198

} else {

3199

if ((type_get = TSUrlFtpTypeGet(bufp1, url_loc1)) == TS_ERROR) {

3200

SDK_RPRINT(test, "TSUrlFtpTypeSet|Get", "TestCase1", TC_FAIL, "TSUrlFtpTypeGet Returned TS_ERROR");

3201

} else {

3202

if (type_get == type) {

3203

SDK_RPRINT(test, "TSUrlFtpTypeSet&Get", "TestCase1", TC_PASS, "ok");

3204

test_passed_type = true;

3205

} else {

3206

SDK_RPRINT(test, "TSUrlFtpTypeSet&Get", "TestCase1", TC_FAIL, "Values don't match");

3207

}

3208

}

3209

}

3210

3211

3212

if ((TSUrlDestroy(bufp1, url_loc1) == TS_ERROR) &&

3213

(TSUrlDestroy(bufp2, url_loc2) == TS_ERROR) && (TSUrlDestroy(bufp3, url_loc3) == TS_ERROR)

3214

) {

3215

SDK_RPRINT(test, "TSUrlCreate", "TestCase1&2", TC_PASS, "ok");

3216

SDK_RPRINT(test, "TSUrlDestroy", "TestCase1|2|3", TC_FAIL, "Returns TS_ERROR");

3217

} else {

3218

SDK_RPRINT(test, "TSUrlCreate", "TestCase1&2", TC_PASS, "ok");

3219

SDK_RPRINT(test, "TSUrlDestroy", "TestCase1&2&3", TC_PASS, "ok");

3220

TSHandleMLocRelease(bufp1, TS_NULL_MLOC, url_loc1);

3221

TSHandleMLocRelease(bufp2, TS_NULL_MLOC, url_loc2);

3222

TSHandleMLocRelease(bufp3, TS_NULL_MLOC, url_loc3);

3223

test_passed_create = true;

3224

test_passed_destroy = true;

3225

}

3226

3227

print_results:

3228

TSfree(url_expected_string);

3229

if (url_string_from_1 != TS_ERROR_PTR) {

3230

TSfree(url_string_from_1);

3231

}

3232

if (url_string_from_2 != TS_ERROR_PTR) {

3233

TSfree(url_string_from_2);

3234

}

3235

if (url_string_from_3 != TS_ERROR_PTR) {

3236

TSfree(url_string_from_3);

3237

}

3238

if (bufp1 != TS_ERROR_PTR) {

3239

TSMBufferDestroy(bufp1);

3240

}

3241

if (bufp2 != TS_ERROR_PTR) {

3242

TSMBufferDestroy(bufp2);

3243

}

3244

if (bufp3 != TS_ERROR_PTR) {

3245

TSMBufferDestroy(bufp3);

3246

}

3247

if ((test_passed_create == false) ||

3248

(test_passed_destroy == false) ||

3249

(test_passed_scheme == false) ||

3250

(test_passed_user == false) ||

3251

(test_passed_password == false) ||

3252

(test_passed_host == false) ||

3253

(test_passed_port == false) ||

3254

(test_passed_path == false) ||

3255

(test_passed_params == false) ||

3256

(test_passed_query == false) ||

3257

(test_passed_fragment == false) ||

3258

(test_passed_copy == false) ||

3259

(test_passed_clone == false) ||

3260

(test_passed_string1 == false) ||

3261

(test_passed_string2 == false) ||

3262

(test_passed_print == false) ||

3263

(test_passed_length1 == false) || (test_passed_length2 == false) || (test_passed_type == false)

3264

) {

3265

/*** Debugging the test itself....

3266

(test_passed_create == false)?printf("test_passed_create is false\n"):printf("");

3267

(test_passed_destroy == false)?printf("test_passed_destroy is false\n"):printf("");

3268

(test_passed_scheme == false)?printf("test_passed_scheme is false\n"):printf("");

3269

(test_passed_user == false)?printf("test_passed_user is false\n"):printf("");

3270

(test_passed_password == false)?printf("test_passed_password is false\n"):printf("");

3271

(test_passed_host == false)?printf("test_passed_host is false\n"):printf("");

3272

(test_passed_port == false)?printf("test_passed_port is false\n"):printf("");

3273

(test_passed_path == false)?printf("test_passed_path is false\n"):printf("");

3274

(test_passed_params == false)?printf("test_passed_params is false\n"):printf("");

3275

(test_passed_query == false)?printf("test_passed_query is false\n"):printf("");

3276

(test_passed_fragment == false)?printf("test_passed_fragment is false\n"):printf("");

3277

(test_passed_copy == false)?printf("test_passed_copy is false\n"):printf("");

3278

(test_passed_string1 == false)?printf("test_passed_string1 is false\n"):printf("");

3279

(test_passed_string2 == false)?printf("test_passed_string2 is false\n"):printf("");

3280

(test_passed_length1 == false)?printf("test_passed_length1 is false\n"):printf("");

3281

(test_passed_length2 == false)?printf("test_passed_length2 is false\n"):printf("");

3282

(test_passed_type == false)?printf("test_passed_type is false\n"):printf("");

3283

.....***********/

3284

*pstatus = REGRESSION_TEST_FAILED;

3285

} else {

3286

*pstatus = REGRESSION_TEST_PASSED;

3287

}

3288

}

3289

3290

//////////////////////////////////////////////

3291

// SDK_API_TSHttpHdr

3292

3293

// Unit Test for API: TSHttpHdrCreate

3294

// TSHttpHdrCopy

3295

// TSHttpHdrClone

3296

// TSHttpHdrDestroy

3297

// TSHttpHdrLengthGet

3298

// TSHttpHdrMethodGet

3299

// TSHttpHdrMethodSet

3300

// TSHttpHdrPrint

3301

// TSHttpHdrReasonGet

3302

// TSHttpHdrReasonLookup

3303

// TSHttpHdrReasonSet

3304

// TSHttpHdrStatusGet

3305

// TSHttpHdrStatusSet

3306

// TSHttpHdrTypeGet

3307

// TSHttpHdrUrlGet

3308

// TSHttpHdrUrlSet

3309

//////////////////////////////////////////////

3310

3311

/**

3312

* If you change value of any constant in this function then reflect that change in variable expected_iobuf.

3313

3314

REGRESSION_TEST(SDK_API_TSHttpHdr) (RegressionTest * test, int atype, int *pstatus)

3315

{

3316

NOWARN_UNUSED(atype);

3317

TSMBuffer bufp1 = (TSMBuffer) TS_ERROR_PTR;

3318

TSMBuffer bufp2 = (TSMBuffer) TS_ERROR_PTR;

3319

TSMBuffer bufp3 = (TSMBuffer) TS_ERROR_PTR;

3320

TSMBuffer bufp4 = (TSMBuffer) TS_ERROR_PTR;

3321

3322

TSMLoc hdr_loc1 = (TSMLoc) TS_ERROR_PTR;

3323

TSMLoc hdr_loc2 = (TSMLoc) TS_ERROR_PTR;

3324

TSMLoc hdr_loc3 = (TSMLoc) TS_ERROR_PTR;

3325

TSMLoc hdr_loc4 = (TSMLoc) TS_ERROR_PTR;

3326

3327

TSHttpType hdr1type;

3328

TSHttpType hdr2type;

3329

3330

const char *methodGet;

3331

3332

TSMLoc url_loc;

3333

TSMLoc url_loc_Get;

3334

const char *url_host = "www.example.com";

3335

int url_port = 2345;

3336

const char *url_path = "abcd/efg/hij.htm";

3337

3338

const char *response_reason = "aefa";

3339

const char *response_reason_get;

3340

3341

TSHttpStatus status_get;

3342

3343

int version_major = 2;

3344

int version_minor = 1;

3345

int version_get;

3346

3347

/* TSHttpType type1; unused: lv */

3348

/* TSHttpType type2; unused: lv */

3349

const char *method1;

3350

const char *method2;

3351

int length1;

3352

int length2;

3353

TSMLoc url_loc1;

3354

TSMLoc url_loc2;

3355

/* int version1; unused: lv */

3356

/* int version2; unused: lv */

3357

3358

int length;

3359

const char *expected_iobuf = "GET http://www.example.com:2345/abcd/efg/hij.htm HTTP/2.1\r\n\r\n";

3360

int actual_length;

3361

int expected_length;

3362

bool test_passed_Http_Hdr_Create = false;

3363

bool test_passed_Http_Hdr_Type = false;

3364

bool test_passed_Http_Hdr_Method = false;

3365

bool test_passed_Http_Hdr_Url = false;

3366

bool test_passed_Http_Hdr_Status = false;

3367

bool test_passed_Http_Hdr_Reason = false;

3368

bool test_passed_Http_Hdr_Reason_Lookup = false;

3369

bool test_passed_Http_Hdr_Version = false;

3370

bool test_passed_Http_Hdr_Copy = false;

3371

bool test_passed_Http_Hdr_Clone = false;

3372

bool test_passed_Http_Hdr_Length = false;

3373

bool test_passed_Http_Hdr_Print = false;

3374

bool test_passed_Http_Hdr_Destroy = false;

3375

bool try_print_function = true;

3376

bool test_buffer_created = true;

3377

3378

3379

*pstatus = REGRESSION_TEST_INPROGRESS;

3380

3381

if (((bufp1 = TSMBufferCreate()) == TS_ERROR_PTR) ||

3382

((bufp2 = TSMBufferCreate()) == TS_ERROR_PTR) ||

3383

((bufp3 = TSMBufferCreate()) == TS_ERROR_PTR) || ((bufp4 = TSMBufferCreate()) == TS_ERROR_PTR)

3384

) {

3385

SDK_RPRINT(test, "TSHttpHdr", "All Test Cases", TC_FAIL,

3386

"TSMBufferCreate returns TS_ERROR_PTR. Cannot test the functions");

3387

test_buffer_created = true;

3388

}

3389

// Create

3390

if (test_buffer_created == true) {

3391

if (((hdr_loc1 = TSHttpHdrCreate(bufp1)) == TS_ERROR_PTR) ||

3392

((hdr_loc2 = TSHttpHdrCreate(bufp2)) == TS_ERROR_PTR) ||

3393

((hdr_loc3 = TSHttpHdrCreate(bufp3)) == TS_ERROR_PTR)

3394

) {

3395

SDK_RPRINT(test, "TSHttpHdrCreate", "TestCase1|2|3", TC_FAIL, "TSHttpHdrCreate returns TS_ERROR_PTR.");

3396

} else {

3397

SDK_RPRINT(test, "TSHttpHdrCreate", "TestCase1&2&3", TC_PASS, "ok");

3398

test_passed_Http_Hdr_Create = true;

3399

}

3400

} else {

3401

SDK_RPRINT(test, "TSHttpHdrCreate", "All Test Cases", TC_FAIL, "Cannot run test as unable to allocate MBuffers");

3402

}

3403

3404

3405

// Type

3406

if (test_passed_Http_Hdr_Create == true) {

3407

if ((TSHttpHdrTypeSet(bufp1, hdr_loc1, TS_HTTP_TYPE_REQUEST) == TS_ERROR) ||

3408

(TSHttpHdrTypeSet(bufp2, hdr_loc2, TS_HTTP_TYPE_RESPONSE) == TS_ERROR)

3409

) {

3410

SDK_RPRINT(test, "TSHttpHdrTypeSet", "TestCase1|2", TC_FAIL, "TSHttpHdrTypeSet returns TS_ERROR");

3411

} else {

3412

if (((hdr1type = TSHttpHdrTypeGet(bufp1, hdr_loc1)) == (TSHttpType) TS_ERROR) ||

3413

((hdr2type = TSHttpHdrTypeGet(bufp2, hdr_loc2)) == (TSHttpType) TS_ERROR)

3414

) {

3415

SDK_RPRINT(test, "TSHttpHdrTypeSet&Get", "TestCase1|2", TC_FAIL, "TSHttpHdrTypeGet returns TS_ERROR");

3416

} else {

3417

if ((hdr1type == TS_HTTP_TYPE_REQUEST) && (hdr2type == TS_HTTP_TYPE_RESPONSE)) {

3418

SDK_RPRINT(test, "TSHttpHdrTypeSet&Get", "TestCase1&2", TC_PASS, "ok");

3419

test_passed_Http_Hdr_Type = true;

3420

} else {

3421

SDK_RPRINT(test, "TSHttpHdrTypeSet&Get", "TestCase1&2", TC_FAIL, "Values mismatch");

3422

}

3423

}

3424

}

3425

} else {

3426

SDK_RPRINT(test, "TSHttpHdrTypeSet&Get", "All Test Case", TC_FAIL,

3427

"Cannot run test as Header Creation Test failed");

3428

}

3429

3430

// Method

3431

if (test_passed_Http_Hdr_Type == true) {

3432

if (TSHttpHdrMethodSet(bufp1, hdr_loc1, TS_HTTP_METHOD_GET, -1) == TS_ERROR) {

3433

SDK_RPRINT(test, "TSHttpHdrMethodSet&Get", "TestCase1", TC_FAIL, "TSHttpHdrMethodSet returns TS_ERROR");

3434

} else {

3435

if ((methodGet = TSHttpHdrMethodGet(bufp1, hdr_loc1, &length)) == TS_ERROR_PTR) {

3436

SDK_RPRINT(test, "TSHttpHdrMethodSet&Get", "TestCase1", TC_FAIL, "TSHttpHdrMethodGet retuns TS_ERROR_PTR");

3437

} else {

3438

if ((strncmp(methodGet, TS_HTTP_METHOD_GET, length) == 0) && (length == (int) strlen(TS_HTTP_METHOD_GET))) {

3439

SDK_RPRINT(test, "TSHttpHdrMethodSet&Get", "TestCase1", TC_PASS, "ok");

3440

test_passed_Http_Hdr_Method = true;

3441

} else {

3442

SDK_RPRINT(test, "TSHttpHdrMethodSet&Get", "TestCase1", TC_FAIL, "Value's mismatch");

3443

}

3444

}

3445

}

3446

} else {

3447

SDK_RPRINT(test, "TSHttpHdrMethodSet&Get", "All Test Case", TC_FAIL,

3448

"Cannot run test as Header's Type cannot be set");

3449

}

3450

3451

// Url

3452

if (test_passed_Http_Hdr_Type == true) {

3453

if ((url_loc = TSUrlCreate(bufp1)) == TS_ERROR_PTR) {

3454

SDK_RPRINT(test, "TSHttpHdrUrlSet&Get", "TestCase1", TC_FAIL,

3455

"Cannot run test as TSUrlCreate returns TS_ERROR_PTR");

3456

} else {

3457

if (TSHttpHdrUrlSet(bufp1, hdr_loc1, url_loc) == TS_ERROR) {

3458

SDK_RPRINT(test, "TSHttpHdrUrlSet&Get", "TestCase1", TC_FAIL, "TSHttpHdrUrlSet returns TS_ERROR");

3459

} else {

3460

if ((url_loc_Get = TSHttpHdrUrlGet(bufp1, hdr_loc1)) == TS_ERROR_PTR) {

3461

SDK_RPRINT(test, "TSHttpHdrUrlSet&Get", "TestCase1", TC_FAIL, "TSHttpHdrUrlGet retuns TS_ERROR_PTR");

3462

} else {

3463

if (url_loc == url_loc_Get) {

3464

SDK_RPRINT(test, "TSHttpHdrUrlSet&Get", "TestCase1", TC_PASS, "ok");

3465

test_passed_Http_Hdr_Url = true;

3466

} else {

3467

SDK_RPRINT(test, "TSHttpHdrUrlSet&Get", "TestCase1", TC_FAIL, "Value's mismatch");

3468

}

3469

if (TSHandleMLocRelease(bufp1, hdr_loc1, url_loc_Get) == TS_ERROR) {

3470

SDK_RPRINT(test, "TSHandleMLocRelease", "", TC_FAIL, "Unable to release handle to URL");

3471

}

3472

}

3473

}

3474

3475

// Fill up the URL for Copy Test Case.

3476

if (TSUrlSchemeSet(bufp1, url_loc, TS_URL_SCHEME_HTTP, -1) == TS_ERROR) {

3477

SDK_RPRINT(test, "TSUrlSchemeSet", "", TC_FAIL, "Unable to set scheme in URL in the HTTP Header");

3478

try_print_function = false;

3479

}

3480

if (TSUrlHostSet(bufp1, url_loc, url_host, -1) == TS_ERROR) {

3481

SDK_RPRINT(test, "TSUrlHostSet", "", TC_FAIL, "Unable to set host in URL in the HTTP Header");

3482

try_print_function = false;

3483

}

3484

if (TSUrlPortSet(bufp1, url_loc, url_port) == TS_ERROR) {

3485

SDK_RPRINT(test, "TSUrlPortSet", "", TC_FAIL, "Unable to set port in URL in the HTTP Header");

3486

try_print_function = false;

3487

}

3488

if (TSUrlPathSet(bufp1, url_loc, url_path, -1) == TS_ERROR) {

3489

SDK_RPRINT(test, "TSUrlPathSet", "", TC_FAIL, "Unable to set path in URL in the HTTP Header");

3490

try_print_function = false;

3491

}

3492

if (TSHandleMLocRelease(bufp1, hdr_loc1, url_loc) == TS_ERROR) {

3493

SDK_RPRINT(test, "TSHandleMLocRelease", "", TC_FAIL, "Unable to release handle to URL");

3494

}

3495

}

3496

} else {

3497

SDK_RPRINT(test, "TSHttpHdrUrlSet&Get", "All Test Case", TC_FAIL,

3498

"Cannot run test as Header's Type cannot be set");

3499

}

3500

3501

// Reason

3502

if (test_passed_Http_Hdr_Type == true) {

3503

if (TSHttpHdrReasonSet(bufp2, hdr_loc2, response_reason, -1) == TS_ERROR) {

3504

SDK_RPRINT(test, "TSHttpHdrReasonSet&Get", "TestCase1", TC_FAIL, "TSHttpHdrReasonSet returns TS_ERROR");

3505

} else {

3506

if ((response_reason_get = TSHttpHdrReasonGet(bufp2, hdr_loc2, &length)) == TS_ERROR_PTR) {

3507

SDK_RPRINT(test, "TSHttpHdrReasonSet&Get", "TestCase1", TC_FAIL, "TSHttpHdrReasonGet returns TS_ERROR_PTR");

3508

} else {

3509

if ((strncmp(response_reason_get, response_reason, length) == 0) && (length == (int) strlen(response_reason))) {

3510

SDK_RPRINT(test, "TSHttpHdrReasonSet&Get", "TestCase1", TC_PASS, "ok");

3511

test_passed_Http_Hdr_Reason = true;

3512

} else {

3513

SDK_RPRINT(test, "TSHttpHdrReasonSet&Get", "TestCase1", TC_FAIL, "Value's mismatch");

3514

}

3515

}

3516

}

3517

} else {

3518

SDK_RPRINT(test, "TSHttpHdrReasonSet&Get", "All Test Case", TC_FAIL,

3519

"Cannot run test as Header's Type cannot be set");

3520

}

3521

3522

// Status

3523

if (test_passed_Http_Hdr_Type == true) {

3524

if (TSHttpHdrStatusSet(bufp2, hdr_loc2, TS_HTTP_STATUS_OK) == TS_ERROR) {

3525

SDK_RPRINT(test, "TSHttpHdrStatusSet&Get", "TestCase1", TC_FAIL, "TSHttpHdrStatusSet returns TS_ERROR");

3526

} else {

3527

if ((status_get = TSHttpHdrStatusGet(bufp2, hdr_loc2)) == (TSHttpStatus) TS_ERROR) {

3528

SDK_RPRINT(test, "TSHttpHdrStatusSet&Get", "TestCase1", TC_FAIL, "TSHttpHdrStatusGet returns TS_ERROR");

3529

} else {

3530

if (status_get == TS_HTTP_STATUS_OK) {

3531

SDK_RPRINT(test, "TSHttpHdrStatusSet&Get", "TestCase1", TC_PASS, "ok");

3532

test_passed_Http_Hdr_Status = true;

3533

} else {

3534

SDK_RPRINT(test, "TSHttpHdrStatusSet&Get", "TestCase1", TC_FAIL, "Value's mismatch");

3535

}

3536

}

3537

}

3538

} else {

3539

SDK_RPRINT(test, "TSHttpHdrStatusSet&Get", "All Test Case", TC_FAIL,

3540

"Cannot run test as Header's Type cannot be set");

3541

}

3542

3543

//Version

3544

if (test_passed_Http_Hdr_Type == true) {

3545

if (TSHttpHdrVersionSet(bufp1, hdr_loc1, TS_HTTP_VERSION(version_major, version_minor)) == TS_ERROR) {

3546

SDK_RPRINT(test, "TSHttpHdrVersionSet&Get", "TestCase1", TC_FAIL, "TSHttpHdrVersionSet returns TS_ERROR");

3547

} else {

3548

if ((version_get = TSHttpHdrVersionGet(bufp1, hdr_loc1)) == TS_ERROR) {

3549

SDK_RPRINT(test, "TSHttpHdrVersionSet&Get", "TestCase1", TC_FAIL, "TSHttpHdrVersionGet returns TS_ERROR");

3550

} else {

3551

if ((version_major == TS_HTTP_MAJOR(version_get)) && (version_minor == TS_HTTP_MINOR(version_get))) {

3552

SDK_RPRINT(test, "TSHttpHdrVersionSet&Get", "TestCase1", TC_PASS, "ok");

3553

test_passed_Http_Hdr_Version = true;

3554

} else {

3555

SDK_RPRINT(test, "TSHttpHdrVersionSet&Get", "TestCase1", TC_FAIL, "Value's mismatch");

3556

}

3557

}

3558

}

3559

} else {

3560

SDK_RPRINT(test, "TSHttpHdrVersionSet&Get", "All Test Case", TC_FAIL,

3561

"Cannot run test as Header's Type cannot be set");

3562

}

3563

3564

if (test_passed_Http_Hdr_Version == true) {

3565

if (TSHttpHdrVersionSet(bufp2, hdr_loc2, TS_HTTP_VERSION(version_major, version_minor)) == TS_ERROR) {

3566

SDK_RPRINT(test, "TSHttpHdrVersionSet&Get", "TestCase2", TC_FAIL, "TSHttpHdrVersionSet returns TS_ERROR");

3567

test_passed_Http_Hdr_Version = false;

3568

} else {

3569

if ((version_get = TSHttpHdrVersionGet(bufp2, hdr_loc2)) == TS_ERROR) {

3570

SDK_RPRINT(test, "TSHttpHdrVersionSet&Get", "TestCase2", TC_FAIL, "TSHttpHdrVersionGet returns TS_ERROR");

3571

test_passed_Http_Hdr_Version = false;

3572

} else {

3573

if ((version_major == TS_HTTP_MAJOR(version_get)) && (version_minor == TS_HTTP_MINOR(version_get))) {

3574

SDK_RPRINT(test, "TSHttpHdrVersionSet&Get", "TestCase2", TC_PASS, "ok");

3575

} else {

3576

SDK_RPRINT(test, "TSHttpHdrVersionSet&Get", "TestCase2", TC_FAIL, "Value's mismatch");

3577

test_passed_Http_Hdr_Version = false;

3578

}

3579

}

3580

}

3581

}

3582

//Reason Lookup

3583

if (strcmp("None", TSHttpHdrReasonLookup(TS_HTTP_STATUS_NONE)) != 0) {

3584

SDK_RPRINT(test, "TSHttpHdrReasonLookup", "TestCase1", TC_FAIL,

3585

"TSHttpHdrReasonLookup returns TS_ERROR_PTR or Value's mismatch");

3586

} else {

3587

SDK_RPRINT(test, "TSHttpHdrReasonLookup", "TestCase1", TC_PASS, "ok");

3588

test_passed_Http_Hdr_Reason_Lookup = true;

3589

}

3590

3591

if (strcmp("Ok", TSHttpHdrReasonLookup(TS_HTTP_STATUS_OK)) != 0) {

3592

SDK_RPRINT(test, "TSHttpHdrReasonLookup", "TestCase2", TC_FAIL,

3593

"TSHttpHdrReasonLookup returns TS_ERROR_PTR or Value's mismatch");

3594

if (test_passed_Http_Hdr_Reason_Lookup == true) {

3595

test_passed_Http_Hdr_Reason_Lookup = false;

3596

}

3597

} else {

3598

SDK_RPRINT(test, "TSHttpHdrReasonLookup", "TestCase2", TC_PASS, "ok");

3599

}

3600

3601

if (strcmp("Continue", TSHttpHdrReasonLookup(TS_HTTP_STATUS_CONTINUE)) != 0) {

3602

SDK_RPRINT(test, "TSHttpHdrReasonLookup", "TestCase3", TC_FAIL,

3603

"TSHttpHdrReasonLookup returns TS_ERROR_PTR or Value's mismatch");

3604

if (test_passed_Http_Hdr_Reason_Lookup == true) {

3605

test_passed_Http_Hdr_Reason_Lookup = false;

3606

}

3607

} else {

3608

SDK_RPRINT(test, "TSHttpHdrReasonLookup", "TestCase3", TC_PASS, "ok");

3609

}

3610

3611

if (strcmp("Not Modified", TSHttpHdrReasonLookup(TS_HTTP_STATUS_NOT_MODIFIED)) != 0) {

3612

SDK_RPRINT(test, "TSHttpHdrReasonLookup", "TestCase2", TC_FAIL,

3613

"TSHttpHdrReasonLookup returns TS_ERROR_PTR or Value's mismatch");

3614

if (test_passed_Http_Hdr_Reason_Lookup == true) {

3615

test_passed_Http_Hdr_Reason_Lookup = false;

3616

}

3617

} else {

3618

SDK_RPRINT(test, "TSHttpHdrReasonLookup", "TestCase4", TC_PASS, "ok");

3619

}

3620

3621

// Copy

3622

if (test_passed_Http_Hdr_Create == true) {

3623

if (TSHttpHdrCopy(bufp3, hdr_loc3, bufp1, hdr_loc1) == TS_ERROR) {

3624

SDK_RPRINT(test, "TSHttpHdrCopy", "TestCase1", TC_FAIL, "TSHttpHdrCopy returns TS_ERROR");

3625

} else {

3626

3627

bool flag = true;

3628

// Check the type

3629

if (flag == true) {

3630

TSHttpType type1;

3631

TSHttpType type2;

3632

3633

if (((type1 = TSHttpHdrTypeGet(bufp1, hdr_loc1)) == (TSHttpType) TS_ERROR) ||

3634

((type2 = TSHttpHdrTypeGet(bufp3, hdr_loc3)) == (TSHttpType) TS_ERROR)

3635

) {

3636

SDK_RPRINT(test, "TSHttpHdrCopy", "TestCase1", TC_FAIL, "TSHttpTypeGet returns TS_ERROR.");

3637

flag = false;

3638

} else {

3639

if (type1 != type2) {

3640

SDK_RPRINT(test, "TSHttpHdrCopy", "TestCase1", TC_FAIL, "Type mismatch in both headers");

3641

flag = false;

3642

}

3643

}

3644

}

3645

// Check the Version

3646

if (flag == true) {

3647

int version1;

3648

int version2;

3649

3650

if (((version1 = TSHttpHdrVersionGet(bufp1, hdr_loc1)) == TS_ERROR) ||

3651

((version2 = TSHttpHdrVersionGet(bufp3, hdr_loc3)) == TS_ERROR)

3652

) {

3653

SDK_RPRINT(test, "TSHttpHdrCopy", "TestCase1", TC_FAIL, "TSHttpVersionGet returns TS_ERROR");

3654

flag = false;

3655

} else {

3656

if (version1 != version2) {

3657

SDK_RPRINT(test, "TSHttpHdrCopy", "TestCase1", TC_FAIL, "Version mismatch in both headers");

3658

flag = false;

3659

}

3660

}

3661

}

3662

// Check the Method

3663

if (flag == true) {

3664

3665

if (((method1 = TSHttpHdrMethodGet(bufp1, hdr_loc1, &length1)) == TS_ERROR_PTR) ||

3666

((method2 = TSHttpHdrMethodGet(bufp3, hdr_loc3, &length2)) == TS_ERROR_PTR)

3667

) {

3668

SDK_RPRINT(test, "TSHttpHdrCopy", "TestCase1", TC_FAIL, "TSHttpVersionGet returns TS_ERROR");

3669

flag = false;

3670

} else {

3671

if ((length1 != length2) || (strncmp(method1, method2, length1) != 0)) {

3672

SDK_RPRINT(test, "TSHttpHdrCopy", "TestCase1", TC_FAIL, "Method mismatch in both headers");

3673

flag = false;

3674

}

3675

}

3676

}

3677

// Check the URL

3678

if (flag == true) {

3679

3680

if (((url_loc1 = TSHttpHdrUrlGet(bufp1, hdr_loc1)) == TS_ERROR_PTR) ||

3681

((url_loc2 = TSHttpHdrUrlGet(bufp3, hdr_loc3)) == TS_ERROR_PTR)

3682

) {

3683

SDK_RPRINT(test, "TSHttpHdrCopy", "TestCase1", TC_FAIL, "TSHttpVersionGet returns TS_ERROR");

3684

flag = false;

3685

} else {

3686

const char *scheme1;

3687

const char *scheme2;

3688

3689

const char *host1;

3690

const char *host2;

3691

3692

int port1;

3693

int port2;

3694

3695

const char *path1;

3696

const char *path2;

3697

3698

// URL Scheme

3699

if (((scheme1 = TSUrlSchemeGet(bufp1, url_loc1, &length1)) == TS_ERROR_PTR) ||

3700

((scheme2 = TSUrlSchemeGet(bufp3, url_loc2, &length2)) == TS_ERROR_PTR)

3701

) {

3702

SDK_RPRINT(test, "TSHttpHdrCopy", "TestCase1", TC_FAIL, "TSUrlSchemeGet returns TS_ERROR_PTR");

3703

flag = false;

3704

} else {

3705

if ((length1 != length2) || (strncmp(scheme1, scheme2, length1) != 0)) {

3706

SDK_RPRINT(test, "TSHttpHdrCopy", "TestCase1", TC_FAIL,

3707

"Url Scheme has different values in both headers");

3708

flag = false;

3709

}

3710

}

3711

3712

// URL Host

3713

if (flag == true) {

3714

if (((host1 = TSUrlHostGet(bufp1, url_loc1, &length1)) == TS_ERROR_PTR) ||

3715

((host2 = TSUrlHostGet(bufp3, url_loc2, &length2)) == TS_ERROR_PTR)

3716

) {

3717

SDK_RPRINT(test, "TSHttpHdrCopy", "TestCase1", TC_FAIL, "TSUrlHostGet returns TS_ERROR_PTR");

3718

flag = false;

3719

} else {

3720

if ((length1 != length2) || (strncmp(host1, host2, length1) != 0)) {

3721

SDK_RPRINT(test, "TSHttpHdrCopy", "TestCase1", TC_FAIL,

3722

"Url Host has different values in both headers");

3723

flag = false;

3724

}

3725

}

3726

}

3727

// URL Port

3728

if (flag == true) {

3729

if (((port1 = TSUrlPortGet(bufp1, url_loc1)) == TS_ERROR) ||

3730

((port2 = TSUrlPortGet(bufp3, url_loc2)) == TS_ERROR)

3731

) {

3732

SDK_RPRINT(test, "TSHttpHdrCopy", "TestCase1", TC_FAIL, "TSUrlPortGet returns TS_ERROR");

3733

flag = false;

3734

} else {

3735

if (port1 != port2) {

3736

SDK_RPRINT(test, "TSHttpHdrCopy", "TestCase1", TC_FAIL,

3737

"Url Port has different values in both headers");

3738

flag = false;

3739

}

3740

}

3741

}

3742

// URL Path

3743

if (flag == true) {

3744

if (((path1 = TSUrlPathGet(bufp1, url_loc1, &length1)) == TS_ERROR_PTR) ||

3745

((path2 = TSUrlPathGet(bufp3, url_loc2, &length2)) == TS_ERROR_PTR)

3746

) {

3747

SDK_RPRINT(test, "TSHttpHdrCopy", "TestCase1", TC_FAIL, "TSUrlPathGet returns TS_ERROR_PTR");

3748

flag = false;

3749

} else {

3750

if ((path1 != NULL) && (path2 != NULL)) {

3751

if ((length1 != length2) || (strncmp(path1, path2, length1) != 0)) {

3752

SDK_RPRINT(test, "TSHttpHdrCopy", "TestCase1", TC_FAIL,

3753

"Url Path has different values in both headers");

3754

flag = false;

3755

}

3756

} else {

3757

if (path1 != path2) {

3758

SDK_RPRINT(test, "TSHttpHdrCopy", "TestCase1", TC_FAIL,

3759

"Url Host has different values in both headers");

3760

flag = false;

3761

}

3762

}

3763

}

3764

if ((TSHandleMLocRelease(bufp1, hdr_loc1, url_loc1) == TS_ERROR) ||

3765

(TSHandleMLocRelease(bufp3, hdr_loc3, url_loc2) == TS_ERROR)

3766

) {

3767

SDK_RPRINT(test, "TSHandleMLocRelease", "", TC_FAIL,

3768

"Unable to release Handle acquired by TSHttpHdrUrlGet");

3769

}

3770

}

3771

3772

if (flag == true) {

3773

SDK_RPRINT(test, "TSHttpHdrCopy", "TestCase1", TC_PASS, "ok");

3774

test_passed_Http_Hdr_Copy = true;

3775

}

3776

}

3777

}

3778

}

3779

} else {

3780

SDK_RPRINT(test, "TSHttpHdrCopy", "All Test Cases", TC_PASS, "Cannot run test as TSHttpHdrCreate has failed");

3781

}

3782

3783

// Clone

3784

if (test_passed_Http_Hdr_Create == true) {

3785

if ((hdr_loc4 = TSHttpHdrClone(bufp4, bufp1, hdr_loc1)) == TS_ERROR_PTR) {

3786

SDK_RPRINT(test, "TSHttpHdrClone", "TestCase1", TC_FAIL, "TSHttpHdrClone returns TS_ERROR_PTR");

3787

} else {

3788

3789

bool flag = true;

3790

// Check the type

3791

if (flag == true) {

3792

TSHttpType type1;

3793

TSHttpType type2;

3794

3795

if (((type1 = TSHttpHdrTypeGet(bufp1, hdr_loc1)) == (TSHttpType) TS_ERROR) ||

3796

((type2 = TSHttpHdrTypeGet(bufp4, hdr_loc4)) == (TSHttpType) TS_ERROR)

3797

) {

3798

SDK_RPRINT(test, "TSHttpHdrClone", "TestCase1", TC_FAIL, "TSHttpTypeGet returns TS_ERROR.");

3799

flag = false;

3800

} else {

3801

if (type1 != type2) {

3802

SDK_RPRINT(test, "TSHttpHdrClone", "TestCase1", TC_FAIL, "Type mismatch in both headers");

3803

flag = false;

3804

}

3805

}

3806

}

3807

// Check the Version

3808

if (flag == true) {

3809

int version1;

3810

int version2;

3811

3812

if (((version1 = TSHttpHdrVersionGet(bufp1, hdr_loc1)) == TS_ERROR) ||

3813

((version2 = TSHttpHdrVersionGet(bufp4, hdr_loc4)) == TS_ERROR)

3814

) {

3815

SDK_RPRINT(test, "TSHttpHdrClone", "TestCase1", TC_FAIL, "TSHttpVersionGet returns TS_ERROR");

3816

flag = false;

3817

} else {

3818

if (version1 != version2) {

3819

SDK_RPRINT(test, "TSHttpHdrClone", "TestCase1", TC_FAIL, "Version mismatch in both headers");

3820

flag = false;

3821

}

3822

}

3823

}

3824

// Check the Method

3825

if (flag == true) {

3826

3827

if (((method1 = TSHttpHdrMethodGet(bufp1, hdr_loc1, &length1)) == TS_ERROR_PTR) ||

3828

((method2 = TSHttpHdrMethodGet(bufp4, hdr_loc4, &length2)) == TS_ERROR_PTR)

3829

) {

3830

SDK_RPRINT(test, "TSHttpHdrClone", "TestCase1", TC_FAIL, "TSHttpVersionGet returns TS_ERROR");

3831

flag = false;

3832

} else {

3833

if ((length1 != length2) || (strncmp(method1, method2, length1) != 0)) {

3834

SDK_RPRINT(test, "TSHttpHdrClone", "TestCase1", TC_FAIL, "Method mismatch in both headers");

3835

flag = false;

3836

}

3837

}

3838

}

3839

// Check the URL

3840

if (flag == true) {

3841

3842

if (((url_loc1 = TSHttpHdrUrlGet(bufp1, hdr_loc1)) == TS_ERROR_PTR) ||

3843

((url_loc2 = TSHttpHdrUrlGet(bufp4, hdr_loc4)) == TS_ERROR_PTR)

3844

) {

3845

SDK_RPRINT(test, "TSHttpHdrClone", "TestCase1", TC_FAIL, "TSHttpVersionGet returns TS_ERROR");

3846

flag = false;

3847

} else {

3848

const char *scheme1;

3849

const char *scheme2;

3850

3851

const char *host1;

3852

const char *host2;

3853

3854

int port1;

3855

int port2;

3856

3857

const char *path1;

3858

const char *path2;

3859

3860

// URL Scheme

3861

if (((scheme1 = TSUrlSchemeGet(bufp1, url_loc1, &length1)) == TS_ERROR_PTR) ||

3862

((scheme2 = TSUrlSchemeGet(bufp4, url_loc2, &length2)) == TS_ERROR_PTR)

3863

) {

3864

SDK_RPRINT(test, "TSHttpHdrClone", "TestCase1", TC_FAIL, "TSUrlSchemeGet returns TS_ERROR_PTR");

3865

flag = false;

3866

} else {

3867

if ((length1 != length2) || (strncmp(scheme1, scheme2, length1) != 0)) {

3868

SDK_RPRINT(test, "TSHttpHdrClone", "TestCase1", TC_FAIL,

3869

"Url Scheme has different values in both headers");

3870

flag = false;

3871

}

3872

}

3873

3874

3875

// URL Host

3876

if (flag == true) {

3877

if (((host1 = TSUrlHostGet(bufp1, url_loc1, &length1)) == TS_ERROR_PTR) ||

3878

((host2 = TSUrlHostGet(bufp4, url_loc2, &length2)) == TS_ERROR_PTR)

3879

) {

3880

SDK_RPRINT(test, "TSHttpHdrClone", "TestCase1", TC_FAIL, "TSUrlHostGet returns TS_ERROR_PTR");

3881

flag = false;

3882

} else {

3883

if ((length1 != length2) || (strncmp(host1, host2, length1) != 0)) {

3884

SDK_RPRINT(test, "TSHttpHdrClone", "TestCase1", TC_FAIL,

3885

"Url Host has different values in both headers");

3886

flag = false;

3887

}

3888

}

3889

}

3890

// URL Port

3891

if (flag == true) {

3892

if (((port1 = TSUrlPortGet(bufp1, url_loc1)) == TS_ERROR) ||

3893

((port2 = TSUrlPortGet(bufp4, url_loc2)) == TS_ERROR)

3894

) {

3895

SDK_RPRINT(test, "TSHttpHdrClone", "TestCase1", TC_FAIL, "TSUrlPortGet returns TS_ERROR");

3896

flag = false;

3897

} else {

3898

if (port1 != port2) {

3899

SDK_RPRINT(test, "TSHttpHdrClone", "TestCase1", TC_FAIL,

3900

"Url Port has different values in both headers");

3901

flag = false;

3902

}

3903

}

3904

}

3905

// URL Path

3906

if (flag == true) {

3907

if (((path1 = TSUrlPathGet(bufp1, url_loc1, &length1)) == TS_ERROR_PTR) ||

3908

((path2 = TSUrlPathGet(bufp4, url_loc2, &length2)) == TS_ERROR_PTR)

3909

) {

3910

SDK_RPRINT(test, "TSHttpHdrClone", "TestCase1", TC_FAIL, "TSUrlPathGet returns TS_ERROR_PTR");

3911

flag = false;

3912

} else {

3913

if ((path1 != NULL) && (path2 != NULL)) {

3914

if ((length1 != length2) || (strncmp(path1, path2, length1) != 0)) {

3915

SDK_RPRINT(test, "TSHttpHdrCopy", "TestCase1", TC_FAIL,

3916

"Url Path has different values in both headers");

3917

flag = false;

3918

}

3919

} else {

3920

if (path1 != path2) {

3921

SDK_RPRINT(test, "TSHttpHdrCopy", "TestCase1", TC_FAIL,

3922

"Url Host has different values in both headers");

3923

flag = false;

3924

}

3925

}

3926

}

3927

if ((TSHandleMLocRelease(bufp1, hdr_loc1, url_loc1) == TS_ERROR) ||

3928

(TSHandleMLocRelease(bufp4, hdr_loc4, url_loc2) == TS_ERROR)

3929

) {

3930

SDK_RPRINT(test, "TSHandleMLocRelease", "", TC_FAIL,

3931

"Unable to release Handle acquired by TSHttpHdrUrlGet");

3932

}

3933

}

3934

3935

if (flag == true) {

3936

SDK_RPRINT(test, "TSHttpHdrClone", "TestCase1", TC_PASS, "ok");

3937

test_passed_Http_Hdr_Clone = true;

3938

}

3939

}

3940

}

3941

}

3942

} else {

3943

SDK_RPRINT(test, "TSHttpHdrClone", "All Test Cases", TC_PASS, "Cannot run test as TSHttpHdrCreate has failed");

3944

}

3945

3946

3947

//LengthGet

3948

if (test_passed_Http_Hdr_Create == true) {

3949

if ((actual_length = TSHttpHdrLengthGet(bufp1, hdr_loc1)) == TS_ERROR) {

3950

SDK_RPRINT(test, "TSHttpHdrLengthGet", "TestCase1", TC_FAIL, "TSHttpHdrLengthGet returns TS_ERROR");

3951

} else {

3952

TSIOBuffer iobuf;

3953

3954

if ((iobuf = TSIOBufferCreate()) == TS_ERROR_PTR) {

3955

SDK_RPRINT(test, "TSHttpHdrLengthGet", "TestCase1", TC_FAIL,

3956

"Cannot create iobuffer. Cannot continue with test");

3957

} else {

3958

if (TSHttpHdrPrint(bufp1, hdr_loc1, iobuf) == TS_ERROR) {

3959

SDK_RPRINT(test, "TSHttpHdrLengthGet", "TestCase1", TC_FAIL, "TSHttpHdrPrint returned TS_ERROR");

3960

} else {

3961

TSIOBufferReader iobufreader;

3962

if ((iobufreader = TSIOBufferReaderAlloc(iobuf)) == TS_ERROR_PTR) {

3963

SDK_RPRINT(test, "TSHttpHdrLengthGet", "TestCase1", TC_FAIL, "Cannot allocate a reader to io buffer");

3964

} else {

3965

if ((expected_length = TSIOBufferReaderAvail(iobufreader)) == TS_ERROR) {

3966

SDK_RPRINT(test, "TSHttpHdrLengthGet", "TestCase1", TC_FAIL,

3967

"Cannot calculate the length to be expected.");

3968

} else {

3969

if (actual_length == expected_length) {

3970

SDK_RPRINT(test, "TSHttpHdrLengthGet", "TestCase1", TC_PASS, "ok");

3971

test_passed_Http_Hdr_Length = true;

3972

} else {

3973

SDK_RPRINT(test, "TSHttpHdrLengthGet", "TestCase1", TC_FAIL, "Incorrect value returned.");

3974

}

3975

}

3976

}

3977

3978

// Print.

3979

if ((test_passed_Http_Hdr_Method == true) && (test_passed_Http_Hdr_Url == true) &&

3980

(test_passed_Http_Hdr_Version == true) && (test_passed_Http_Hdr_Length == true) &&

3981

(try_print_function == true)

3982

) {

3983

char *actual_iobuf = NULL;

3984

3985

actual_iobuf = (char *) TSmalloc((actual_length + 1) * sizeof(char));

3986

3987

if (actual_iobuf == NULL) {

3988

SDK_RPRINT(test, "TSHttpHdrPrint", "TestCase1", TC_FAIL, "Unable to allocate memory");

3989

} else {

3990

3991

TSIOBufferBlock iobufblock;

3992

int64_t bytes_read;

3993

3994

memset(actual_iobuf, 0, (actual_length + 1) * sizeof(char));

3995

bytes_read = 0;

3996

3997

iobufblock = TSIOBufferReaderStart(iobufreader);

3998

3999

while ((iobufblock != NULL) && (iobufblock != TS_ERROR_PTR)) {

4000

const char *block_start;

4001

int64_t block_size;

4002

block_start = TSIOBufferBlockReadStart(iobufblock, iobufreader, &block_size);

4003

4004

if ((block_start == TS_ERROR_PTR) || (block_size == 0) || (block_size == TS_ERROR)) {

4005

break;

4006

}

4007

4008

memcpy(actual_iobuf + bytes_read, block_start, block_size);

4009

bytes_read += block_size;

4010

4011

4012

if (TSIOBufferReaderConsume(iobufreader,block_size)==TS_ERROR) {

4013

break;

4014

}

4015

4016

TSIOBufferReaderConsume(iobufreader, block_size);

4017

iobufblock = TSIOBufferReaderStart(iobufreader);

4018

}

4019

if (strcmp(actual_iobuf, expected_iobuf) == 0) {

4020

SDK_RPRINT(test, "TSHttpHdrPrint", "TestCase1", TC_PASS, "ok");

4021

test_passed_Http_Hdr_Print = true;

4022

} else {

4023

SDK_RPRINT(test, "TSHttpHdrPrint", "TestCase1", TC_FAIL, "Value's mismatch");

4024

}

4025

4026

TSfree(actual_iobuf);

4027

4028

if ((TSIOBufferReaderFree(iobufreader)==TS_ERROR) ||

4029

(TSIOBufferDestroy(iobuf)==TS_ERROR)

4030

) {

4031

SDK_RPRINT(test,"TSIOBuffer","",TC_FAIL,"Unable to free memory");

4032

}

4033

4034

TSIOBufferReaderFree(iobufreader);

4035

TSIOBufferDestroy(iobuf);

4036

}

4037

} else {

4038

SDK_RPRINT(test, "TSHttpHdrPrint", "TestCase1", TC_FAIL, "Unable to run test for TSHttpHdrPrint");

4039

}

4040

4041

}

4042

}

4043

}

4044

} else {

4045

SDK_RPRINT(test, "TSHttpHdrLengthGet", "All Test Cases", TC_PASS,

4046

"Cannot run test as TSHttpHdrCreate has failed");

4047

}

4048

4049

// Destroy

4050

if (test_passed_Http_Hdr_Create == true) {

4051

if ((TSHttpHdrDestroy(bufp1, hdr_loc1) == TS_ERROR) ||

4052

(TSHttpHdrDestroy(bufp2, hdr_loc2) == TS_ERROR) ||

4053

(TSHttpHdrDestroy(bufp3, hdr_loc3) == TS_ERROR) || (TSHttpHdrDestroy(bufp4, hdr_loc4) == TS_ERROR)

4054

) {

4055

SDK_RPRINT(test, "TSHttpHdrDestroy", "TestCase1|2|3|4", TC_FAIL, "TSHttpHdrDestroy returns TS_ERROR.");

4056

} else {

4057

if ((TSHandleMLocRelease(bufp1, TS_NULL_MLOC, hdr_loc1) == TS_ERROR) ||

4058

(TSHandleMLocRelease(bufp2, TS_NULL_MLOC, hdr_loc2) == TS_ERROR) ||

4059

(TSHandleMLocRelease(bufp3, TS_NULL_MLOC, hdr_loc3) == TS_ERROR) ||

4060

(TSHandleMLocRelease(bufp4, TS_NULL_MLOC, hdr_loc4) == TS_ERROR)

4061

) {

4062

SDK_RPRINT(test, "TSHandleMLocRelease", "TestCase1|2|3|4", TC_FAIL, "Unable to release the handle to headers");

4063

}

4064

SDK_RPRINT(test, "TSHttpHdrDestroy", "TestCase1&2&3&4", TC_PASS, "ok");

4065

test_passed_Http_Hdr_Destroy = true;

4066

}

4067

} else {

4068

SDK_RPRINT(test, "TSHttpHdrDestroy", "All Test Cases", TC_FAIL, "Cannot run test as header was not created");

4069

}

4070

4071

if (bufp1 != TS_ERROR_PTR) {

4072

if (TSMBufferDestroy(bufp1) == TS_ERROR) {

4073

SDK_RPRINT(test, "TSMBufferDestroy", "TestCase1", TC_FAIL, "Unable to destroy MBuffer");

4074

}

4075

}

4076

4077

if (bufp2 != TS_ERROR_PTR) {

4078

if (TSMBufferDestroy(bufp2) == TS_ERROR) {

4079

SDK_RPRINT(test, "TSMBufferDestroy", "TestCase2", TC_FAIL, "Unable to destroy MBuffer");

4080

}

4081

}

4082

4083

if (bufp3 != TS_ERROR_PTR) {

4084

if (TSMBufferDestroy(bufp3) == TS_ERROR) {

4085

SDK_RPRINT(test, "TSMBufferDestroy", "TestCase3", TC_FAIL, "Unable to destroy MBuffer");

4086

}

4087

}

4088

4089

if (bufp4 != TS_ERROR_PTR) {

4090

if (TSMBufferDestroy(bufp4) == TS_ERROR) {

4091

SDK_RPRINT(test, "TSMBufferDestroy", "TestCase4", TC_FAIL, "Unable to destroy MBuffer");

4092

}

4093

}

4094

4095

if ((test_passed_Http_Hdr_Create == true) &&

4096

(test_passed_Http_Hdr_Type == true) &&

4097

(test_passed_Http_Hdr_Method == true) &&

4098

(test_passed_Http_Hdr_Url == true) &&

4099

(test_passed_Http_Hdr_Status == true) &&

4100

(test_passed_Http_Hdr_Reason == true) &&

4101

(test_passed_Http_Hdr_Reason_Lookup == true) &&

4102

(test_passed_Http_Hdr_Version == true) &&

4103

(test_passed_Http_Hdr_Copy == true) &&

4104

(test_passed_Http_Hdr_Clone == true) &&

4105

(test_passed_Http_Hdr_Length == true) &&

4106

(test_passed_Http_Hdr_Print == true) && (test_passed_Http_Hdr_Destroy == true)

4107

) {

4108

*pstatus = REGRESSION_TEST_PASSED;

4109

} else {

4110

*pstatus = REGRESSION_TEST_FAILED;

4111

}

4112

4113

return;

4114

4115

}

4116

4117

4118

//////////////////////////////////////////////

4119

// SDK_API_TSMimeHdrField

4120

4121

// Unit Test for API: TSMBufferCreate

4122

// TSMBufferDestroy

4123

// TSMimeHdrCreate

4124

// TSMimeHdrDestroy

4125

// TSMimeHdrFieldCreate

4126

// TSMimeHdrFieldDestroy

4127

// TSMimeHdrFieldFind

4128

// TSMimeHdrFieldGet

4129

// TSMimeHdrFieldAppend

4130

// TSMimeHdrFieldNameGet

4131

// TSMimeHdrFieldNameSet

4132

// TSMimeHdrFieldNext

4133

// TSMimeHdrFieldsClear

4134

// TSMimeHdrFieldsCount

4135

// TSMimeHdrFieldValueAppend

4136

// TSMimeHdrFieldValueDelete

4137

// TSMimeHdrFieldValueStringGet

4138

// TSMimeHdrFieldValueDateGet

4139

// TSMimeHdrFieldValueIntGet

4140

// TSMimeHdrFieldValueUintGet

4141

// TSMimeHdrFieldValueStringInsert

4142

// TSMimeHdrFieldValueDateInsert

4143

// TSMimeHdrFieldValueIntInsert

4144

// TSMimeHdrFieldValueUintInsert

4145

// TSMimeHdrFieldValuesClear

4146

// TSMimeHdrFieldValuesCount

4147

// TSMimeHdrFieldValueStringSet

4148

// TSMimeHdrFieldValueDateSet

4149

// TSMimeHdrFieldValueIntSet

4150

// TSMimeHdrFieldValueUintSet

4151

// TSMimeHdrLengthGet

4152

// TSMimeHdrPrint

4153

//////////////////////////////////////////////

4154

4155

TSReturnCode

4156

compare_field_names(RegressionTest * test, TSMBuffer bufp1, TSMLoc mime_loc1, TSMLoc field_loc1, TSMBuffer bufp2,

4157

TSMLoc mime_loc2, TSMLoc field_loc2)

4158

{

4159

NOWARN_UNUSED(test);

4160

const char *name1;

4161

const char *name2;

4162

int length1;

4163

int length2;

4164

4165

if ((name1 = TSMimeHdrFieldNameGet(bufp1, mime_loc1, field_loc1, &length1)) == TS_ERROR_PTR) {

4166

return TS_ERROR;

4167

}

4168

4169

if ((name2 = TSMimeHdrFieldNameGet(bufp2, mime_loc2, field_loc2, &length2)) == TS_ERROR_PTR) {

4170

return TS_ERROR;

4171

}

4172

4173

if ((length1 == length2) && (strncmp(name1, name2, length1) == 0) ) {

4174

return TS_SUCCESS;

4175

} else {

4176

return TS_ERROR;

4177

}

4178

}

4179

4180

REGRESSION_TEST(SDK_API_TSMimeHdrField) (RegressionTest * test, int atype, int *pstatus)

4181

{

4182

NOWARN_UNUSED(atype);

4183

TSMBuffer bufp1 = (TSMBuffer) TS_ERROR_PTR;

4184

4185

TSMLoc mime_loc1 = (TSMLoc) TS_ERROR_PTR;

4186

4187

TSMLoc field_loc11 = (TSMLoc) TS_ERROR_PTR;

4188

TSMLoc field_loc12 = (TSMLoc) TS_ERROR_PTR;

4189

TSMLoc field_loc13 = (TSMLoc) TS_ERROR_PTR;

4190

TSMLoc field_loc14 = (TSMLoc) TS_ERROR_PTR;

4191

TSMLoc field_loc15 = (TSMLoc) TS_ERROR_PTR;

4192

4193

4194

const char *field1Name = "field1";

4195

const char *field2Name = "field2";

4196

const char *field3Name = "field3";

4197

const char *field4Name = "field4";

4198

const char *field5Name = "field5";

4199

4200

const char *field1NameGet;

4201

const char *field2NameGet;

4202

const char *field3NameGet;

4203

const char *field4NameGet;

4204

const char *field5NameGet;

4205

4206

int field1NameGetLength;

4207

int field2NameGetLength;

4208

int field3NameGetLength;

4209

int field4NameGetLength;

4210

int field5NameGetLength;

4211

4212

int field1_length;

4213

int field2_length;

4214

int field3_length;

4215

int field4_length;

4216

/* int field5_length; unused: lv */

4217

4218

TSMLoc test_field_loc11 = (TSMLoc) TS_ERROR_PTR;

4219

TSMLoc test_field_loc12 = (TSMLoc) TS_ERROR_PTR;

4220

TSMLoc test_field_loc13 = (TSMLoc) TS_ERROR_PTR;

4221

TSMLoc test_field_loc14 = (TSMLoc) TS_ERROR_PTR;

4222

TSMLoc test_field_loc15 = (TSMLoc) TS_ERROR_PTR;

4223

4224

int actualNumberOfFields;

4225

int numberOfFields;

4226

4227

const char *field1Value1 = "field1Value1";

4228

const char *field1Value2 = "field1Value2";

4229

const char *field1Value3 = "field1Value3";

4230

const char *field1Value4 = "field1Value4";

4231

const char *field1Value5 = "field1Value5";

4232

const char *field1ValueNew = "newfieldValue";

4233

4234

const char *field1Value1Get;

4235

const char *field1Value2Get;

4236

const char *field1Value3Get;

4237

const char *field1Value4Get;

4238

const char *field1Value5Get;

4239

const char *field1ValueNewGet;

4240

4241

int lengthField1Value1;

4242

int lengthField1Value2;

4243

int lengthField1Value3;

4244

int lengthField1Value4;

4245

int lengthField1Value5;

4246

int lengthField1ValueNew;

4247

4248

time_t field2Value1 = time(NULL);

4249

time_t field2Value1Get;

4250

time_t field2ValueNew;

4251

time_t field2ValueNewGet;

4252

4253

int field3Value1 = 31;

4254

int field3Value2 = 32;

4255

int field3Value3 = 33;

4256

int field3Value4 = 34;

4257

int field3Value5 = 35;

4258

int field3ValueNew = 30;

4259

4260

int field3Value1Get;

4261

int field3Value2Get;

4262

int field3Value3Get;

4263

int field3Value4Get;

4264

int field3Value5Get;

4265

int field3ValueNewGet;

4266

4267

unsigned int field4Value1 = 41;

4268

unsigned int field4Value2 = 42;

4269

unsigned int field4Value3 = 43;

4270

unsigned int field4Value4 = 44;

4271

unsigned int field4Value5 = 45;

4272

unsigned int field4ValueNew = 40;

4273

4274

unsigned int field4Value1Get;

4275

unsigned int field4Value2Get;

4276

unsigned int field4Value3Get;

4277

unsigned int field4Value4Get;

4278

unsigned int field4Value5Get;

4279

unsigned int field4ValueNewGet;

4280

4281

const char *field5Value1 = "field5Value1";

4282

const char *field5Value1Append = "AppendedValue";

4283

const char *fieldValueAppendGet;

4284

int lengthFieldValueAppended;

4285

int field5Value2 = 52;

4286

const char *field5Value3 = "DeleteValue";

4287

const char *fieldValueDeleteGet;

4288

int lengthFieldValueDeleteGet;

4289

unsigned int field5Value4 = 54;

4290

int numberOfValueInField;

4291

4292

TSMLoc field_loc;

4293

4294

bool test_passed_MBuffer_Create = false;

4295

bool test_passed_Mime_Hdr_Create = false;

4296

bool test_passed_Mime_Hdr_Field_Create = false;

4297

bool test_passed_Mime_Hdr_Field_Name = false;

4298

bool test_passed_Mime_Hdr_Field_Append = false;

4299

bool test_passed_Mime_Hdr_Field_Get = false;

4300

bool test_passed_Mime_Hdr_Field_Next = false;

4301

bool test_passed_Mime_Hdr_Fields_Count = false;

4302

bool test_passed_Mime_Hdr_Field_Value_String_Insert = false;

4303

bool test_passed_Mime_Hdr_Field_Value_String_Get = false;

4304

bool test_passed_Mime_Hdr_Field_Value_String_Set = false;

4305

bool test_passed_Mime_Hdr_Field_Value_Date_Insert = false;

4306

bool test_passed_Mime_Hdr_Field_Value_Date_Get = false;

4307

bool test_passed_Mime_Hdr_Field_Value_Date_Set = false;

4308

bool test_passed_Mime_Hdr_Field_Value_Int_Insert = false;

4309

bool test_passed_Mime_Hdr_Field_Value_Int_Get = false;

4310

bool test_passed_Mime_Hdr_Field_Value_Int_Set = false;

4311

bool test_passed_Mime_Hdr_Field_Value_Uint_Insert = false;

4312

bool test_passed_Mime_Hdr_Field_Value_Uint_Get = false;

4313

bool test_passed_Mime_Hdr_Field_Value_Uint_Set = false;

4314

bool test_passed_Mime_Hdr_Field_Value_Append = false;

4315

bool test_passed_Mime_Hdr_Field_Value_Delete = false;

4316

bool test_passed_Mime_Hdr_Field_Values_Clear = false;

4317

bool test_passed_Mime_Hdr_Field_Values_Count = false;

4318

bool test_passed_Mime_Hdr_Field_Destroy = false;

4319

bool test_passed_Mime_Hdr_Fields_Clear = false;

4320

bool test_passed_Mime_Hdr_Destroy = false;

4321

bool test_passed_MBuffer_Destroy = false;

4322

bool test_passed_Mime_Hdr_Field_Length_Get = false;

4323

4324

*pstatus = REGRESSION_TEST_INPROGRESS;

4325

4326

// TSMBufferCreate

4327

if ((bufp1 = TSMBufferCreate()) == TS_ERROR_PTR) {

4328

// Cannot proceed with tests.

4329

SDK_RPRINT(test, "TSMBufferCreate", "TestCase1", TC_FAIL, "TSMBufferCreate Returns TS_ERROR_PTR");

4330

} else {

4331

SDK_RPRINT(test, "TSMBufferCreate", "TestCase1", TC_PASS, "ok");

4332

test_passed_MBuffer_Create = true;

4333

}

4334

4335

// TSMimeHdrCreate

4336

if (test_passed_MBuffer_Create == true) {

4337

if ((mime_loc1 = TSMimeHdrCreate(bufp1)) == TS_ERROR_PTR) {

4338

SDK_RPRINT(test, "TSMimeHdrCreate", "TestCase1", TC_FAIL, "TSMimeHdrCreate Returns TS_ERROR_PTR");

4339

} else {

4340

SDK_RPRINT(test, "TSMimeHdrCreate", "TestCase1", TC_PASS, "ok");

4341

test_passed_Mime_Hdr_Create = true;

4342

}

4343

} else {

4344

SDK_RPRINT(test, "TSMimeHdrCreate", "TestCase1", TC_FAIL, "Cannot run test as Test for TSMBufferCreate Failed");

4345

}

4346

4347

// TSMimeHdrFieldCreate

4348

if (test_passed_Mime_Hdr_Create == true) {

4349

if (((field_loc11 = TSMimeHdrFieldCreate(bufp1, mime_loc1)) == TS_ERROR_PTR) ||

4350

((field_loc12 = TSMimeHdrFieldCreate(bufp1, mime_loc1)) == TS_ERROR_PTR) ||

4351

((field_loc13 = TSMimeHdrFieldCreate(bufp1, mime_loc1)) == TS_ERROR_PTR) ||

4352

((field_loc14 = TSMimeHdrFieldCreate(bufp1, mime_loc1)) == TS_ERROR_PTR) ||

4353

((field_loc15 = TSMimeHdrFieldCreate(bufp1, mime_loc1)) == TS_ERROR_PTR)

4354

) {

4355

SDK_RPRINT(test, "TSMimeHdrFieldCreate", "TestCase1|2|3|4|5", TC_FAIL,

4356

"TSMimeHdrFieldCreate Returns TS_ERROR_PTR");

4357

} else {

4358

SDK_RPRINT(test, "TSMimeHdrFieldCreate", "TestCase1|2|3|4|5", TC_PASS, "ok");

4359

test_passed_Mime_Hdr_Field_Create = true;

4360

}

4361

} else {

4362

SDK_RPRINT(test, "TSMimeHdrFieldCreate", "All Test Case", TC_FAIL,

4363

"Cannot run test as Test for TSMimeHdrCreate Failed");

4364

}

4365

4366

4367

//TSMimeHdrFieldNameGet&Set

4368

if (test_passed_Mime_Hdr_Field_Create == true) {

4369

if ((TSMimeHdrFieldNameSet(bufp1, mime_loc1, field_loc11, field1Name, -1) == TS_ERROR) ||

4370

(TSMimeHdrFieldNameSet(bufp1, mime_loc1, field_loc12, field2Name, -1) == TS_ERROR) ||

4371

(TSMimeHdrFieldNameSet(bufp1, mime_loc1, field_loc13, field3Name, -1) == TS_ERROR) ||

4372

(TSMimeHdrFieldNameSet(bufp1, mime_loc1, field_loc14, field4Name, -1) == TS_ERROR) ||

4373

(TSMimeHdrFieldNameSet(bufp1, mime_loc1, field_loc15, field5Name, -1) == TS_ERROR)

4374

) {

4375

SDK_RPRINT(test, "TSMimeHdrFieldNameSet", "TestCase1|2|3|4|5", TC_FAIL,

4376

"TSMimeHdrFieldNameSet Returns TS_ERROR_PTR");

4377

} else {

4378

if (((field1NameGet =

4379

TSMimeHdrFieldNameGet(bufp1, mime_loc1, field_loc11, &field1NameGetLength)) == TS_ERROR_PTR) ||

4380

((field2NameGet =

4381

TSMimeHdrFieldNameGet(bufp1, mime_loc1, field_loc12, &field2NameGetLength)) == TS_ERROR_PTR) ||

4382

((field3NameGet =

4383

TSMimeHdrFieldNameGet(bufp1, mime_loc1, field_loc13, &field3NameGetLength)) == TS_ERROR_PTR) ||

4384

((field4NameGet =

4385

TSMimeHdrFieldNameGet(bufp1, mime_loc1, field_loc14, &field4NameGetLength)) == TS_ERROR_PTR) ||

4386

((field5NameGet =

4387

TSMimeHdrFieldNameGet(bufp1, mime_loc1, field_loc15, &field5NameGetLength)) == TS_ERROR_PTR)

4388

) {

4389

SDK_RPRINT(test, "TSMimeHdrFieldNameGet", "TestCase1|2|3|4|5", TC_FAIL,

4390

"TSMimeHdrFieldNameGet Returns TS_ERROR_PTR");

4391

SDK_RPRINT(test, "TSMimeHdrFieldNameGet|Set", "TestCase1|2|3|4|5", TC_FAIL,

4392

"TSMimeHdrFieldNameGet Returns TS_ERROR_PTR");

4393

} else {

4394

if (((strncmp(field1NameGet, field1Name, field1NameGetLength) == 0) &&

4395

(field1NameGetLength == (int) strlen(field1Name))) &&

4396

((strncmp(field2NameGet, field2Name, field2NameGetLength) == 0) &&

4397

(field2NameGetLength == (int) strlen(field2Name))) &&

4398

((strncmp(field3NameGet, field3Name, field3NameGetLength) == 0) &&

4399

(field3NameGetLength == (int) strlen(field3Name))) &&

4400

((strncmp(field4NameGet, field4Name, field4NameGetLength) == 0) &&

4401

(field4NameGetLength == (int) strlen(field4Name))) &&

4402

((strncmp(field5NameGet, field5Name, field5NameGetLength) == 0) &&

4403

field5NameGetLength == (int) strlen(field5Name))

4404

) {

4405

SDK_RPRINT(test, "TSMimeHdrFieldNameGet&Set", "TestCase1&2&3&4&5", TC_PASS, "ok");

4406

test_passed_Mime_Hdr_Field_Name = true;

4407

} else {

4408

SDK_RPRINT(test, "TSMimeHdrFieldNameGet&Set", "TestCase1|2|3|4|5", TC_FAIL, "Values Don't Match");

4409

}

4410

}

4411

}

4412

} else {

4413

SDK_RPRINT(test, "TSMimeHdrFieldNameGet&Set", "All Test Case", TC_FAIL,

4414

"Cannot run test as Test for TSMBufferFieldCreate Failed");

4415

}

4416

4417

4418

4419

4420

// TSMimeHdrFieldAppend, TSMimeHdrFieldGet, TSMimeHdrFieldNext

4421

if (test_passed_Mime_Hdr_Field_Name == true) {

4422

if ((TSMimeHdrFieldAppend(bufp1, mime_loc1, field_loc11) == TS_ERROR) ||

4423

(TSMimeHdrFieldAppend(bufp1, mime_loc1, field_loc12) == TS_ERROR) ||

4424

(TSMimeHdrFieldAppend(bufp1, mime_loc1, field_loc13) == TS_ERROR) ||

4425

(TSMimeHdrFieldAppend(bufp1, mime_loc1, field_loc14) == TS_ERROR) ||

4426

(TSMimeHdrFieldAppend(bufp1, mime_loc1, field_loc15) == TS_ERROR)

4427

) {

4428

SDK_RPRINT(test, "TSMimeHdrFieldAppend", "TestCase1|2|3|4|5", TC_FAIL,

4429

"TSMimeHdrFieldAppend Returns TS_ERROR");

4430

} else {

4431

if ((test_field_loc11 = TSMimeHdrFieldGet(bufp1, mime_loc1, 0)) == TS_ERROR_PTR) {

4432

SDK_RPRINT(test, "TSMimeHdrFieldAppend", "TestCase1|2|3|4|5", TC_FAIL,

4433

"TSMimeHdrFieldGet Returns TS_ERROR_PTR");

4434

SDK_RPRINT(test, "TSMimeHdrFieldNext", "TestCase1", TC_FAIL,

4435

"Cannot Test TSMimeHdrFieldNext as TSMimeHdrFieldGet Returns TS_ERROR_PTR");

4436

SDK_RPRINT(test, "TSMimeHdrFieldGet", "TestCase1", TC_FAIL, "TSMimeHdrFieldGet Returns TS_ERROR_PTR");

4437

} else {

4438

if (compare_field_names(test, bufp1, mime_loc1, field_loc11, bufp1, mime_loc1, test_field_loc11) == TS_ERROR) {

4439

SDK_RPRINT(test, "TSMimeHdrFieldAppend", "TestCase1", TC_FAIL, "Values Don't match");

4440

SDK_RPRINT(test, "TSMimeHdrFieldNext", "TestCase1", TC_FAIL,

4441

"Cannot Test TSMimeHdrFieldNext as Values don't match");

4442

SDK_RPRINT(test, "TSMimeHdrFieldGet", "TestCase1", TC_FAIL, "Values Don't match");

4443

} else {

4444

SDK_RPRINT(test, "TSMimeHdrFieldAppend", "TestCase1", TC_PASS, "ok");

4445

SDK_RPRINT(test, "TSMimeHdrFieldGet", "TestCase1", TC_PASS, "ok");

4446

test_passed_Mime_Hdr_Field_Append = true;

4447

test_passed_Mime_Hdr_Field_Get = true;

4448

}

4449

}

4450

4451

if (test_passed_Mime_Hdr_Field_Append == true) {

4452

if ((test_field_loc12 = TSMimeHdrFieldNext(bufp1, mime_loc1, test_field_loc11)) == TS_ERROR_PTR) {

4453

SDK_RPRINT(test, "TSMimeHdrFieldAppend", "TestCase2", TC_FAIL,

4454

"TSMimeHdrFieldAppend failed as TSMimeHdrFieldNext Returns TS_ERROR_PTR");

4455

SDK_RPRINT(test, "TSMimeHdrFieldNext", "TestCase2", TC_FAIL, "TSMimeHdrFieldNext Returns TS_ERROR_PTR");

4456

SDK_RPRINT(test, "TSMimeHdrFieldGet", "TestCase2", TC_FAIL,

4457

"Cannot be sure that TSMimeHdrFieldGet passed as TSMimeHdrFieldNext Returns TS_ERROR_PTR");

4458

test_passed_Mime_Hdr_Field_Append = false;

4459

test_passed_Mime_Hdr_Field_Next = false;

4460

test_passed_Mime_Hdr_Field_Get = false;

4461

} else {

4462

if (compare_field_names(test, bufp1, mime_loc1, field_loc12, bufp1, mime_loc1, test_field_loc12) == TS_ERROR) {

4463

SDK_RPRINT(test, "TSMimeHdrFieldAppend", "TestCase2", TC_PASS, "Values Don't match");

4464

SDK_RPRINT(test, "TSMimeHdrFieldNext", "TestCase2", TC_PASS, "Values Don't match");

4465

SDK_RPRINT(test, "TSMimeHdrFieldGet", "TestCase2", TC_PASS, "Values Don't match");

4466

test_passed_Mime_Hdr_Field_Append = false;

4467

test_passed_Mime_Hdr_Field_Next = false;

4468

test_passed_Mime_Hdr_Field_Get = false;

4469

} else {

4470

SDK_RPRINT(test, "TSMimeHdrFieldAppend", "TestCase2", TC_PASS, "ok");

4471

SDK_RPRINT(test, "TSMimeHdrFieldNext", "TestCase2", TC_PASS, "ok");

4472

SDK_RPRINT(test, "TSMimeHdrFieldGet", "TestCase2", TC_PASS, "ok");

4473

test_passed_Mime_Hdr_Field_Next = true;

4474

}

4475

}

4476

}

4477

4478

if (test_passed_Mime_Hdr_Field_Append == true) {

4479

if ((test_field_loc13 = TSMimeHdrFieldNext(bufp1, mime_loc1, test_field_loc12)) == TS_ERROR_PTR) {

4480

SDK_RPRINT(test, "TSMimeHdrFieldAppend", "TestCase3", TC_FAIL,

4481

"TSMimeHdrFieldNext Returns TS_ERROR. Cannot check.");

4482

SDK_RPRINT(test, "TSMimeHdrFieldNext", "TestCase3", TC_FAIL, "TSMimeHdrFieldNext Returns TS_ERROR_PTR");

4483

SDK_RPRINT(test, "TSMimeHdrFieldGet", "TestCase3", TC_FAIL,

4484

"Cannot be sure that TSMimeHdrFieldGet passed as TSMimeHdrFieldNext Returns TS_ERROR_PTR");

4485

test_passed_Mime_Hdr_Field_Append = false;

4486

test_passed_Mime_Hdr_Field_Next = false;

4487

test_passed_Mime_Hdr_Field_Get = false;

4488

} else {

4489

if (compare_field_names(test, bufp1, mime_loc1, field_loc13, bufp1, mime_loc1, test_field_loc13) == TS_ERROR) {

4490

SDK_RPRINT(test, "TSMimeHdrFieldAppend", "TestCase3", TC_FAIL, "Values Don't match");

4491

SDK_RPRINT(test, "TSMimeHdrFieldNext", "TestCase3", TC_FAIL, "Values Don't match");

4492

SDK_RPRINT(test, "TSMimeHdrFieldGet", "TestCase3", TC_FAIL, "Values Don't match");

4493

test_passed_Mime_Hdr_Field_Append = false;

4494

test_passed_Mime_Hdr_Field_Next = false;

4495

test_passed_Mime_Hdr_Field_Get = false;

4496

} else {

4497

SDK_RPRINT(test, "TSMimeHdrFieldAppend", "TestCase3", TC_PASS, "ok");

4498

SDK_RPRINT(test, "TSMimeHdrFieldNext", "TestCase3", TC_PASS, "ok");

4499

SDK_RPRINT(test, "TSMimeHdrFieldGet", "TestCase3", TC_PASS, "ok");

4500

}

4501

}

4502

}

4503

4504

if (test_passed_Mime_Hdr_Field_Append == true) {

4505

if ((test_field_loc14 = TSMimeHdrFieldNext(bufp1, mime_loc1, test_field_loc13)) == TS_ERROR_PTR) {

4506

SDK_RPRINT(test, "TSMimeHdrFieldAppend", "TestCase4", TC_FAIL,

4507

"TSMimeHdrFieldNext Returns TS_ERROR. Cannot check.");

4508

SDK_RPRINT(test, "TSMimeHdrFieldNext", "TestCase4", TC_FAIL, "TSMimeHdrFieldNext Returns TS_ERROR_PTR");

4509

SDK_RPRINT(test, "TSMimeHdrFieldAppend", "TestCase4", TC_FAIL,

4510

"Cannot be sure that TSMimeHdrFieldGet passed as TSMimeHdrFieldNext Returns TS_ERROR.");

4511

test_passed_Mime_Hdr_Field_Append = false;

4512

test_passed_Mime_Hdr_Field_Next = false;

4513

test_passed_Mime_Hdr_Field_Get = false;

4514

} else {

4515

if (compare_field_names(test, bufp1, mime_loc1, field_loc14, bufp1, mime_loc1, test_field_loc14) == TS_ERROR) {

4516

SDK_RPRINT(test, "TSMimeHdrFieldAppend", "TestCase4", TC_FAIL, "Values Don't match");

4517

SDK_RPRINT(test, "TSMimeHdrFieldNext", "TestCase4", TC_FAIL, "Values Don't match");

4518

SDK_RPRINT(test, "TSMimeHdrFieldGet", "TestCase4", TC_FAIL, "Values Don't match");

4519

test_passed_Mime_Hdr_Field_Append = false;

4520

test_passed_Mime_Hdr_Field_Next = false;

4521

test_passed_Mime_Hdr_Field_Get = false;

4522

} else {

4523

SDK_RPRINT(test, "TSMimeHdrFieldAppend", "TestCase4", TC_PASS, "ok");

4524

SDK_RPRINT(test, "TSMimeHdrFieldNext", "TestCase4", TC_PASS, "ok");

4525

SDK_RPRINT(test, "TSMimeHdrFieldGet", "TestCase4", TC_PASS, "ok");

4526

}

4527

}

4528

}

4529

4530

if (test_passed_Mime_Hdr_Field_Append == true) {

4531

if ((test_field_loc15 = TSMimeHdrFieldNext(bufp1, mime_loc1, test_field_loc14)) == TS_ERROR_PTR) {

4532

SDK_RPRINT(test, "TSMimeHdrFieldNext", "TestCase5", TC_FAIL, "TSMimeHdrFieldNext Returns TS_ERROR_PTR");

4533

SDK_RPRINT(test, "TSMimeHdrFieldAppend", "TestCase5", TC_FAIL,

4534

"TSMimeHdrFieldNext Returns TS_ERROR. Cannot check.");

4535

test_passed_Mime_Hdr_Field_Append = false;

4536

test_passed_Mime_Hdr_Field_Next = false;

4537

test_passed_Mime_Hdr_Field_Get = false;

4538

} else {

4539

if (compare_field_names(test, bufp1, mime_loc1, field_loc15, bufp1, mime_loc1, test_field_loc15) == TS_ERROR) {

4540

SDK_RPRINT(test, "TSMimeHdrFieldAppend", "TestCase5", TC_FAIL, "Values Don't match");

4541

SDK_RPRINT(test, "TSMimeHdrFieldNext", "TestCase5", TC_FAIL, "Values Don't match");

4542

test_passed_Mime_Hdr_Field_Append = false;

4543

test_passed_Mime_Hdr_Field_Next = false;

4544

test_passed_Mime_Hdr_Field_Get = false;

4545

} else {

4546

SDK_RPRINT(test, "TSMimeHdrFieldAppend", "TestCase5", TC_PASS, "ok");

4547

SDK_RPRINT(test, "TSMimeHdrFieldNext", "TestCase5", TC_PASS, "ok");

4548

}

4549

}

4550

}

4551

4552

if ((TSHandleMLocRelease(bufp1, mime_loc1, test_field_loc11) == TS_ERROR) ||

4553

(TSHandleMLocRelease(bufp1, mime_loc1, test_field_loc12) == TS_ERROR) ||

4554

(TSHandleMLocRelease(bufp1, mime_loc1, test_field_loc13) == TS_ERROR) ||

4555

(TSHandleMLocRelease(bufp1, mime_loc1, test_field_loc14) == TS_ERROR) ||

4556

(TSHandleMLocRelease(bufp1, mime_loc1, test_field_loc15) == TS_ERROR)

4557

) {

4558

SDK_RPRINT(test, "TSMimeHdrFieldAppend/Next/Get", "", TC_FAIL,

4559

"Unable to release handle using TSHandleMLocRelease. Can be bad handle.");

4560

}

4561

}

4562

} else {

4563

SDK_RPRINT(test, "TSMimeHdrFieldAppend & TSMimeHdrFieldNext", "All Test Case", TC_FAIL,

4564

"Cannot run test as Test for TSMimeHdrFieldNameGet&Set Failed");

4565

}

4566

4567

4568

//TSMimeHdrFieldsCount

4569

if (test_passed_Mime_Hdr_Field_Create == true) {

4570

if ((numberOfFields = TSMimeHdrFieldsCount(bufp1, mime_loc1)) == TS_ERROR) {

4571

SDK_RPRINT(test, "TSMimeHdrFieldsCount", "TestCase1", TC_FAIL, "TSMimeHdrFieldsCount Returns TS_ERROR");

4572

} else {

4573

actualNumberOfFields = 0;

4574

if ((field_loc = TSMimeHdrFieldGet(bufp1, mime_loc1, actualNumberOfFields)) == TS_ERROR_PTR) {

4575

SDK_RPRINT(test, "TSMimeHdrFieldsCount", "TestCase1", TC_FAIL, "TSMimeHdrFieldGet Returns TS_ERROR_PTR");

4576

} else {

4577

while (field_loc != NULL) {

4578

TSMLoc next_field_loc;

4579

4580

actualNumberOfFields++;

4581

if ((next_field_loc = TSMimeHdrFieldNext(bufp1, mime_loc1, field_loc)) == TS_ERROR_PTR) {

4582

SDK_RPRINT(test, "TSMimeHdrFieldsCount", "TestCase1", TC_FAIL,

4583

"TSMimeHdrFieldNext Returns TS_ERROR_PTR");

4584

}

4585

if (TSHandleMLocRelease(bufp1, mime_loc1, field_loc) == TS_ERROR) {

4586

SDK_RPRINT(test, "TSMimeHdrFieldsCount", "TestCase1", TC_FAIL,

4587

"Unable to release handle using TSHandleMLocRelease");

4588

}

4589

field_loc = next_field_loc;

4590

next_field_loc = NULL;

4591

}

4592

if (actualNumberOfFields == numberOfFields) {

4593

SDK_RPRINT(test, "TSMimeHdrFieldsCount", "TestCase1", TC_PASS, "ok");

4594

test_passed_Mime_Hdr_Fields_Count = true;

4595

} else {

4596

SDK_RPRINT(test, "TSMimeHdrFieldsCount", "TestCase1", TC_FAIL, "Value's Dont match");

4597

}

4598

}

4599

}

4600

} else {

4601

SDK_RPRINT(test, "TSMimeHdrFieldsCount", "TestCase1", TC_FAIL, "Cannot run Test as TSMimeHdrFieldCreate failed");

4602

}

4603

4604

// TSMimeHdrFieldValueStringInsert, TSMimeHdrFieldValueStringGet, TSMimeHdrFieldValueStringSet

4605

if (test_passed_Mime_Hdr_Field_Create == true) {

4606

if ((TSMimeHdrFieldValueStringInsert(bufp1, mime_loc1, field_loc11, -1, field1Value2, -1) == TS_ERROR) ||

4607

(TSMimeHdrFieldValueStringInsert(bufp1, mime_loc1, field_loc11, 0, field1Value1, -1) == TS_ERROR) ||

4608

(TSMimeHdrFieldValueStringInsert(bufp1, mime_loc1, field_loc11, -1, field1Value5, -1) == TS_ERROR) ||

4609

(TSMimeHdrFieldValueStringInsert(bufp1, mime_loc1, field_loc11, 2, field1Value4, -1) == TS_ERROR) ||

4610

(TSMimeHdrFieldValueStringInsert(bufp1, mime_loc1, field_loc11, 2, field1Value3, -1) == TS_ERROR)

4611

) {

4612

SDK_RPRINT(test, "TSMimeHdrFieldValueStringInsert", "TestCase1|2|3|4|5", TC_FAIL,

4613

"TSMimeHdrFieldValueStringInsert Returns TS_ERROR");

4614

SDK_RPRINT(test, "TSMimeHdrFieldValueStringGet", "TestCase1&2&3&4&5", TC_FAIL,

4615

"Cannot run Test as TSMimeHdrFieldValueStringInsert returns TS_ERROR");

4616

SDK_RPRINT(test, "TSMimeHdrFieldValueStringSet", "TestCase1", TC_FAIL,

4617

"Cannot run Test as TSMimeHdrFieldValueStringInsert returns TS_ERROR");

4618

} else {

4619

if ((TSMimeHdrFieldValueStringGet(bufp1, mime_loc1, field_loc11, 0, &field1Value1Get, &lengthField1Value1) ==

4620

TS_ERROR) ||

4621

(TSMimeHdrFieldValueStringGet(bufp1, mime_loc1, field_loc11, 1, &field1Value2Get, &lengthField1Value2) ==

4622

TS_ERROR) ||

4623

(TSMimeHdrFieldValueStringGet(bufp1, mime_loc1, field_loc11, 2, &field1Value3Get, &lengthField1Value3) ==

4624

TS_ERROR) ||

4625

(TSMimeHdrFieldValueStringGet(bufp1, mime_loc1, field_loc11, 3, &field1Value4Get, &lengthField1Value4) ==

4626

TS_ERROR) ||

4627

(TSMimeHdrFieldValueStringGet(bufp1, mime_loc1, field_loc11, 4, &field1Value5Get, &lengthField1Value5) ==

4628

TS_ERROR)

4629

) {

4630

SDK_RPRINT(test, "TSMimeHdrFieldValueStringInsert|Get", "TestCase1|2|3|4|5", TC_FAIL,

4631

"TSMimeHdrFieldValueStringGet Returns TS_ERROR");

4632

SDK_RPRINT(test, "TSMimeHdrFieldValueStringSet", "TestCase1", TC_FAIL,

4633

"TSMimeHdrFieldValueStringSet cannot be tested as TSMimeHdrFieldValueStringInsert|Get failed");

4634

} else {

4635

if (((strncmp(field1Value1Get, field1Value1, lengthField1Value1) == 0) &&

4636

lengthField1Value1 == (int) strlen(field1Value1)) &&

4637

((strncmp(field1Value2Get, field1Value2, lengthField1Value2) == 0) &&

4638

lengthField1Value2 == (int) strlen(field1Value2)) &&

4639

((strncmp(field1Value3Get, field1Value3, lengthField1Value3) == 0) &&

4640

lengthField1Value3 == (int) strlen(field1Value3)) &&

4641

((strncmp(field1Value4Get, field1Value4, lengthField1Value4) == 0) &&

4642

lengthField1Value4 == (int) strlen(field1Value4)) &&

4643

((strncmp(field1Value5Get, field1Value5, lengthField1Value5) == 0) &&

4644

lengthField1Value5 == (int) strlen(field1Value5))

4645

) {

4646

SDK_RPRINT(test, "TSMimeHdrFieldValueStringInsert", "TestCase1&2&3&4&5", TC_PASS, "ok");

4647

SDK_RPRINT(test, "TSMimeHdrFieldValueStringGet", "TestCase1&2&3&4&5", TC_PASS, "ok");

4648

test_passed_Mime_Hdr_Field_Value_String_Insert = true;

4649

test_passed_Mime_Hdr_Field_Value_String_Get = true;

4650

4651

if ((TSMimeHdrFieldValueStringSet(bufp1, mime_loc1, field_loc11, 3, field1ValueNew, -1)) == TS_ERROR) {

4652

SDK_RPRINT(test, "TSMimeHdrFieldValueStringSet", "TestCase1", TC_FAIL,

4653

"TSMimeHdrFieldValueStringSet returns TS_ERROR");

4654

} else {

4655

if (TSMimeHdrFieldValueStringGet

4656

(bufp1, mime_loc1, field_loc11, 3, &field1ValueNewGet, &lengthField1ValueNew) == TS_ERROR) {

4657

SDK_RPRINT(test, "TSMimeHdrFieldValueStringSet", "TestCase1", TC_FAIL,

4658

"TSMimeHdrFieldValueStringGet returns TS_ERROR");

4659

} else {

4660

if ((strncmp(field1ValueNewGet, field1ValueNew, lengthField1ValueNew) == 0) &&

4661

(lengthField1ValueNew == (int) strlen(field1ValueNew))) {

4662

SDK_RPRINT(test, "TSMimeHdrFieldValueStringSet", "TestCase1", TC_PASS, "ok");

4663

test_passed_Mime_Hdr_Field_Value_String_Set = true;

4664

} else {

4665

SDK_RPRINT(test, "TSMimeHdrFieldValueStringSet", "TestCase1", TC_FAIL, "Value's Don't match");

4666

}

4667

}

4668

}

4669

} else {

4670

SDK_RPRINT(test, "TSMimeHdrFieldValueStringInsert", "TestCase1|2|3|4|5", TC_PASS, "Value's Don't Match");

4671

SDK_RPRINT(test, "TSMimeHdrFieldValueStringGet", "TestCase1|2|3|4|5", TC_PASS, "Value's Don't Match");

4672

SDK_RPRINT(test, "TSMimeHdrFieldValueStringSet", "TestCase1", TC_FAIL,

4673

"TSMimeHdrFieldValueStringSet cannot be tested as TSMimeHdrFieldValueStringInsert|Get failed");

4674

}

4675

}

4676

}

4677

} else {

4678

SDK_RPRINT(test, "TSMimeHdrFieldValueStringInsert&Set&Get", "All", TC_FAIL,

4679

"Cannot run Test as TSMimeHdrFieldCreate failed");

4680

}

4681

4682

4683

// TSMimeHdrFieldValueDateInsert, TSMimeHdrFieldValueDateGet, TSMimeHdrFieldValueDateSet

4684

if (test_passed_Mime_Hdr_Field_Create == true) {

4685

if (TSMimeHdrFieldValueDateInsert(bufp1, mime_loc1, field_loc12, field2Value1) == TS_ERROR) {

4686

SDK_RPRINT(test, "TSMimeHdrFieldValueDateInsert", "TestCase1", TC_FAIL,

4687

"TSMimeHdrFieldValueDateInsert Returns TS_ERROR");

4688

SDK_RPRINT(test, "TSMimeHdrFieldValueDateGet", "TestCase1", TC_FAIL,

4689

"Cannot run Test as TSMimeHdrFieldValueDateInsert returns TS_ERROR");

4690

SDK_RPRINT(test, "TSMimeHdrFieldValueDateSet", "TestCase1", TC_FAIL,

4691

"Cannot run Test as TSMimeHdrFieldValueDateInsert returns TS_ERROR");

4692

} else {

4693

if (TSMimeHdrFieldValueDateGet(bufp1, mime_loc1, field_loc12, &field2Value1Get) == TS_ERROR) {

4694

SDK_RPRINT(test, "TSMimeHdrFieldValueDateInsert|Get", "TestCase1", TC_FAIL,

4695

"TSMimeHdrFieldValueDateGet Returns TS_ERROR");

4696

SDK_RPRINT(test, "TSMimeHdrFieldValueDateSet", "TestCase1", TC_FAIL,

4697

"TSMimeHdrFieldValueDateSet cannot be tested as TSMimeHdrFieldValueDateInsert|Get failed");

4698

} else {

4699

if (field2Value1Get == field2Value1) {

4700

SDK_RPRINT(test, "TSMimeHdrFieldValueDateInsert", "TestCase1", TC_PASS, "ok");

4701

SDK_RPRINT(test, "TSMimeHdrFieldValueDateGet", "TestCase1", TC_PASS, "ok");

4702

test_passed_Mime_Hdr_Field_Value_Date_Insert = true;

4703

test_passed_Mime_Hdr_Field_Value_Date_Get = true;

4704

field2ValueNew = time(NULL);

4705

if ((TSMimeHdrFieldValueDateSet(bufp1, mime_loc1, field_loc12, field2ValueNew)) == TS_ERROR) {

4706

SDK_RPRINT(test, "TSMimeHdrFieldValueDateSet", "TestCase1", TC_FAIL,

4707

"TSMimeHdrFieldValueDateSet returns TS_ERROR");

4708

} else {

4709

if (TSMimeHdrFieldValueDateGet(bufp1, mime_loc1, field_loc12, &field2ValueNewGet) == TS_ERROR) {

4710

SDK_RPRINT(test, "TSMimeHdrFieldValueDateSet", "TestCase1", TC_FAIL,

4711

"TSMimeHdrFieldValueDateGet returns TS_ERROR");

4712

} else {

4713

if (field2ValueNewGet == field2ValueNew) {

4714

SDK_RPRINT(test, "TSMimeHdrFieldValueDateSet", "TestCase1", TC_PASS, "ok");

4715

test_passed_Mime_Hdr_Field_Value_Date_Set = true;

4716

} else {

4717

SDK_RPRINT(test, "TSMimeHdrFieldValueDateSet", "TestCase1", TC_FAIL, "Value's Don't match");

4718

}

4719

}

4720

}

4721

} else {

4722

SDK_RPRINT(test, "TSMimeHdrFieldValueDateInsert", "TestCase1", TC_PASS, "Value's Don't Match");

4723

SDK_RPRINT(test, "TSMimeHdrFieldValueDateGet", "TestCase1", TC_PASS, "Value's Don't Match");

4724

SDK_RPRINT(test, "TSMimeHdrFieldValueDateSet", "TestCase1", TC_FAIL,

4725

"TSMimeHdrFieldValueDateSet cannot be tested as TSMimeHdrFieldValueDateInsert|Get failed");

4726

}

4727

}

4728

}

4729

} else {

4730

SDK_RPRINT(test, "TSMimeHdrFieldValueDateInsert&Set&Get", "TestCase1", TC_FAIL,

4731

"Cannot run Test as TSMimeHdrFieldCreate failed");

4732

}

4733

4734

4735

// TSMimeHdrFieldValueIntInsert, TSMimeHdrFieldValueIntGet, TSMimeHdrFieldValueIntSet

4736

if (test_passed_Mime_Hdr_Field_Create == true) {

4737

if ((TSMimeHdrFieldValueIntInsert(bufp1, mime_loc1, field_loc13, -1, field3Value2) == TS_ERROR) ||

4738

(TSMimeHdrFieldValueIntInsert(bufp1, mime_loc1, field_loc13, 0, field3Value1) == TS_ERROR) ||

4739

(TSMimeHdrFieldValueIntInsert(bufp1, mime_loc1, field_loc13, -1, field3Value5) == TS_ERROR) ||

4740

(TSMimeHdrFieldValueIntInsert(bufp1, mime_loc1, field_loc13, 2, field3Value4) == TS_ERROR) ||

4741

(TSMimeHdrFieldValueIntInsert(bufp1, mime_loc1, field_loc13, 2, field3Value3) == TS_ERROR)

4742

) {

4743

SDK_RPRINT(test, "TSMimeHdrFieldValueIntInsert", "TestCase1|2|3|4|5", TC_FAIL,

4744

"TSMimeHdrFieldValueIntInsert Returns TS_ERROR");

4745

SDK_RPRINT(test, "TSMimeHdrFieldValueIntGet", "TestCase1&2&3&4&5", TC_FAIL,

4746

"Cannot run Test as TSMimeHdrFieldValueIntInsert returns TS_ERROR");

4747

SDK_RPRINT(test, "TSMimeHdrFieldValueIntSet", "TestCase1", TC_FAIL,

4748

"Cannot run Test as TSMimeHdrFieldValueIntInsert returns TS_ERROR");

4749

} else {

4750

if ((TSMimeHdrFieldValueIntGet(bufp1, mime_loc1, field_loc13, 0, &field3Value1Get) == TS_ERROR) ||

4751

(TSMimeHdrFieldValueIntGet(bufp1, mime_loc1, field_loc13, 1, &field3Value2Get) == TS_ERROR) ||

4752

(TSMimeHdrFieldValueIntGet(bufp1, mime_loc1, field_loc13, 2, &field3Value3Get) == TS_ERROR) ||

4753

(TSMimeHdrFieldValueIntGet(bufp1, mime_loc1, field_loc13, 3, &field3Value4Get) == TS_ERROR) ||

4754

(TSMimeHdrFieldValueIntGet(bufp1, mime_loc1, field_loc13, 4, &field3Value5Get) == TS_ERROR)

4755

) {

4756

SDK_RPRINT(test, "TSMimeHdrFieldValueIntInsert|Get", "TestCase1|2|3|4|5", TC_FAIL,

4757

"TSMimeHdrFieldValueIntGet Returns TS_ERROR");

4758

SDK_RPRINT(test, "TSMimeHdrFieldValueIntSet", "TestCase1", TC_FAIL,

4759

"TSMimeHdrFieldValueIntSet cannot be tested as TSMimeHdrFieldValueIntInsert|Get failed");

4760

} else {

4761

if ((field3Value1Get == field3Value1) &&

4762

(field3Value2Get == field3Value2) &&

4763

(field3Value3Get == field3Value3) && (field3Value4Get == field3Value4) && (field3Value5Get == field3Value5)

4764

) {

4765

SDK_RPRINT(test, "TSMimeHdrFieldValueIntInsert", "TestCase1&2&3&4&5", TC_PASS, "ok");

4766

SDK_RPRINT(test, "TSMimeHdrFieldValueIntGet", "TestCase1&2&3&4&5", TC_PASS, "ok");

4767

test_passed_Mime_Hdr_Field_Value_Int_Insert = true;

4768

test_passed_Mime_Hdr_Field_Value_Int_Get = true;

4769

if ((TSMimeHdrFieldValueIntSet(bufp1, mime_loc1, field_loc13, 3, field3ValueNew)) == TS_ERROR) {

4770

SDK_RPRINT(test, "TSMimeHdrFieldValueIntSet", "TestCase1", TC_FAIL,

4771

"TSMimeHdrFieldValueIntSet returns TS_ERROR");

4772

} else {

4773

if (TSMimeHdrFieldValueIntGet(bufp1, mime_loc1, field_loc13, 3, &field3ValueNewGet) == TS_ERROR) {

4774

SDK_RPRINT(test, "TSMimeHdrFieldValueIntSet", "TestCase1", TC_FAIL,

4775

"TSMimeHdrFieldValueIntGet returns TS_ERROR");

4776

} else {

4777

if (field3ValueNewGet == field3ValueNew) {

4778

SDK_RPRINT(test, "TSMimeHdrFieldValueIntSet", "TestCase1", TC_PASS, "ok");

4779

test_passed_Mime_Hdr_Field_Value_Int_Set = true;

4780

} else {

4781

SDK_RPRINT(test, "TSMimeHdrFieldValueIntSet", "TestCase1", TC_FAIL, "Value's Don't match");

4782

}

4783

}

4784

}

4785

} else {

4786

SDK_RPRINT(test, "TSMimeHdrFieldValueIntInsert", "TestCase1|2|3|4|5", TC_PASS, "Value's Don't Match");

4787

SDK_RPRINT(test, "TSMimeHdrFieldValueIntGet", "TestCase1|2|3|4|5", TC_PASS, "Value's Don't Match");

4788

SDK_RPRINT(test, "TSMimeHdrFieldValueIntSet", "TestCase1", TC_FAIL,

4789

"TSMimeHdrFieldValueIntSet cannot be tested as TSMimeHdrFieldValueIntInsert|Get failed");

4790

}

4791

}

4792

}

4793

} else {

4794

SDK_RPRINT(test, "TSMimeHdrFieldValueIntInsert&Set&Get", "All", TC_FAIL,

4795

"Cannot run Test as TSMimeHdrFieldCreate failed");

4796

}

4797

4798

// TSMimeHdrFieldValueUintInsert, TSMimeHdrFieldValueUintGet, TSMimeHdrFieldValueUintSet

4799

if (test_passed_Mime_Hdr_Field_Create == true) {

4800

if ((TSMimeHdrFieldValueUintInsert(bufp1, mime_loc1, field_loc14, -1, field4Value2) == TS_ERROR) ||

4801

(TSMimeHdrFieldValueUintInsert(bufp1, mime_loc1, field_loc14, 0, field4Value1) == TS_ERROR) ||

4802

(TSMimeHdrFieldValueUintInsert(bufp1, mime_loc1, field_loc14, -1, field4Value5) == TS_ERROR) ||

4803

(TSMimeHdrFieldValueUintInsert(bufp1, mime_loc1, field_loc14, 2, field4Value4) == TS_ERROR) ||

4804

(TSMimeHdrFieldValueUintInsert(bufp1, mime_loc1, field_loc14, 2, field4Value3) == TS_ERROR)

4805

) {

4806

SDK_RPRINT(test, "TSMimeHdrFieldValueUintInsert", "TestCase1|2|3|4|5", TC_FAIL,

4807

"TSMimeHdrFieldValueUintInsert Returns TS_ERROR");

4808

SDK_RPRINT(test, "TSMimeHdrFieldValueUintGet", "TestCase1&2&3&4&5", TC_FAIL,

4809

"Cannot run Test as TSMimeHdrFieldValueUintInsert returns TS_ERROR");

4810

SDK_RPRINT(test, "TSMimeHdrFieldValueUintSet", "TestCase1", TC_FAIL,

4811

"Cannot run Test as TSMimeHdrFieldValueUintInsert returns TS_ERROR");

4812

} else {

4813

if ((TSMimeHdrFieldValueUintGet(bufp1, mime_loc1, field_loc14, 0, &field4Value1Get) == TS_ERROR) ||

4814

(TSMimeHdrFieldValueUintGet(bufp1, mime_loc1, field_loc14, 1, &field4Value2Get) == TS_ERROR) ||

4815

(TSMimeHdrFieldValueUintGet(bufp1, mime_loc1, field_loc14, 2, &field4Value3Get) == TS_ERROR) ||

4816

(TSMimeHdrFieldValueUintGet(bufp1, mime_loc1, field_loc14, 3, &field4Value4Get) == TS_ERROR) ||

4817

(TSMimeHdrFieldValueUintGet(bufp1, mime_loc1, field_loc14, 4, &field4Value5Get) == TS_ERROR)

4818

) {

4819

SDK_RPRINT(test, "TSMimeHdrFieldValueUintInsert|Get", "TestCase1|2|3|4|5", TC_FAIL,

4820

"TSMimeHdrFieldValueUintGet Returns TS_ERROR");

4821

SDK_RPRINT(test, "TSMimeHdrFieldValueUintSet", "TestCase1", TC_FAIL,

4822

"TSMimeHdrFieldValueUintSet cannot be tested as TSMimeHdrFieldValueUintInsert|Get failed");

4823

} else {

4824

if ((field4Value1Get == field4Value1) &&

4825

(field4Value2Get == field4Value2) &&

4826

(field4Value3Get == field4Value3) && (field4Value4Get == field4Value4) && (field4Value5Get == field4Value5)

4827

) {

4828

SDK_RPRINT(test, "TSMimeHdrFieldValueUintInsert", "TestCase1&2&3&4&5", TC_PASS, "ok");

4829

SDK_RPRINT(test, "TSMimeHdrFieldValueUintGet", "TestCase1&2&3&4&5", TC_PASS, "ok");

4830

test_passed_Mime_Hdr_Field_Value_Uint_Insert = true;

4831

test_passed_Mime_Hdr_Field_Value_Uint_Get = true;

4832

if ((TSMimeHdrFieldValueUintSet(bufp1, mime_loc1, field_loc14, 3, field4ValueNew)) == TS_ERROR) {

4833

SDK_RPRINT(test, "TSMimeHdrFieldValueUintSet", "TestCase1", TC_FAIL,

4834

"TSMimeHdrFieldValueUintSet returns TS_ERROR");

4835

} else {

4836

if (TSMimeHdrFieldValueUintGet(bufp1, mime_loc1, field_loc14, 3, &field4ValueNewGet) == TS_ERROR) {

4837

SDK_RPRINT(test, "TSMimeHdrFieldValueUintSet", "TestCase1", TC_FAIL,

4838

"TSMimeHdrFieldValueUintGet returns TS_ERROR");

4839

} else {

4840

if (field4ValueNewGet == field4ValueNew) {

4841

SDK_RPRINT(test, "TSMimeHdrFieldValueUintSet", "TestCase1", TC_PASS, "ok");

4842

test_passed_Mime_Hdr_Field_Value_Uint_Set = true;

4843

} else {

4844

SDK_RPRINT(test, "TSMimeHdrFieldValueUintSet", "TestCase1", TC_FAIL, "Value's Don't match");

4845

}

4846

}

4847

}

4848

} else {

4849

SDK_RPRINT(test, "TSMimeHdrFieldValueUintInsert", "TestCase1|2|3|4|5", TC_PASS, "Value's Don't Match");

4850

SDK_RPRINT(test, "TSMimeHdrFieldValueUintGet", "TestCase1|2|3|4|5", TC_PASS, "Value's Don't Match");

4851

SDK_RPRINT(test, "TSMimeHdrFieldValueUintSet", "TestCase1", TC_FAIL,

4852

"TSMimeHdrFieldValueUintSet cannot be tested as TSMimeHdrFieldValueUintInsert|Get failed");

4853

}

4854

}

4855

}

4856

} else {

4857

SDK_RPRINT(test, "TSMimeHdrFieldValueUintInsert&Set&Get", "All", TC_FAIL,

4858

"Cannot run Test as TSMimeHdrFieldCreate failed");

4859

}

4860

4861

// TSMimeHdrFieldLengthGet

4862

field1_length = TSMimeHdrFieldLengthGet(bufp1, mime_loc1, field_loc11);

4863

field2_length = TSMimeHdrFieldLengthGet(bufp1, mime_loc1, field_loc12);

4864

field3_length = TSMimeHdrFieldLengthGet(bufp1, mime_loc1, field_loc13);

4865

field4_length = TSMimeHdrFieldLengthGet(bufp1, mime_loc1, field_loc14);

4866

if ((field1_length == TS_ERROR || field1_length == 0) ||

4867

(field2_length == TS_ERROR || field2_length == 0) ||

4868

(field3_length == TS_ERROR || field3_length == 0) || (field4_length == TS_ERROR || field4_length == 0)) {

4869

SDK_RPRINT(test, "TSMimeHdrFieldLengthGet", "TestCase1", TC_FAIL, "Returned bad length");

4870

test_passed_Mime_Hdr_Field_Length_Get = false;

4871

} else {

4872

SDK_RPRINT(test, "TSMimeHdrFieldLengthGet", "TestCase1", TC_PASS, "ok");

4873

test_passed_Mime_Hdr_Field_Length_Get = true;

4874

}

4875

4876

4877

4878

// TSMimeHdrFieldValueAppend, TSMimeHdrFieldValueDelete, TSMimeHdrFieldValuesCount, TSMimeHdrFieldValuesClear

4879

4880

if (test_passed_Mime_Hdr_Field_Create == true) {

4881

if ((TSMimeHdrFieldValueStringInsert(bufp1, mime_loc1, field_loc15, -1, field5Value1, -1) == TS_ERROR) ||

4882

(TSMimeHdrFieldValueIntInsert(bufp1, mime_loc1, field_loc15, -1, field5Value2) == TS_ERROR) ||

4883

(TSMimeHdrFieldValueStringInsert(bufp1, mime_loc1, field_loc15, -1, field5Value3, -1) == TS_ERROR) ||

4884

(TSMimeHdrFieldValueUintInsert(bufp1, mime_loc1, field_loc15, -1, field5Value4) == TS_ERROR)

4885

) {

4886

SDK_RPRINT(test, "TSMimeHdrFieldValueAppend", "TestCase1", TC_FAIL,

4887

"TSMimeHdrFieldValueString|Int|UintInsert returns TS_ERROR. Cannot create field for testing.");

4888

SDK_RPRINT(test, "TSMimeHdrFieldValueDelete", "TestCase1", TC_FAIL,

4889

"TSMimeHdrFieldValueString|Int|UintInsert returns TS_ERROR. Cannot create field for testing.");

4890

SDK_RPRINT(test, "TSMimeHdrFieldValuesCount", "TestCase1", TC_FAIL,

4891

"TSMimeHdrFieldValueString|Int|UintInsert returns TS_ERROR. Cannot create field for testing.");

4892

SDK_RPRINT(test, "TSMimeHdrFieldValuesClear", "TestCase1", TC_FAIL,

4893

"TSMimeHdrFieldValueString|Int|UintInsert returns TS_ERROR. Cannot create field for testing.");

4894

} else {

4895

if (TSMimeHdrFieldValueAppend(bufp1, mime_loc1, field_loc15, 0, field5Value1Append, -1) == TS_ERROR) {

4896

SDK_RPRINT(test, "TSMimeHdrFieldValueAppend", "TestCase1", TC_FAIL,

4897

"TSMimeHdrFieldValueAppend returns TS_ERROR");

4898

} else {

4899

if ((TSMimeHdrFieldValueStringGet

4900

(bufp1, mime_loc1, field_loc15, 0, &fieldValueAppendGet, &lengthFieldValueAppended)) != TS_SUCCESS) {

4901

SDK_RPRINT(test, "TSMimeHdrFieldValueAppend", "TestCase1", TC_FAIL,

4902

"TSMimeHdrFieldValueStringGet doesn't return TS_SUCCESS");

4903

} else {

4904

char *expected_value;

4905

size_t len = strlen(field5Value1) + strlen(field5Value1Append) + 1;

4906

expected_value = (char *) TSmalloc(len);

4907

memset(expected_value, 0, strlen(field5Value1) + strlen(field5Value1Append) + 1);

4908

ink_strncpy(expected_value, field5Value1, len);

4909

strncat(expected_value, field5Value1Append, len - strlen(expected_value) - 1);

4910

if ((strncmp(fieldValueAppendGet, expected_value, lengthFieldValueAppended) == 0) &&

4911

(lengthFieldValueAppended = strlen(expected_value))

4912

) {

4913

SDK_RPRINT(test, "TSMimeHdrFieldValueAppend", "TestCase1", TC_PASS, "ok");

4914

test_passed_Mime_Hdr_Field_Value_Append = true;

4915

} else {

4916

SDK_RPRINT(test, "TSMimeHdrFieldValueAppend", "TestCase1", TC_FAIL, "Values mismatch");

4917

}

4918

TSfree(expected_value);

4919

}

4920

}

4921

4922

if ((numberOfValueInField = TSMimeHdrFieldValuesCount(bufp1, mime_loc1, field_loc15)) == TS_ERROR) {

4923

SDK_RPRINT(test, "TSMimeHdrFieldValuesCount", "TestCase1", TC_FAIL,

4924

"TSMimeHdrFieldValuesCount returns TS_ERROR");

4925

} else {

4926

if (numberOfValueInField == 4) {

4927

SDK_RPRINT(test, "TSMimeHdrFieldValuesCount", "TestCase1", TC_PASS, "ok");

4928

test_passed_Mime_Hdr_Field_Values_Count = true;

4929

} else {

4930

SDK_RPRINT(test, "TSMimeHdrFieldValuesCount", "TestCase1", TC_FAIL, "Values don't match");

4931

}

4932

}

4933

4934

4935

if (TSMimeHdrFieldValueDelete(bufp1, mime_loc1, field_loc15, 2) == TS_ERROR) {

4936

SDK_RPRINT(test, "TSMimeHdrFieldValueDelete", "TestCase1", TC_FAIL,

4937

"TSMimeHdrFieldValueDelete Returns TS_ERROR");

4938

} else {

4939

if ((TSMimeHdrFieldValueStringGet

4940

(bufp1, mime_loc1, field_loc15, 2, &fieldValueDeleteGet, &lengthFieldValueDeleteGet)) != TS_SUCCESS) {

4941

SDK_RPRINT(test, "TSMimeHdrFieldValueDelete", "TestCase1", TC_FAIL,

4942

"TSMimeHdrFieldValueStringGet doesn't return TS_SUCCESS. Cannot test for TSMimeHdrFieldValueDelete");

4943

} else {

4944

if ((strncmp(fieldValueDeleteGet, field5Value3, lengthFieldValueDeleteGet) == 0) &&

4945

(lengthFieldValueDeleteGet == (int) strlen(field5Value3))) {

4946

SDK_RPRINT(test, "TSMimeHdrFieldValueDelete", "TestCase1", TC_FAIL,

4947

"Value not deleted from field or incorrect index deleted from field.");

4948

} else {

4949

SDK_RPRINT(test, "TSMimeHdrFieldValueDelete", "TestCase1", TC_PASS, "ok");

4950

test_passed_Mime_Hdr_Field_Value_Delete = true;

4951

}

4952

}

4953

}

4954

4955

if (TSMimeHdrFieldValuesClear(bufp1, mime_loc1, field_loc15) == TS_ERROR) {

4956

SDK_RPRINT(test, "TSMimeHdrFieldValuesClear", "TestCase1", TC_FAIL,

4957

"TSMimeHdrFieldValuesClear returns TS_ERROR");

4958

} else {

4959

if ((numberOfValueInField = TSMimeHdrFieldValuesCount(bufp1, mime_loc1, field_loc15)) == TS_ERROR) {

4960

SDK_RPRINT(test, "TSMimeHdrFieldValuesClear", "TestCase1", TC_FAIL,

4961

"TSMimeHdrFieldValuesCount returns TS_ERROR. Cannot test TSMimeHdrFieldValuesClear");

4962

} else {

4963

if (numberOfValueInField == 0) {

4964

SDK_RPRINT(test, "TSMimeHdrFieldValuesClear", "TestCase1", TC_PASS, "ok");

4965

test_passed_Mime_Hdr_Field_Values_Clear = true;

4966

} else {

4967

SDK_RPRINT(test, "TSMimeHdrFieldValuesClear", "TestCase1", TC_FAIL, "Values don't match");

4968

}

4969

}

4970

}

4971

}

4972

4973

// TSMimeHdrFieldDestroy

4974

if (TSMimeHdrFieldDestroy(bufp1, mime_loc1, field_loc15) == TS_ERROR) {

4975

SDK_RPRINT(test, "TSMimeHdrFieldDestroy", "TestCase1", TC_FAIL, "TSMimeHdrFieldDestroy returns TS_ERROR");

4976

} else {

4977

if ((test_field_loc15 = TSMimeHdrFieldFind(bufp1, mime_loc1, field5Name, -1)) == TS_ERROR_PTR) {

4978

SDK_RPRINT(test, "TSMimeHdrFieldDestroy", "TestCase1", TC_FAIL, "TSMimeHdrFieldFind returns TS_ERROR_PTR");

4979

} else {

4980

if (test_field_loc15 == NULL) {

4981

SDK_RPRINT(test, "TSMimeHdrFieldDestroy", "TestCase1", TC_PASS, "ok");

4982

test_passed_Mime_Hdr_Field_Destroy = true;

4983

} else {

4984

SDK_RPRINT(test, "TSMimeHdrFieldDestroy", "TestCase1", TC_FAIL, "Field not destroyed");

4985

if (TSHandleMLocRelease(bufp1, mime_loc1, test_field_loc15) == TS_ERROR) {

4986

SDK_RPRINT(test, "TSMimeHdrFieldDestroy", "TestCase1", TC_FAIL,

4987

"Unable to release handle using TSHandleMLocRelease");

4988

}

4989

}

4990

}

4991

if (TSHandleMLocRelease(bufp1, mime_loc1, field_loc15) == TS_ERROR) {

4992

SDK_RPRINT(test, "TSMimeHdrFieldDestroy", "TestCase2", TC_FAIL,

4993

"Unable to release handle using TSHandleMLocRelease");

4994

}

4995

}

4996

} else {

4997

SDK_RPRINT(test, "TSMimeHdrFieldValueAppend", "TestCase1", TC_FAIL,

4998

"Cannot run test as TSMimeHdrFieldCreate has failed");

4999

SDK_RPRINT(test, "TSMimeHdrFieldValueDelete", "TestCase1", TC_FAIL,

5000

"Cannot run test as TSMimeHdrFieldCreate has failed");

5001

SDK_RPRINT(test, "TSMimeHdrFieldValuesCount", "TestCase1", TC_FAIL,

5002

"Cannot run test as TSMimeHdrFieldCreate has failed");

5003

SDK_RPRINT(test, "TSMimeHdrFieldValuesClear", "TestCase1", TC_FAIL,

5004

"Cannot run test as TSMimeHdrFieldCreate has failed");

5005

SDK_RPRINT(test, "TSMimeHdrFieldDestroy", "TestCase1", TC_FAIL,

5006

"Cannot run test as TSMimeHdrFieldCreate has failed");

5007

}

5008

5009

// Mime Hdr Fields Clear

5010

if (test_passed_Mime_Hdr_Field_Append == true) {

5011

if (TSMimeHdrFieldsClear(bufp1, mime_loc1) != TS_SUCCESS) {

5012

SDK_RPRINT(test, "TSMimeHdrFieldsClear", "TestCase1", TC_FAIL, "TSMimeHdrFieldsClear returns TS_ERROR");

5013

} else {

5014

if ((numberOfFields = TSMimeHdrFieldsCount(bufp1, mime_loc1)) == TS_ERROR) {

5015

SDK_RPRINT(test, "TSMimeHdrFieldsClear", "TestCase1", TC_FAIL, "TSMimeHdrFieldsCount returns TS_ERROR");

5016

} else {

5017

if (numberOfFields == 0) {

5018

SDK_RPRINT(test, "TSMimeHdrFieldsClear", "TestCase1", TC_PASS, "ok");

5019

test_passed_Mime_Hdr_Fields_Clear = true;

5020

} else {

5021

SDK_RPRINT(test, "TSMimeHdrFieldsClear", "TestCase1", TC_FAIL, "Fields still exist");

5022

}

5023

}

5024

if ((TSHandleMLocRelease(bufp1, mime_loc1, field_loc11) == TS_ERROR) ||

5025

(TSHandleMLocRelease(bufp1, mime_loc1, field_loc12) == TS_ERROR) ||

5026

(TSHandleMLocRelease(bufp1, mime_loc1, field_loc13) == TS_ERROR) ||

5027

(TSHandleMLocRelease(bufp1, mime_loc1, field_loc14) == TS_ERROR)

5028

) {

5029

SDK_RPRINT(test, "TSMimeHdrFieldsDestroy", "", TC_FAIL, "Unable to release handle using TSHandleMLocRelease");

5030

}

5031

}

5032

} else {

5033

SDK_RPRINT(test, "TSMimeHdrFieldsClear", "TestCase1", TC_FAIL,

5034

"Cannot run test as Fields have not been inserted in the mime header");

5035

}

5036

5037

// Mime Hdr Destroy

5038

if (test_passed_Mime_Hdr_Create == true) {

5039

if (TSMimeHdrDestroy(bufp1, mime_loc1) == TS_ERROR) {

5040

SDK_RPRINT(test, "TSMimeHdrDestroy", "TestCase1", TC_FAIL, "TSMimeHdrDestroy return TS_ERROR");

5041

SDK_RPRINT(test, "TSMimeHdrDestroy", "TestCase1", TC_FAIL, "Probably TSMimeHdrCreate failed.");

5042

} else {

5043

SDK_RPRINT(test, "TSMimeHdrDestroy", "TestCase1", TC_PASS, "ok");

5044

test_passed_Mime_Hdr_Destroy = true;

5045

}

5046

/** Commented out as Traffic Server was crashing. Will have to look into it. */

5047

5048

if (TSHandleMLocRelease(bufp1,TS_NULL_MLOC,mime_loc1)==TS_ERROR) {

5049

SDK_RPRINT(test,"TSHandleMLocRelease","TSMimeHdrDestroy",TC_FAIL,"unable to release handle using TSHandleMLocRelease");

5050

}

5051

5052

} else {

5053

SDK_RPRINT(test, "TSMimeHdrDestroy", "TestCase1", TC_FAIL, "Cannot run test as TSMimeHdrCreate failed");

5054

}

5055

5056

// MBuffer Destroy

5057

if (test_passed_MBuffer_Create == true) {

5058

if (TSMBufferDestroy(bufp1) == TS_ERROR) {

5059

SDK_RPRINT(test, "TSMBufferDestroy", "TestCase1", TC_FAIL, "TSMBufferDestroy return TS_ERROR");

5060

SDK_RPRINT(test, "TSMBufferDestroy", "TestCase1", TC_FAIL, "Probably TSMBufferCreate failed.");

5061

} else {

5062

SDK_RPRINT(test, "TSMBufferDestroy", "TestCase1", TC_PASS, "ok");

5063

test_passed_MBuffer_Destroy = true;

5064

}

5065

} else {

5066

SDK_RPRINT(test, "TSMimeHdrDestroy", "TestCase1", TC_FAIL, "Cannot run test as TSMimeHdrCreate failed");

5067

}

5068

5069

5070

if ((test_passed_MBuffer_Create == true) &&

5071

(test_passed_Mime_Hdr_Create == true) &&

5072

(test_passed_Mime_Hdr_Field_Create == true) &&

5073

(test_passed_Mime_Hdr_Field_Name == true) &&

5074

(test_passed_Mime_Hdr_Field_Append == true) &&

5075

(test_passed_Mime_Hdr_Field_Get == true) &&

5076

(test_passed_Mime_Hdr_Field_Next == true) &&

5077

(test_passed_Mime_Hdr_Fields_Count == true) &&

5078

(test_passed_Mime_Hdr_Field_Value_String_Insert == true) &&

5079

(test_passed_Mime_Hdr_Field_Value_String_Get == true) &&

5080

(test_passed_Mime_Hdr_Field_Value_String_Set == true) &&

5081

(test_passed_Mime_Hdr_Field_Value_Date_Insert == true) &&

5082

(test_passed_Mime_Hdr_Field_Value_Date_Get == true) &&

5083

(test_passed_Mime_Hdr_Field_Value_Date_Set == true) &&

5084

(test_passed_Mime_Hdr_Field_Value_Int_Insert == true) &&

5085

(test_passed_Mime_Hdr_Field_Value_Int_Get == true) &&

5086

(test_passed_Mime_Hdr_Field_Value_Int_Set == true) &&

5087

(test_passed_Mime_Hdr_Field_Value_Uint_Insert == true) &&

5088

(test_passed_Mime_Hdr_Field_Value_Uint_Get == true) &&

5089

(test_passed_Mime_Hdr_Field_Value_Uint_Set == true) &&

5090

(test_passed_Mime_Hdr_Field_Value_Append == true) &&

5091

(test_passed_Mime_Hdr_Field_Value_Delete == true) &&

5092

(test_passed_Mime_Hdr_Field_Values_Clear == true) &&

5093

(test_passed_Mime_Hdr_Field_Values_Count == true) &&

5094

(test_passed_Mime_Hdr_Field_Destroy == true) &&

5095

(test_passed_Mime_Hdr_Fields_Clear == true) &&

5096

(test_passed_Mime_Hdr_Destroy == true) &&

5097

(test_passed_MBuffer_Destroy == true) && (test_passed_Mime_Hdr_Field_Length_Get == true)

5098

) {

5099

*pstatus = REGRESSION_TEST_PASSED;

5100

} else {

5101

*pstatus = REGRESSION_TEST_FAILED;

5102

}

5103

return;

5104

5105

}

5106

5107

5108

//////////////////////////////////////////////

5109

// SDK_API_TSHttpHdrParse

5110

5111

// Unit Test for API: TSHttpParserCreate

5112

// TSHttpParserDestroy

5113

// TSHttpParserClear

5114

// TSHttpHdrParseReq

5115

// TSHttpHdrParseResp

5116

//////////////////////////////////////////////

5117

5118

char *

5119

convert_http_hdr_to_string(TSMBuffer bufp, TSMLoc hdr_loc)

5120

{

5121

TSIOBuffer output_buffer;

5122

TSIOBufferReader reader;

5123

int64_t total_avail;

5124

5125

TSIOBufferBlock block;

5126

const char *block_start;

5127

int64_t block_avail;

5128

5129

char *output_string;

5130

int output_len;

5131

5132

output_buffer = TSIOBufferCreate();

5133

5134

if (!output_buffer) {

5135

TSError("couldn't allocate IOBuffer\n");

5136

}

5137

5138

reader = TSIOBufferReaderAlloc(output_buffer);

5139

5140

/* This will print just MIMEFields and not

5141

the http request line */

5142

TSHttpHdrPrint(bufp, hdr_loc, output_buffer);

5143

5144

/* Find out how the big the complete header is by

5145

seeing the total bytes in the buffer. We need to

5146

look at the buffer rather than the first block to

5147

see the size of the entire header */

5148

total_avail = TSIOBufferReaderAvail(reader);

5149

5150

/* Allocate the string with an extra byte for the string

5151

terminator */

5152

output_string = (char *) TSmalloc(total_avail + 1);

5153

output_len = 0;

5154

5155

/* We need to loop over all the buffer blocks to make

5156

sure we get the complete header since the header can

5157

be in multiple blocks */

5158

block = TSIOBufferReaderStart(reader);

5159

while (block) {

5160

5161

block_start = TSIOBufferBlockReadStart(block, reader, &block_avail);

5162

5163

/* We'll get a block pointer back even if there is no data

5164

left to read so check for this condition and break out of

5165

the loop. A block with no data to read means we've exhausted

5166

buffer of data since if there was more data on a later

5167

block in the chain, this block would have been skipped over */

5168

if (block_avail == 0) {

5169

break;

5170

}

5171

5172

memcpy(output_string + output_len, block_start, block_avail);

5173

output_len += block_avail;

5174

5175

/* Consume the data so that we get to the next block */

5176

TSIOBufferReaderConsume(reader, block_avail);

5177

5178

/* Get the next block now that we've consumed the

5179

data off the last block */

5180

block = TSIOBufferReaderStart(reader);

5181

}

5182

5183

/* Terminate the string */

5184

output_string[output_len] = '\0';

5185

output_len++;

5186

5187

/* Free up the TSIOBuffer that we used to print out the header */

5188

TSIOBufferReaderFree(reader);

5189

TSIOBufferDestroy(output_buffer);

5190

5191

return output_string;

5192

}

5193

5194

REGRESSION_TEST(SDK_API_TSHttpHdrParse) (RegressionTest * test, int atype, int *pstatus)

5195

{

5196

NOWARN_UNUSED(atype);

5197

const char *req =

5198

"GET http://www.example.com/ HTTP/1.1\r\nmimefield1:field1value1,field1value2\r\nmimefield2:field2value1,field2value2\r\n\r\n";

5199

const char *resp =

5200

"HTTP/1.1 200 OK\r\n1mimefield:1field1value,1field2value\r\n2mimefield:2field1value,2field2value\r\n\r\n";

5201

const char *start;

5202

const char *end;

5203

char *temp;

5204

5205

int retval;

5206

5207

TSMBuffer reqbufp;

5208

TSMBuffer respbufp = (TSMBuffer) TS_ERROR_PTR;

5209

5210

TSMLoc req_hdr_loc = (TSMLoc) TS_ERROR_PTR;

5211

TSMLoc resp_hdr_loc = (TSMLoc) TS_ERROR_PTR;

5212

5213

TSHttpParser parser;

5214

5215

bool test_passed_parse_req = false;

5216

bool test_passed_parse_resp = false;

5217

bool test_passed_parser_clear = false;

5218

bool test_passed_parser_destroy = false;

5219

bool resp_run = true;

5220

5221

5222

//Create Parser

5223

parser = TSHttpParserCreate();

5224

if (parser == TS_ERROR_PTR) {

5225

SDK_RPRINT(test, "TSHttpParserCreate", "TestCase1", TC_FAIL, "TSHttpParserCreate returns TS_ERROR_PTR");

5226

SDK_RPRINT(test, "TSHttpParserDestroy", "TestCase1", TC_FAIL, "Unable to run test as TSHttpParserCreate failed");

5227

SDK_RPRINT(test, "TSHttpParserClear", "TestCase1", TC_FAIL, "Unable to run test as TSHttpParserCreate failed");

5228

SDK_RPRINT(test, "TSHttpHdrParseReq", "TestCase1", TC_FAIL, "Unable to run test as TSHttpParserCreate failed");

5229

SDK_RPRINT(test, "TSHttpHdrParseResp", "TestCase1", TC_FAIL, "Unable to run test as TSHttpParserCreate failed");

5230

5231

*pstatus = REGRESSION_TEST_FAILED;

5232

return;

5233

} else {

5234

SDK_RPRINT(test, "TSHttpParserCreate", "TestCase1", TC_PASS, "ok");

5235

}

5236

5237

// Request

5238

reqbufp = TSMBufferCreate();

5239

if (reqbufp == TS_ERROR_PTR) {

5240

SDK_RPRINT(test, "TSHttpHdrParseReq", "TestCase1", TC_FAIL, "Cannot create buffer for parsing request");

5241

} else {

5242

req_hdr_loc = TSHttpHdrCreate(reqbufp);

5243

if (req_hdr_loc == TS_ERROR_PTR) {

5244

SDK_RPRINT(test, "TSHttpHdrParseReq", "TestCase1", TC_FAIL, "Cannot create Http hdr for parsing request");

5245

if (TSMBufferDestroy(reqbufp) == TS_ERROR) {

5246

SDK_RPRINT(test, "TSHttpHdrParseReq", "TestCase1", TC_FAIL, "Error in Destroying MBuffer");

5247

}

5248

} else {

5249

start = req;

5250

end = req + strlen(req) + 1;

5251

if ((retval = TSHttpHdrParseReq(parser, reqbufp, req_hdr_loc, &start, end)) == TS_PARSE_ERROR) {

5252

SDK_RPRINT(test, "TSHttpHdrParseReq", "TestCase1", TC_FAIL, "TSHttpHdrParseReq returns TS_PARSE_ERROR");

5253

} else {

5254

if (retval == TS_PARSE_DONE) {

5255

test_passed_parse_req = true;

5256

} else {

5257

SDK_RPRINT(test, "TSHttpHdrParseReq", "TestCase1", TC_FAIL, "Parsing Error");

5258

}

5259

}

5260

}

5261

}

5262

5263

if (TSHttpParserClear(parser) == TS_ERROR) {

5264

SDK_RPRINT(test, "TSHttpParserClear", "TestCase1", TC_FAIL, "TSHttpParserClear returns TS_ERROR");

5265

SDK_RPRINT(test, "TSHttpHdrParseResp", "TestCase1", TC_FAIL, "Cannot run test as TSHttpParserClear Failed");

5266

} else {

5267

SDK_RPRINT(test, "TSHttpParserClear", "TestCase1", TC_PASS, "ok");

5268

test_passed_parser_clear = true;

5269

}

5270

5271

// Response

5272

if (test_passed_parser_clear == true) {

5273

respbufp = TSMBufferCreate();

5274

if (respbufp == TS_ERROR_PTR) {

5275

SDK_RPRINT(test, "TSHttpHdrParseResp", "TestCase1", TC_FAIL, "Cannot create buffer for parsing response");

5276

} else {

5277

resp_hdr_loc = TSHttpHdrCreate(respbufp);

5278

if (resp_hdr_loc == TS_ERROR_PTR) {

5279

SDK_RPRINT(test, "TSHttpHdrParseResp", "TestCase1", TC_FAIL, "Cannot create Http hdr for parsing response");

5280

if (TSMBufferDestroy(respbufp) == TS_ERROR) {

5281

SDK_RPRINT(test, "TSHttpHdrParseResp", "TestCase1", TC_FAIL, "Error in Destroying MBuffer");

5282

}

5283

} else {

5284

start = resp;

5285

end = resp + strlen(resp) + 1;

5286

if ((retval = TSHttpHdrParseResp(parser, respbufp, resp_hdr_loc, &start, end)) == TS_PARSE_ERROR) {

5287

SDK_RPRINT(test, "TSHttpHdrParseReq", "TestCase1", TC_FAIL,

5288

"TSHttpHdrParseReq returns TS_PARSE_ERROR. Maybe an error with TSHttpParserClear.");

5289

} else {

5290

if (retval == TS_PARSE_DONE) {

5291

test_passed_parse_resp = true;

5292

} else {

5293

SDK_RPRINT(test, "TSHttpHdrParseResp", "TestCase1", TC_FAIL, "Parsing Error");

5294

}

5295

}

5296

}

5297

}

5298

} else {

5299

resp_run = false;

5300

}

5301

5302

if (test_passed_parse_req == true) {

5303

temp = convert_http_hdr_to_string(reqbufp, req_hdr_loc);

5304

if (strcmp(req, temp) == 0) {

5305

SDK_RPRINT(test, "TSHttpHdrParseReq", "TestCase1", TC_PASS, "ok");

5306

} else {

5307

SDK_RPRINT(test, "TSHttpHdrParseReq", "TestCase1", TC_FAIL, "Incorrect parsing");

5308

test_passed_parse_req = false;

5309

}

5310

TSfree(temp);

5311

}

5312

5313

if (test_passed_parse_resp == true) {

5314

temp = convert_http_hdr_to_string(respbufp, resp_hdr_loc);

5315

if (strcmp(resp, temp) == 0) {

5316

SDK_RPRINT(test, "TSHttpHdrParseResp", "TestCase1", TC_PASS, "ok");

5317

} else {

5318

SDK_RPRINT(test, "TSHttpHdrParseResp", "TestCase1", TC_FAIL, "Incorrect parsing");

5319

test_passed_parse_resp = false;

5320

}

5321

TSfree(temp);

5322

}

5323

5324

if (TSHttpParserDestroy(parser) != TS_SUCCESS) {

5325

SDK_RPRINT(test, "TSHttpParserDestroy", "TestCase1", TC_FAIL, "TSHttpParserDestroy doesn't return TS_SUCCESS");

5326

} else {

5327

SDK_RPRINT(test, "TSHttpParserDestroy", "TestCase1", TC_PASS, "ok");

5328

test_passed_parser_destroy = true;

5329

}

5330

5331

if ((test_passed_parse_req != true) ||

5332

(test_passed_parse_resp != true) || (test_passed_parser_clear != true) || (test_passed_parser_destroy != true)

5333

) {

5334

*pstatus = REGRESSION_TEST_FAILED;

5335

} else {

5336

*pstatus = REGRESSION_TEST_PASSED;

5337

}

5338

5339

TSMimeHdrDestroy(reqbufp, req_hdr_loc);

5340

if (resp_run == true)

5341

TSMimeHdrDestroy(respbufp, resp_hdr_loc);

5342

5343

TSHandleMLocRelease(reqbufp, TS_NULL_MLOC, req_hdr_loc);

5344

if (resp_run == true)

5345

TSHandleMLocRelease(respbufp, TS_NULL_MLOC, resp_hdr_loc);

5346

5347

TSMBufferDestroy(reqbufp);

5348

if (resp_run == true)

5349

TSMBufferDestroy(respbufp);

5350

5351

return;

5352

}

5353

5354

5355

5356

5357

//////////////////////////////////////////////

5358

// SDK_API_TSMimeHdrParse

5359

5360

// Unit Test for API: TSMimeHdrCopy

5361

// TSMimeHdrClone

5362

// TSMimeHdrFieldCopy

5363

// TSMimeHdrFieldClone

5364

// TSMimeHdrFieldCopyValues

5365

// TSMimeHdrFieldNextDup

5366

// TSMimeHdrFieldRemove

5367

// TSMimeHdrLengthGet

5368

// TSMimeHdrParse

5369

// TSMimeHdrPrint

5370

// TSMimeParserClear

5371

// TSMimeParserCreate

5372

// TSMimeParserDestroy

5373

// TSHandleMLocRelease

5374

//////////////////////////////////////////////

5375

5376

char *

5377

convert_mime_hdr_to_string(TSMBuffer bufp, TSMLoc hdr_loc)

5378

{

5379

TSIOBuffer output_buffer;

5380

TSIOBufferReader reader;

5381

int64_t total_avail;

5382

5383

TSIOBufferBlock block;

5384

const char *block_start;

5385

int64_t block_avail;

5386

5387

char *output_string;

5388

int output_len;

5389

5390

output_buffer = TSIOBufferCreate();

5391

5392

if (!output_buffer) {

5393

TSError("couldn't allocate IOBuffer\n");

5394

}

5395

5396

reader = TSIOBufferReaderAlloc(output_buffer);

5397

5398

/* This will print just MIMEFields and not

5399

the http request line */

5400

TSMimeHdrPrint(bufp, hdr_loc, output_buffer);

5401

5402

/* Find out how the big the complete header is by

5403

seeing the total bytes in the buffer. We need to

5404

look at the buffer rather than the first block to

5405

see the size of the entire header */

5406

total_avail = TSIOBufferReaderAvail(reader);

5407

5408

/* Allocate the string with an extra byte for the string

5409

terminator */

5410

output_string = (char *) TSmalloc(total_avail + 1);

5411

output_len = 0;

5412

5413

/* We need to loop over all the buffer blocks to make

5414

sure we get the complete header since the header can

5415

be in multiple blocks */

5416

block = TSIOBufferReaderStart(reader);

5417

while (block) {

5418

5419

block_start = TSIOBufferBlockReadStart(block, reader, &block_avail);

5420

5421

/* We'll get a block pointer back even if there is no data

5422

left to read so check for this condition and break out of

5423

the loop. A block with no data to read means we've exhausted

5424

buffer of data since if there was more data on a later

5425

block in the chain, this block would have been skipped over */

5426

if (block_avail == 0) {

5427

break;

5428

}

5429

5430

memcpy(output_string + output_len, block_start, block_avail);

5431

output_len += block_avail;

5432

5433

/* Consume the data so that we get to the next block */

5434

TSIOBufferReaderConsume(reader, block_avail);

5435

5436

/* Get the next block now that we've consumed the

5437

data off the last block */

5438

block = TSIOBufferReaderStart(reader);

5439

}

5440

5441

/* Terminate the string */

5442

output_string[output_len] = '\0';

5443

output_len++;

5444

5445

/* Free up the TSIOBuffer that we used to print out the header */

5446

TSIOBufferReaderFree(reader);

5447

TSIOBufferDestroy(output_buffer);

5448

5449

return output_string;

5450

}

5451

5452

TSReturnCode

5453

compare_field_values(RegressionTest * test, TSMBuffer bufp1, TSMLoc hdr_loc1, TSMLoc field_loc1, TSMBuffer bufp2,

5454

TSMBuffer hdr_loc2, TSMLoc field_loc2, bool first_time)

5455

{

5456

5457

int no_of_values1;

5458

int no_of_values2;

5459

int i;

5460

5461

const char *str1 = NULL;

5462

const char *str2 = NULL;

5463

5464

int length1 = 0;

5465

int length2 = 0;

5466

5467

no_of_values1 = TSMimeHdrFieldValuesCount(bufp1, hdr_loc1, field_loc1);

5468

no_of_values2 = TSMimeHdrFieldValuesCount(bufp2, hdr_loc2, field_loc2);

5469

if ((no_of_values1 == TS_ERROR) || (no_of_values2 == TS_ERROR)) {

5470

SDK_RPRINT(test, "compare_field_values", "TestCase", TC_FAIL, "TSMimeHdrFieldValuesCount returns TS_ERROR");

5471

return TS_ERROR;

5472

}

5473

5474

if (no_of_values1 != no_of_values2) {

5475

SDK_RPRINT(test, "compare_field_values", "TestCase", TC_FAIL, "Field Values not equal");

5476

return TS_ERROR;

5477

}

5478

5479

for (i = 0; i < no_of_values1; i++) {

5480

if ((TSMimeHdrFieldValueStringGet(bufp1, hdr_loc1, field_loc1, i, &str1, &length1) != TS_SUCCESS) ||

5481

(TSMimeHdrFieldValueStringGet(bufp2, hdr_loc2, field_loc2, i, &str2, &length2) != TS_SUCCESS)) {

5482

SDK_RPRINT(test, "compare_field_values", "TestCase", TC_FAIL,

5483

"TSMimeHdrFieldValueStringGet doesn't return TS_SUCCESS");

5484

return TS_ERROR;

5485

}

5486

if (!((length1 == length2) && (strncmp(str1, str2, length1) == 0))) {

5487

SDK_RPRINT(test, "compare_field_values", "TestCase", TC_FAIL, "Field Value %d differ from each other", i);

5488

return TS_ERROR;

5489

}

5490

}

5491

5492

return TS_SUCCESS;

5493

}

5494

5495

5496

REGRESSION_TEST(SDK_API_TSMimeHdrParse) (RegressionTest * test, int atype, int *pstatus)

5497

{

5498

NOWARN_UNUSED(atype);

5499

const char *parse_string =

5500

"field1:field1Value1,field1Value2\r\nfield2:10,-34,45\r\nfield3:field3Value1,23\r\nfield2: 2345, field2Value2\r\n\r\n";

5501

const char *DUPLICATE_FIELD_NAME = "field2";

5502

const char *REMOVE_FIELD_NAME = "field3";

5503

5504

TSMimeParser parser;

5505

5506

TSMBuffer bufp1 = (TSMBuffer) TS_ERROR_PTR;

5507

TSMBuffer bufp2 = (TSMBuffer) TS_ERROR_PTR;

5508

TSMBuffer bufp3 = (TSMBuffer) TS_ERROR_PTR;

5509

5510

TSMLoc mime_hdr_loc1 = (TSMLoc) TS_ERROR_PTR;

5511

TSMLoc mime_hdr_loc2 = (TSMLoc) TS_ERROR_PTR;

5512

TSMLoc mime_hdr_loc3 = (TSMLoc) TS_ERROR_PTR;

5513

5514

TSMLoc field_loc1 = (TSMLoc) TS_ERROR_PTR;

5515

TSMLoc field_loc2 = (TSMLoc) TS_ERROR_PTR;

5516

5517

const char *start;

5518

const char *end;

5519

char *temp;

5520

5521

int retval;

5522

int hdrLength;

5523

5524

bool test_passed_parser_create = false;

5525

bool test_passed_parse = false;

5526

bool test_passed_parser_clear = false;

5527

bool test_passed_parser_destroy = false;

5528

bool test_passed_mime_hdr_print = false;

5529

bool test_passed_mime_hdr_length_get = false;

5530

bool test_passed_mime_hdr_field_next_dup = false;

5531

bool test_passed_mime_hdr_copy = false;

5532

bool test_passed_mime_hdr_clone = false;

5533

bool test_passed_mime_hdr_field_remove = false;

5534

bool test_passed_mime_hdr_field_copy = false;

5535

bool test_passed_mime_hdr_field_copy_values = false;

5536

bool test_passed_handle_mloc_release = false;

5537

bool test_passed_mime_hdr_field_find = false;

5538

5539

//Create Parser

5540

parser = TSMimeParserCreate();

5541

if (parser == TS_ERROR_PTR) {

5542

SDK_RPRINT(test, "TSMimeParserCreate", "TestCase1", TC_FAIL, "TSMimeParserCreate returns TS_ERROR_PTR");

5543

} else {

5544

SDK_RPRINT(test, "TSMimeParserCreate", "TestCase1", TC_PASS, "ok");

5545

test_passed_parser_create = true;

5546

}

5547

5548

if (test_passed_parser_create == true) {

5549

// Parsing

5550

bufp1 = TSMBufferCreate();

5551

if (bufp1 == TS_ERROR_PTR) {

5552

SDK_RPRINT(test, "TSMimeHdrParse", "TestCase1", TC_FAIL, "Cannot create buffer for parsing");

5553

SDK_RPRINT(test, "TSMimeHdrPrint", "TestCase1", TC_FAIL,

5554

"Cannot run test as unable to create a buffer for parsing");

5555

SDK_RPRINT(test, "TSMimeHdrLengthGet", "TestCase1", TC_FAIL,

5556

"Cannot run test as unable to create a buffer for parsing");

5557

} else {

5558

mime_hdr_loc1 = TSMimeHdrCreate(bufp1);

5559

if (mime_hdr_loc1 == TS_ERROR_PTR) {

5560

SDK_RPRINT(test, "TSMimeHdrParse", "TestCase1", TC_FAIL, "Cannot create Mime hdr for parsing");

5561

SDK_RPRINT(test, "TSMimeHdrPrint", "TestCase1", TC_FAIL,

5562

"Cannot run test as unable to create Mime Header for parsing");

5563

SDK_RPRINT(test, "TSMimeHdrLengthGet", "TestCase1", TC_FAIL,

5564

"Cannot run test as unable to create Mime Header for parsing");

5565

5566

if (TSMBufferDestroy(bufp1) == TS_ERROR) {

5567

SDK_RPRINT(test, "TSMimeHdrParse", "TestCase1", TC_FAIL, "Error in Destroying MBuffer");

5568

}

5569

} else {

5570

start = parse_string;

5571

end = parse_string + strlen(parse_string) + 1;

5572

if ((retval = TSMimeHdrParse(parser, bufp1, mime_hdr_loc1, &start, end)) == TS_PARSE_ERROR) {

5573

SDK_RPRINT(test, "TSMimeHdrParse", "TestCase1", TC_FAIL, "TSMimeHdrParse returns TS_PARSE_ERROR");

5574

SDK_RPRINT(test, "TSMimeHdrPrint", "TestCase1", TC_FAIL,

5575

"Cannot run test as TSMimeHdrParse returned Error.");

5576

SDK_RPRINT(test, "TSMimeHdrLengthGet", "TestCase1", TC_FAIL,

5577

"Cannot run test as TSMimeHdrParse returned Error.");

5578

} else {

5579

if (retval == TS_PARSE_DONE) {

5580

temp = convert_mime_hdr_to_string(bufp1, mime_hdr_loc1); // Implements TSMimeHdrPrint.

5581

if (strcmp(parse_string, temp) == 0) {

5582

SDK_RPRINT(test, "TSMimeHdrParse", "TestCase1", TC_PASS, "ok");

5583

SDK_RPRINT(test, "TSMimeHdrPrint", "TestCase1", TC_PASS, "ok");

5584

5585

// TSMimeHdrLengthGet

5586

if ((hdrLength = TSMimeHdrLengthGet(bufp1, mime_hdr_loc1)) == TS_ERROR) {

5587

SDK_RPRINT(test, "TSMimeHdrLengthGet", "TestCase1", TC_FAIL, "TSMimeHdrLengthGet returns TS_ERROR");

5588

} else {

5589

if (hdrLength == (int) strlen(temp)) {

5590

SDK_RPRINT(test, "TSMimeHdrLengthGet", "TestCase1", TC_PASS, "ok");

5591

test_passed_mime_hdr_length_get = true;

5592

} else {

5593

SDK_RPRINT(test, "TSMimeHdrLengthGet", "TestCase1", TC_FAIL, "Value's Mismatch");

5594

}

5595

}

5596

5597

test_passed_parse = true;

5598

test_passed_mime_hdr_print = true;

5599

} else {

5600

SDK_RPRINT(test, "TSMimeHdrParse|TSMimeHdrPrint", "TestCase1", TC_FAIL,

5601

"Incorrect parsing or incorrect Printing");

5602

SDK_RPRINT(test, "TSMimeHdrLengthGet", "TestCase1", TC_FAIL,

5603

"Cannot run test as TSMimeHdrParse|TSMimeHdrPrint failed.");

5604

}

5605

5606

TSfree(temp);

5607

} else {

5608

SDK_RPRINT(test, "TSMimeHdrParse", "TestCase1", TC_FAIL, "Parsing Error");

5609

SDK_RPRINT(test, "TSMimeHdrPrint", "TestCase1", TC_FAIL,

5610

"Cannot run test as TSMimeHdrParse returned error.");

5611

SDK_RPRINT(test, "TSMimeHdrLengthGet", "TestCase1", TC_FAIL,

5612

"Cannot run test as TSMimeHdrParse returned error.");

5613

}

5614

}

5615

}

5616

}

5617

} else {

5618

SDK_RPRINT(test, "TSMimeHdrParse", "TestCase1", TC_FAIL, "Cannot run test as unable to create a parser");

5619

SDK_RPRINT(test, "TSMimeHdrPrint", "TestCase1", TC_FAIL, "Cannot run test as unable to create a parser");

5620

SDK_RPRINT(test, "TSMimeHdrLengthGet", "TestCase1", TC_FAIL, "Cannot run test as unable to create a parser");

5621

}

5622

5623

5624

// HOW DO I CHECK FOR PARSER CLEAR????

5625

if (test_passed_parser_create == true) {

5626

if (TSMimeParserClear(parser) == TS_ERROR) {

5627

SDK_RPRINT(test, "TSMimeParserClear", "TestCase1", TC_FAIL, "TSMimeParserClear returns TS_ERROR");

5628

} else {

5629

SDK_RPRINT(test, "TSMimeParserClear", "TestCase1", TC_PASS, "ok");

5630

test_passed_parser_clear = true;

5631

}

5632

} else {

5633

SDK_RPRINT(test, "TSMimeParserClear", "TestCase1", TC_FAIL, "Cannot run test as unable to create a parser");

5634

}

5635

5636

5637

if (test_passed_parser_create == true) {

5638

if (TSMimeParserDestroy(parser) != TS_SUCCESS) {

5639

SDK_RPRINT(test, "TSMimeParserDestroy", "TestCase1", TC_FAIL, "TSMimeParserDestroy doesn't return TS_SUCCESS");

5640

} else {

5641

SDK_RPRINT(test, "TSMimeParserDestroy", "TestCase1", TC_PASS, "ok");

5642

test_passed_parser_destroy = true;

5643

}

5644

} else {

5645

SDK_RPRINT(test, "TSMimeParserDestroy", "TestCase1", TC_FAIL, "Cannot run test as unable to create a parser");

5646

}

5647

5648

//TSMimeHdrFieldNextDup

5649

if (test_passed_parse == true) {

5650

if ((field_loc1 = TSMimeHdrFieldFind(bufp1, mime_hdr_loc1, DUPLICATE_FIELD_NAME, -1)) == TS_ERROR_PTR) {

5651

SDK_RPRINT(test, "TSMimeHdrFieldNextDup", "TestCase1", TC_FAIL, "TSMimeHdrFieldFind returns TS_ERROR_PTR");

5652

SDK_RPRINT(test, "TSMimeHdrFieldFind", "TestCase1", TC_PASS, "TSMimeHdrFieldFind returns TS_ERROR_PTR");

5653

} else {

5654

const char *fieldName;

5655

int length;

5656

if ((fieldName = TSMimeHdrFieldNameGet(bufp1, mime_hdr_loc1, field_loc1, &length)) != TS_ERROR_PTR) {

5657

if (strncmp(fieldName, DUPLICATE_FIELD_NAME, length) == 0) {

5658

SDK_RPRINT(test, "TSMimeHdrFieldFind", "TestCase1", TC_PASS, "ok");

5659

test_passed_mime_hdr_field_find = true;

5660

} else {

5661

SDK_RPRINT(test, "TSMimeHdrFieldFind", "TestCase1", TC_PASS,

5662

"TSMimeHdrFieldFind returns incorrect field pointer");

5663

}

5664

} else {

5665

SDK_RPRINT(test, "TSMimeHdrFieldFind", "TestCase1", TC_PASS, "TSMimeHdrFieldNameGet returns TS_ERROR_PTR");

5666

}

5667

5668

if ((field_loc2 = TSMimeHdrFieldNextDup(bufp1, mime_hdr_loc1, field_loc1)) == TS_ERROR_PTR) {

5669

SDK_RPRINT(test, "TSMimeHdrFieldNextDup", "TestCase1", TC_FAIL,

5670

"TSMimeHdrFieldNextDup returns TS_ERROR_PTR");

5671

} else {

5672

if (compare_field_names(test, bufp1, mime_hdr_loc1, field_loc1, bufp1, mime_hdr_loc1, field_loc2) == TS_ERROR) {

5673

SDK_RPRINT(test, "TSMimeHdrFieldNextDup", "TestCase1", TC_FAIL, "Incorrect Pointer");

5674

} else {

5675

SDK_RPRINT(test, "TSMimeHdrFieldNextDup", "TestCase1", TC_PASS, "ok");

5676

test_passed_mime_hdr_field_next_dup = true;

5677

}

5678

}

5679

5680

// TSHandleMLocRelease

5681

if (TSHandleMLocRelease(bufp1, mime_hdr_loc1, field_loc1) == TS_ERROR) {

5682

SDK_RPRINT(test, "TSHandleMLocRelease", "TestCase1", TC_FAIL, "TSHandleMLocRelease returns TS_ERROR");

5683

} else {

5684

SDK_RPRINT(test, "TSHandleMLocRelease", "TestCase1", TC_PASS, "ok");

5685

test_passed_handle_mloc_release = true;

5686

}

5687

5688

if ((field_loc2 != NULL) && (field_loc2 != TS_ERROR_PTR)) {

5689

if (TSHandleMLocRelease(bufp1, mime_hdr_loc1, field_loc2) == TS_ERROR) {

5690

SDK_RPRINT(test, "TSHandleMLocRelease", "TestCase2", TC_FAIL, "TSHandleMLocRelease returns TS_ERROR");

5691

test_passed_handle_mloc_release = false;

5692

} else {

5693

SDK_RPRINT(test, "TSHandleMLocRelease", "TestCase2", TC_PASS, "ok");

5694

}

5695

}

5696

}

5697

} else {

5698

SDK_RPRINT(test, "TSMimeHdrFieldNext", "TestCase1", TC_FAIL, "Unable to run test as parsing failed.");

5699

}

5700

5701

//TSMimeHdrCopy

5702

if (test_passed_parse == true) {

5703

// Parsing

5704

bufp2 = TSMBufferCreate();

5705

if (bufp2 == TS_ERROR_PTR) {

5706

SDK_RPRINT(test, "TSMimeHdrCopy", "TestCase1", TC_FAIL, "Cannot create buffer for copying.");

5707

} else {

5708

mime_hdr_loc2 = TSMimeHdrCreate(bufp2);

5709

if (mime_hdr_loc2 == TS_ERROR_PTR) {

5710

SDK_RPRINT(test, "TSMimeHdrCopy", "TestCase1", TC_FAIL, "Cannot create Mime hdr for copying");

5711

if (TSMBufferDestroy(bufp2) == TS_ERROR) {

5712

SDK_RPRINT(test, "TSMimeHdrCopy", "TestCase1", TC_FAIL, "Error in Destroying MBuffer");

5713

}

5714

} else {

5715

if (TSMimeHdrCopy(bufp2, mime_hdr_loc2, bufp1, mime_hdr_loc1) == TS_ERROR) {

5716

SDK_RPRINT(test, "TSMimeHdrCopy", "TestCase1", TC_FAIL, "TSMimeHdrCopy returns TS_ERROR");

5717

} else {

5718

temp = convert_mime_hdr_to_string(bufp2, mime_hdr_loc2); // Implements TSMimeHdrPrint.

5719

if (strcmp(parse_string, temp) == 0) {

5720

SDK_RPRINT(test, "TSMimeHdrCopy", "TestCase1", TC_PASS, "ok");

5721

test_passed_mime_hdr_copy = true;

5722

} else {

5723

SDK_RPRINT(test, "TSMimeHdrCopy", "TestCase1", TC_FAIL, "Value's Mismatch");

5724

}

5725

TSfree(temp);

5726

}

5727

}

5728

}

5729

} else {

5730

SDK_RPRINT(test, "TSMimeHdrCopy", "TestCase1", TC_FAIL, "Unable to run test as parsing failed.");

5731

}

5732

5733

bufp3 = TSMBufferCreate();

5734

mime_hdr_loc3 = TSMimeHdrCreate(bufp3);

5735

test_passed_mime_hdr_clone = true;

5736

5737

// TSMimeHdrFieldRemove

5738

if (test_passed_mime_hdr_copy == true) {

5739

if ((field_loc1 = TSMimeHdrFieldFind(bufp2, mime_hdr_loc2, REMOVE_FIELD_NAME, -1)) == TS_ERROR_PTR) {

5740

SDK_RPRINT(test, "TSMimeHdrFieldRemove", "TestCase1", TC_FAIL, "TSMimeHdrFieldFind returns TS_ERROR_PTR");

5741

} else {

5742

if (TSMimeHdrFieldRemove(bufp2, mime_hdr_loc2, field_loc1) == TS_ERROR) {

5743

SDK_RPRINT(test, "TSMimeHdrFieldRemove", "TestCase1", TC_FAIL, "TSMimeHdrFieldRemove returns TS_ERROR_PTR");

5744

} else {

5745

if ((field_loc2 = TSMimeHdrFieldFind(bufp2, mime_hdr_loc2, REMOVE_FIELD_NAME, -1)) == TS_ERROR_PTR) {

5746

SDK_RPRINT(test, "TSMimeHdrFieldRemove", "TestCase1", TC_FAIL, "TSMimeHdrFieldFind returns TS_ERROR_PTR");

5747

} else {

5748

if ((field_loc2 == NULL) || (field_loc1 != field_loc2)) {

5749

test_passed_mime_hdr_field_remove = true;

5750

} else {

5751

SDK_RPRINT(test, "TSMimeHdrFieldRemove", "TestCase1", TC_FAIL, "Field Not Removed");

5752

}

5753

5754

if ((test_passed_mime_hdr_field_remove == true)) {

5755

if (TSMimeHdrFieldAppend(bufp2, mime_hdr_loc2, field_loc1) == TS_ERROR) {

5756

SDK_RPRINT(test, "TSMimeHdrFieldRemove", "TestCase1", TC_FAIL,

5757

"Unable to readd the field to mime header. Probably destroyed");

5758

test_passed_mime_hdr_field_remove = false;

5759

} else {

5760

SDK_RPRINT(test, "TSMimeHdrFieldRemove", "TestCase1", TC_PASS, "ok");

5761

}

5762

}

5763

}

5764

}

5765

5766

// TSHandleMLocRelease

5767

if (TSHandleMLocRelease(bufp2, mime_hdr_loc2, field_loc1) == TS_ERROR) {

5768

SDK_RPRINT(test, "TSHandleMLocRelease", "TestCase3", TC_FAIL, "TSHandleMLocRelease returns TS_ERROR");

5769

test_passed_handle_mloc_release = false;

5770

} else {

5771

SDK_RPRINT(test, "TSHandleMLocRelease", "TestCase3", TC_PASS, "ok");

5772

}

5773

5774

if ((field_loc2 != NULL) && (field_loc2 != TS_ERROR_PTR)) {

5775

if (TSHandleMLocRelease(bufp2, mime_hdr_loc2, field_loc2) == TS_ERROR) {

5776

SDK_RPRINT(test, "TSHandleMLocRelease", "TestCase4", TC_FAIL, "TSHandleMLocRelease returns TS_ERROR");

5777

test_passed_handle_mloc_release = false;

5778

} else {

5779

SDK_RPRINT(test, "TSHandleMLocRelease", "TestCase4", TC_PASS, "ok");

5780

}

5781

}

5782

}

5783

} else {

5784

SDK_RPRINT(test, "TSMimeHdrFieldNext", "TestCase1", TC_FAIL, "Unable to run test as parsing failed.");

5785

}

5786

5787

// TSMimeHdrFieldCopy

5788

if (test_passed_mime_hdr_copy == true) {

5789

if ((field_loc1 = TSMimeHdrFieldCreate(bufp2, mime_hdr_loc2)) == TS_ERROR_PTR) {

5790

SDK_RPRINT(test, "TSMimeHdrFieldCopy", "TestCase1", TC_FAIL, "Unable to create field for Copying");

5791

} else {

5792

if ((field_loc2 = TSMimeHdrFieldGet(bufp1, mime_hdr_loc1, 0)) == TS_ERROR_PTR) {

5793

SDK_RPRINT(test, "TSMimeHdrFieldCopy", "TestCase1", TC_FAIL, "Unable to get source field for copying");

5794

} else {

5795

if (TSMimeHdrFieldCopy(bufp2, mime_hdr_loc2, field_loc1, bufp1, mime_hdr_loc1, field_loc2) == TS_ERROR) {

5796

SDK_RPRINT(test, "TSMimeHdrFieldCopy", "TestCase1", TC_FAIL, "TSMimeHdrFieldCopy returns TS_ERROR");

5797

} else {

5798

if ((compare_field_names(test, bufp2, mime_hdr_loc2, field_loc1, bufp1, mime_hdr_loc1, field_loc2) == TS_ERROR) ||

5799

(compare_field_values(test, bufp2, mime_hdr_loc2, field_loc1, bufp1, mime_hdr_loc1, field_loc2, true) == TS_ERROR)) {

5800

SDK_RPRINT(test, "TSMimeHdrFieldCopy", "TestCase1", TC_FAIL, "Value's Mismatch");

5801

} else {

5802

SDK_RPRINT(test, "TSMimeHdrFieldCopy", "TestCase1", TC_PASS, "ok");

5803

test_passed_mime_hdr_field_copy = true;

5804

}

5805

}

5806

}

5807

if (TSHandleMLocRelease(bufp2, mime_hdr_loc2, field_loc1) == TS_ERROR) {

5808

SDK_RPRINT(test, "TSHandleMLocRelease", "TestCase5", TC_FAIL, "TSHandleMLocRelease returns TS_ERROR");

5809

test_passed_handle_mloc_release = false;

5810

} else {

5811

SDK_RPRINT(test, "TSHandleMLocRelease", "TestCase5", TC_PASS, "ok");

5812

}

5813

5814

if ((field_loc2 != NULL) && (field_loc2 != TS_ERROR_PTR)) {

5815

if (TSHandleMLocRelease(bufp1, mime_hdr_loc1, field_loc2) == TS_ERROR) {

5816

SDK_RPRINT(test, "TSHandleMLocRelease", "TestCase6", TC_FAIL, "TSHandleMLocRelease returns TS_ERROR");

5817

test_passed_handle_mloc_release = false;

5818

} else {

5819

SDK_RPRINT(test, "TSHandleMLocRelease", "TestCase6", TC_PASS, "ok");

5820

}

5821

}

5822

}

5823

} else {

5824

SDK_RPRINT(test, "TSMimeHdrFieldCopy", "TestCase1", TC_FAIL,

5825

"Unable to run test as bufp2 might not have been created");

5826

}

5827

5828

// TSMimeHdrFieldClone

5829

if (test_passed_mime_hdr_clone == true) {

5830

field_loc1 = NULL;

5831

field_loc2 = NULL;

5832

if ((field_loc2 = TSMimeHdrFieldGet(bufp1, mime_hdr_loc1, 0)) == TS_ERROR_PTR) {

5833

SDK_RPRINT(test, "TSMimeHdrFieldClone", "TestCase1", TC_FAIL, "Unable to get source field for copying");

5834

} else {

5835

if ((field_loc1 = TSMimeHdrFieldClone(bufp3, mime_hdr_loc3, bufp1, mime_hdr_loc1, field_loc2)) == TS_ERROR_PTR) {

5836

SDK_RPRINT(test, "TSMimeHdrFieldClone", "TestCase1", TC_FAIL, "TSMimeHdrFieldClone returns TS_ERROR_PTR");

5837

} else {

5838

if ((compare_field_names(test, bufp3, mime_hdr_loc3, field_loc1, bufp1, mime_hdr_loc1, field_loc2) == TS_ERROR) ||

5839

(compare_field_values(test, bufp3, mime_hdr_loc3, field_loc1, bufp1, mime_hdr_loc1, field_loc2, true) == TS_ERROR)) {

5840

SDK_RPRINT(test, "TSMimeHdrFieldClone", "TestCase1", TC_FAIL, "Value's Mismatch");

5841

} else {

5842

SDK_RPRINT(test, "TSMimeHdrFieldClone", "TestCase1", TC_PASS, "ok");

5843

}

5844

}

5845

}

5846

if ((field_loc1 != NULL) && (field_loc1 != TS_ERROR_PTR)) {

5847

if (TSHandleMLocRelease(bufp3, mime_hdr_loc3, field_loc1) == TS_ERROR) {

5848

SDK_RPRINT(test, "TSHandleMLocRelease", "TestCase7", TC_FAIL, "TSHandleMLocRelease returns TS_ERROR");

5849

test_passed_handle_mloc_release = false;

5850

} else {

5851

SDK_RPRINT(test, "TSHandleMLocRelease", "TestCase7", TC_PASS, "ok");

5852

}

5853

}

5854

5855

if ((field_loc2 != NULL) && (field_loc2 != TS_ERROR_PTR)) {

5856

if (TSHandleMLocRelease(bufp1, mime_hdr_loc1, field_loc2) == TS_ERROR) {

5857

SDK_RPRINT(test, "TSHandleMLocRelease", "TestCase8", TC_FAIL, "TSHandleMLocRelease returns TS_ERROR");

5858

test_passed_handle_mloc_release = false;

5859

} else {

5860

SDK_RPRINT(test, "TSHandleMLocRelease", "TestCase8", TC_PASS, "ok");

5861

}

5862

}

5863

} else {

5864

SDK_RPRINT(test, "TSMimeHdrFieldClone", "TestCase1", TC_FAIL,

5865

"Unable to run test as bufp3 might not have been created");

5866

}

5867

5868

// TSMimeHdrFieldCopyValues

5869

if (test_passed_mime_hdr_copy == true) {

5870

if ((field_loc1 = TSMimeHdrFieldCreate(bufp2, mime_hdr_loc2)) == TS_ERROR_PTR) {

5871

SDK_RPRINT(test, "TSMimeHdrFieldCopyValues", "TestCase1", TC_FAIL, "Unable to create field for Copying");

5872

} else {

5873

if ((field_loc2 = TSMimeHdrFieldGet(bufp1, mime_hdr_loc1, 0)) == TS_ERROR_PTR) {

5874

SDK_RPRINT(test, "TSMimeHdrFieldCopyValues", "TestCase1", TC_FAIL, "Unable to get source field for copying");

5875

} else {

5876

if (TSMimeHdrFieldCopyValues(bufp2, mime_hdr_loc2, field_loc1, bufp1, mime_hdr_loc1, field_loc2) == TS_ERROR) {

5877

SDK_RPRINT(test, "TSMimeHdrFieldCopyValues", "TestCase1", TC_FAIL, "TSMimeHdrFieldCopy returns TS_ERROR");

5878

} else {

5879

if (compare_field_values(test, bufp2, mime_hdr_loc2, field_loc1, bufp1, mime_hdr_loc1, field_loc2, false) == TS_ERROR) {

5880

SDK_RPRINT(test, "TSMimeHdrFieldCopyValues", "TestCase1", TC_FAIL, "Value's Mismatch");

5881

} else {

5882

SDK_RPRINT(test, "TSMimeHdrFieldCopyValues", "TestCase1", TC_PASS, "ok");

5883

test_passed_mime_hdr_field_copy_values = true;

5884

}

5885

}

5886

}

5887

if (TSHandleMLocRelease(bufp2, mime_hdr_loc2, field_loc1) == TS_ERROR) {

5888

SDK_RPRINT(test, "TSHandleMLocRelease", "TestCase9", TC_FAIL, "TSHandleMLocRelease returns TS_ERROR");

5889

test_passed_handle_mloc_release = false;

5890

} else {

5891

SDK_RPRINT(test, "TSHandleMLocRelease", "TestCase9", TC_PASS, "ok");

5892

}

5893

5894

if ((field_loc2 != NULL) && (field_loc2 != TS_ERROR_PTR)) {

5895

if (TSHandleMLocRelease(bufp1, mime_hdr_loc1, field_loc2) == TS_ERROR) {

5896

SDK_RPRINT(test, "TSHandleMLocRelease", "TestCase10", TC_FAIL, "TSHandleMLocRelease returns TS_ERROR");

5897

test_passed_handle_mloc_release = false;

5898

} else {

5899

SDK_RPRINT(test, "TSHandleMLocRelease", "TestCase10", TC_PASS, "ok");

5900

}

5901

}

5902

}

5903

} else {

5904

SDK_RPRINT(test, "TSMimeHdrFieldCopy", "TestCase1", TC_FAIL,

5905

"Unable to run test as bufp2 might not have been created");

5906

}

5907

5908

if ((TSMimeHdrDestroy(bufp1, mime_hdr_loc1) == TS_ERROR) ||

5909

(TSMimeHdrDestroy(bufp2, mime_hdr_loc2) == TS_ERROR) || (TSMimeHdrDestroy(bufp3, mime_hdr_loc3) == TS_ERROR)

5910

) {

5911

SDK_RPRINT(test, "", "TestCase", TC_FAIL, "TSMimeHdrDestroy returns TS_ERROR");

5912

}

5913

5914

if ((TSHandleMLocRelease(bufp1, TS_NULL_MLOC, mime_hdr_loc1) == TS_ERROR) ||

5915

(TSHandleMLocRelease(bufp2, TS_NULL_MLOC, mime_hdr_loc2) == TS_ERROR) ||

5916

(TSHandleMLocRelease(bufp3, TS_NULL_MLOC, mime_hdr_loc3) == TS_ERROR)

5917

) {

5918

SDK_RPRINT(test, "TSHandleMLocRelease", "TestCase11|12|13", TC_FAIL, "Unable to release handle to Mime Hdrs");

5919

test_passed_handle_mloc_release = false;

5920

}

5921

5922

if ((TSMBufferDestroy(bufp1) == TS_ERROR) ||

5923

(TSMBufferDestroy(bufp2) == TS_ERROR) || (TSMBufferDestroy(bufp3) == TS_ERROR)

5924

) {

5925

SDK_RPRINT(test, "", "TestCase", TC_FAIL, "TSMBufferDestroy returns TS_ERROR");

5926

}

5927

5928

if ((test_passed_parser_create != true) ||

5929

(test_passed_parse != true) ||

5930

(test_passed_parser_clear != true) ||

5931

(test_passed_parser_destroy != true) ||

5932

(test_passed_mime_hdr_print != true) ||

5933

(test_passed_mime_hdr_length_get != true) ||

5934

(test_passed_mime_hdr_field_next_dup != true) ||

5935

(test_passed_mime_hdr_copy != true) ||

5936

(test_passed_mime_hdr_clone != true) ||

5937

(test_passed_mime_hdr_field_remove != true) ||

5938

(test_passed_mime_hdr_field_copy != true) ||

5939

(test_passed_mime_hdr_field_copy_values != true) ||

5940

(test_passed_handle_mloc_release != true) ||

5941

(test_passed_mime_hdr_field_find != true)

5942

) {

5943

*pstatus = REGRESSION_TEST_FAILED;

5944

} else {

5945

*pstatus = REGRESSION_TEST_PASSED;

5946

}

5947

5948

}

5949

5950

//////////////////////////////////////////////

5951

// SDK_API_TSUrlParse

5952

5953

// Unit Test for API: TSUrlParse

5954

//////////////////////////////////////////////

5955

5956

REGRESSION_TEST(SDK_API_TSUrlParse) (RegressionTest * test, int atype, int *pstatus)

5957

{

5958

NOWARN_UNUSED(atype);

5959

const char *url = "http://abc:def@www.example.com:3426/homepage.cgi;ab?abc=def#abc";

5960

const char *start;

5961

const char *end;

5962

char *temp;

5963

5964

int retval;

5965

5966

TSMBuffer bufp;

5967

TSMLoc url_loc = (TSMLoc) TS_ERROR_PTR;

5968

bool test_passed_parse_url = false;

5969

int length;

5970

5971

*pstatus = REGRESSION_TEST_INPROGRESS;

5972

5973

5974

bufp = TSMBufferCreate();

5975

if (bufp == TS_ERROR_PTR) {

5976

SDK_RPRINT(test, "TSUrlParse", "TestCase1", TC_FAIL, "Cannot create buffer for parsing url");

5977

} else {

5978

url_loc = TSUrlCreate(bufp);

5979

if (url_loc == TS_ERROR_PTR) {

5980

SDK_RPRINT(test, "TSUrlParse", "TestCase1", TC_FAIL, "Cannot create Url for parsing the url");

5981

if (TSMBufferDestroy(bufp) == TS_ERROR) {

5982

SDK_RPRINT(test, "TSUrlParse", "TestCase1", TC_FAIL, "Error in Destroying MBuffer");

5983

}

5984

} else {

5985

start = url;

5986

end = url + strlen(url) + 1;

5987

if ((retval = TSUrlParse(bufp, url_loc, &start, end)) == TS_PARSE_ERROR) {

5988

SDK_RPRINT(test, "TSUrlParse", "TestCase1", TC_FAIL, "TSUrlParse returns TS_PARSE_ERROR");

5989

} else {

5990

if (retval == TS_PARSE_DONE) {

5991

temp = TSUrlStringGet(bufp, url_loc, &length);

5992

if (temp == TS_ERROR_PTR) {

5993

SDK_RPRINT(test, "TSUrlParse", "TestCase1", TC_FAIL, "TSUrlStringGet returns TS_ERROR_PTR");

5994

} else {

5995

if (strncmp(url, temp, length) == 0) {

5996

SDK_RPRINT(test, "TSUrlParse", "TestCase1", TC_PASS, "ok");

5997

test_passed_parse_url = true;

5998

} else {

5999

SDK_RPRINT(test, "TSUrlParse", "TestCase1", TC_FAIL, "Value's Mismatch");

6000

}

6001

TSfree(temp);

6002

}

6003

} else {

6004

SDK_RPRINT(test, "TSHttpHdrParseReq", "TestCase1", TC_FAIL, "Parsing Error");

6005

}

6006

}

6007

}

6008

}

6009

6010

if (test_passed_parse_url != true) {

6011

*pstatus = REGRESSION_TEST_FAILED;

6012

} else {

6013

*pstatus = REGRESSION_TEST_PASSED;

6014

}

6015

6016

TSUrlDestroy(bufp, url_loc);

6017

6018

TSHandleMLocRelease(bufp, TS_NULL_MLOC, url_loc);

6019

6020

TSMBufferDestroy(bufp);

6021

6022

return;

6023

}

6024

6025

//////////////////////////////////////////////

6026

// SDK_API_TSTextLog

6027

6028

// Unit Test for APIs: TSTextLogObjectCreate

6029

// TSTextLogObjectWrite

6030

// TSTextLogObjectDestroy

6031

// TSTextLogObjectFlush

6032

//////////////////////////////////////////////

6033

#define LOG_TEST_PATTERN "SDK team rocks"

6034

6035

typedef struct

6036

{

6037

RegressionTest *test;

6038

int *pstatus;

6039

char *fullpath_logname;

6040

unsigned long magic;

6041

} LogTestData;

6042

6043

6044

static int

6045

log_test_handler(TSCont contp, TSEvent event, void *edata)

6046

{

6047

NOWARN_UNUSED(edata);

6048

TSFile filep;

6049

char buf[1024];

6050

bool str_found;

6051

6052

TSAssert(event == TS_EVENT_TIMEOUT);

6053

6054

LogTestData *data = (LogTestData *) TSContDataGet(contp);

6055

TSAssert(data->magic == MAGIC_ALIVE);

6056

6057

// Verify content was correctly written into log file

6058

6059

if ((filep = TSfopen(data->fullpath_logname, "r")) == NULL) {

6060

SDK_RPRINT(data->test, "TSTextLogObject", "TestCase1", TC_FAIL, "can not open log file %s", data->fullpath_logname);

6061

*(data->pstatus) = REGRESSION_TEST_FAILED;

6062

return -1;

6063

}

6064

6065

str_found = false;

6066

while (TSfgets(filep, buf, 1024) != NULL) {

6067

if (strstr(buf, LOG_TEST_PATTERN) != NULL) {

6068

str_found = true;

6069

break;

6070

}

6071

}

6072

TSfclose(filep);

6073

if (str_found == false) {

6074

SDK_RPRINT(data->test, "TSTextLogObject", "TestCase1", TC_FAIL, "can not find pattern %s in log file", LOG_TEST_PATTERN);

6075

*(data->pstatus) = REGRESSION_TEST_FAILED;

6076

return -1;

6077

}

6078

6079

*(data->pstatus) = REGRESSION_TEST_PASSED;

6080

6081

data->magic = MAGIC_DEAD;

6082

TSfree(data->fullpath_logname);

6083

TSfree(data);

6084

data = NULL;

6085

6086

return -1;

6087

}

6088

6089

REGRESSION_TEST(SDK_API_TSTextLog) (RegressionTest * test, int atype, int *pstatus)

6090

{

6091

NOWARN_UNUSED(atype);

6092

*pstatus = REGRESSION_TEST_INPROGRESS;

6093

6094

TSTextLogObject log;

6095

TSReturnCode retVal;

6096

6097

char logname[128];

6098

char fullpath_logname[128];

6099

6100

/* Generate a random log file name, so if we run the test several times, we won't use the

6101

same log file name. */

6102

char *tmp = REC_ConfigReadString("proxy.config.log.logfile_dir");

6103

snprintf(logname, sizeof(logname), "RegressionTestLog%d.log", (int) getpid());

6104

snprintf(fullpath_logname, sizeof(fullpath_logname), "%s/%s", tmp, logname);

6105

// xfree(tmp);

6106

6107

retVal = TSTextLogObjectCreate(logname, TS_LOG_MODE_ADD_TIMESTAMP, &log);

6108

if (retVal != TS_SUCCESS) {

6109

SDK_RPRINT(test, "TSTextLogObjectCreate", "TestCase1", TC_FAIL, "can not create log object");

6110

*pstatus = REGRESSION_TEST_FAILED;

6111

return;

6112

} else {

6113

SDK_RPRINT(test, "TSTextLogObjectCreate", "TestCase1", TC_PASS, "ok");

6114

}

6115

6116

retVal = TSTextLogObjectWrite(log, (char*)LOG_TEST_PATTERN);

6117

if (retVal != TS_SUCCESS) {

6118

SDK_RPRINT(test, "TSTextLogObjectWrite", "TestCase1", TC_FAIL, "can not write to log object");

6119

*pstatus = REGRESSION_TEST_FAILED;

6120

return;

6121

} else {

6122

SDK_RPRINT(test, "TSTextLogObjectWrite", "TestCase1", TC_PASS, "ok");

6123

}

6124

6125

retVal = TSTextLogObjectFlush(log);

6126

if (retVal != TS_SUCCESS) {

6127

SDK_RPRINT(test, "TSTextLogObjectFlush", "TestCase1", TC_FAIL, "can not flush log object");

6128

*pstatus = REGRESSION_TEST_FAILED;

6129

return;

6130

} else {

6131

SDK_RPRINT(test, "TSTextLogObjectFlush", "TestCase1", TC_PASS, "ok");

6132

}

6133

6134

retVal = TSTextLogObjectDestroy(log);

6135

if (retVal != TS_SUCCESS) {

6136

SDK_RPRINT(test, "TSTextLogObjectDestroy", "TestCase1", TC_FAIL, "can not destroy log object");

6137

*pstatus = REGRESSION_TEST_FAILED;

6138

return;

6139

} else {

6140

SDK_RPRINT(test, "TSTextLogObjectDestroy", "TestCase1", TC_PASS, "ok");

6141

}

6142

6143

6144

TSCont log_test_cont = TSContCreate(log_test_handler, TSMutexCreate());

6145

LogTestData *data = (LogTestData *) TSmalloc(sizeof(LogTestData));

6146

data->test = test;

6147

data->pstatus = pstatus;

6148

data->fullpath_logname = TSstrdup(fullpath_logname);

6149

data->magic = MAGIC_ALIVE;

6150

TSContDataSet(log_test_cont, data);

6151

6152

TSContSchedule(log_test_cont, 5000, TS_THREAD_POOL_DEFAULT);

6153

return;

6154

}

6155

6156

6157

//////////////////////////////////////////////

6158

// SDK_API_TSMgmtGet

6159

6160

// Unit Test for APIs: TSMgmtCounterGet

6161

// TSMgmtFloatGet

6162

// TSMgmtIntGet

6163

// TSMgmtStringGet

6164

//////////////////////////////////////////////

6165

6166

REGRESSION_TEST(SDK_API_TSMgmtGet) (RegressionTest * test, int atype, int *pstatus)

6167

{

6168

NOWARN_UNUSED(atype);

6169

const char *CONFIG_PARAM_COUNTER_NAME = "proxy.process.http.total_parent_proxy_connections";

6170

int CONFIG_PARAM_COUNTER_VALUE = 0;

6171

6172

const char *CONFIG_PARAM_FLOAT_NAME = "proxy.config.http.background_fill_completed_threshold";

6173

float CONFIG_PARAM_FLOAT_VALUE = 0.5;

6174

6175

const char *CONFIG_PARAM_INT_NAME = "proxy.config.http.cache.http";

6176

int CONFIG_PARAM_INT_VALUE = 1;

6177

6178

const char *CONFIG_PARAM_STRING_NAME = "proxy.config.product_name";

6179

const char *CONFIG_PARAM_STRING_VALUE = "Traffic Server";

6180

6181

*pstatus = REGRESSION_TEST_INPROGRESS;

6182

6183

int retVal;

6184

int err = 0;

6185

TSMgmtCounter cvalue = 0;

6186

TSMgmtFloat fvalue = 0.0;

6187

TSMgmtInt ivalue = -1;

6188

TSMgmtString svalue = NULL;

6189

6190

retVal = TSMgmtCounterGet(CONFIG_PARAM_COUNTER_NAME, &cvalue);

6191

if (retVal == 0) {

6192

SDK_RPRINT(test, "TSMgmtCounterGet", "TestCase1.1", TC_FAIL, "can not get value of param %s",

6193

CONFIG_PARAM_COUNTER_NAME);

6194

err = 1;

6195

} else if (cvalue != CONFIG_PARAM_COUNTER_VALUE) {

6196

SDK_RPRINT(test, "TSMgmtCounterGet", "TestCase1.1", TC_FAIL,

6197

"got incorrect value of param %s, should have been %d, found %d", CONFIG_PARAM_COUNTER_NAME,

6198

CONFIG_PARAM_COUNTER_VALUE, cvalue);

6199

err = 1;

6200

} else {

6201

SDK_RPRINT(test, "TSMgmtCounterGet", "TestCase1.1", TC_PASS, "ok");

6202

}

6203

6204

retVal = TSMgmtFloatGet(CONFIG_PARAM_FLOAT_NAME, &fvalue);

6205

if ((retVal == 0) || (fvalue != CONFIG_PARAM_FLOAT_VALUE)) {

6206

SDK_RPRINT(test, "TSMgmtFloatGet", "TestCase2", TC_FAIL, "can not get value of param %s", CONFIG_PARAM_FLOAT_NAME);

6207

err = 1;

6208

} else {

6209

SDK_RPRINT(test, "TSMgmtFloatGet", "TestCase1.2", TC_PASS, "ok");

6210

}

6211

6212

retVal = TSMgmtIntGet(CONFIG_PARAM_INT_NAME, &ivalue);

6213

if ((retVal == 0) || (ivalue != CONFIG_PARAM_INT_VALUE)) {

6214

SDK_RPRINT(test, "TSMgmtIntGet", "TestCase1.3", TC_FAIL, "can not get value of param %s", CONFIG_PARAM_INT_NAME);

6215

err = 1;

6216

} else {

6217

SDK_RPRINT(test, "TSMgmtIntGet", "TestCase1.3", TC_PASS, "ok");

6218

}

6219

6220

retVal = TSMgmtStringGet(CONFIG_PARAM_STRING_NAME, &svalue);

6221

if (retVal == 0) {

6222

SDK_RPRINT(test, "TSMgmtStringGet", "TestCase1.4", TC_FAIL, "can not get value of param %s",

6223

CONFIG_PARAM_STRING_NAME);

6224

err = 1;

6225

} else if (strcmp(svalue, CONFIG_PARAM_STRING_VALUE) != 0) {

6226

SDK_RPRINT(test, "TSMgmtStringGet", "TestCase1.4", TC_FAIL,

6227

"got incorrect value of param %s, should have been \"%s\", found \"%s\"", CONFIG_PARAM_STRING_NAME,

6228

CONFIG_PARAM_STRING_VALUE, svalue);

6229

err = 1;

6230

} else {

6231

SDK_RPRINT(test, "TSMgmtStringGet", "TestCase1.4", TC_PASS, "ok");

6232

}

6233

6234

if (err) {

6235

*pstatus = REGRESSION_TEST_FAILED;

6236

return;

6237

}

6238

6239

*pstatus = REGRESSION_TEST_PASSED;

6240

SDK_RPRINT(test, "TSMgmtGet", "TestCase1", TC_PASS, "ok");

6241

return;

6242

}

6243

6244

6245

//////////////////////////////////////////////

6246

// SDK_API_TSMgmtUpdateRegister

6247

6248

// Unit Test for APIs: TSMgmtUpdateRegister

6249

6250

// FIX ME: How to test this API automatically

6251

// as it requires a GUI action ??

6252

//////////////////////////////////////////////

6253

6254

// dummy handler. Should never get called.

6255

int

6256

gui_update_handler(TSCont contp, TSEvent event, void *edata)

6257

{

6258

NOWARN_UNUSED(contp);

6259

NOWARN_UNUSED(event);

6260

NOWARN_UNUSED(edata);

6261

TSReleaseAssert(!"gui_update_handler should not be called");

6262

return 0;

6263

}

6264

6265

REGRESSION_TEST(SDK_API_TSMgmtUpdateRegister) (RegressionTest * test, int atype, int *pstatus)

6266

{

6267

NOWARN_UNUSED(atype);

6268

*pstatus = REGRESSION_TEST_INPROGRESS;

6269

6270

TSCont mycont = TSContCreate(gui_update_handler, TSMutexCreate());

6271

6272

if (TSMgmtUpdateRegister(mycont, "myPlugin", "myPluginPath/myGui.cgi") != TS_SUCCESS) {

6273

SDK_RPRINT(test, "TSMgmtUpdateRegister", "TestCase1", TC_FAIL, "can not register plugin interface");

6274

*pstatus = REGRESSION_TEST_FAILED;

6275

} else {

6276

*pstatus = REGRESSION_TEST_PASSED;

6277

}

6278

return;

6279

}

6280

6281

6282

//////////////////////////////////////////////

6283

// SDK_API_TSConstant

6284

6285

// Unit Test for APIs: All TS_XXX constants

6286

6287

//////////////////////////////////////////////

6288

6289

#define PRINT_DIFF( _x ) \

6290

{ \

6291

if ( _x - ORIG_##_x != 0) { \

6292

test_passed = false; \

6293

SDK_RPRINT (test, "##_x", "TestCase1", TC_FAIL, \

6294

"%s:Original Value = %d; New Value = %d \n", #_x,_x, ORIG_##_x); \

6295

} \

6296

}

6297

6298

6299

typedef enum

6300

{

6301

ORIG_TS_PARSE_ERROR = -1,

6302

ORIG_TS_PARSE_DONE = 0,

6303

ORIG_TS_PARSE_OK = 1,

6304

ORIG_TS_PARSE_CONT = 2

6305

} ORIG_TSParseResult;

6306

6307

typedef enum

6308

{

6309

ORIG_TS_HTTP_TYPE_UNKNOWN,

6310

ORIG_TS_HTTP_TYPE_REQUEST,

6311

ORIG_TS_HTTP_TYPE_RESPONSE

6312

} ORIG_TSHttpType;

6313

6314

typedef enum

6315

{

6316

ORIG_TS_HTTP_STATUS_NONE = 0,

6317

6318

ORIG_TS_HTTP_STATUS_CONTINUE = 100,

6319

ORIG_TS_HTTP_STATUS_SWITCHING_PROTOCOL = 101,

6320

6321

ORIG_TS_HTTP_STATUS_OK = 200,

6322

ORIG_TS_HTTP_STATUS_CREATED = 201,

6323

ORIG_TS_HTTP_STATUS_ACCEPTED = 202,

6324

ORIG_TS_HTTP_STATUS_NON_AUTHORITATIVE_INFORMATION = 203,

6325

ORIG_TS_HTTP_STATUS_NO_CONTENT = 204,

6326

ORIG_TS_HTTP_STATUS_RESET_CONTENT = 205,

6327

ORIG_TS_HTTP_STATUS_PARTIAL_CONTENT = 206,

6328

6329

ORIG_TS_HTTP_STATUS_MULTIPLE_CHOICES = 300,

6330

ORIG_TS_HTTP_STATUS_MOVED_PERMANENTLY = 301,

6331

ORIG_TS_HTTP_STATUS_MOVED_TEMPORARILY = 302,

6332

ORIG_TS_HTTP_STATUS_SEE_OTHER = 303,

6333

ORIG_TS_HTTP_STATUS_NOT_MODIFIED = 304,

6334

ORIG_TS_HTTP_STATUS_USE_PROXY = 305,

6335

6336

ORIG_TS_HTTP_STATUS_BAD_REQUEST = 400,

6337

ORIG_TS_HTTP_STATUS_UNAUTHORIZED = 401,

6338

ORIG_TS_HTTP_STATUS_PAYMENT_REQUIRED = 402,

6339

ORIG_TS_HTTP_STATUS_FORBIDDEN = 403,

6340

ORIG_TS_HTTP_STATUS_NOT_FOUND = 404,

6341

ORIG_TS_HTTP_STATUS_METHOD_NOT_ALLOWED = 405,

6342

ORIG_TS_HTTP_STATUS_NOT_ACCEPTABLE = 406,

6343

ORIG_TS_HTTP_STATUS_PROXY_AUTHENTICATION_REQUIRED = 407,

6344

ORIG_TS_HTTP_STATUS_REQUEST_TIMEOUT = 408,

6345

ORIG_TS_HTTP_STATUS_CONFLICT = 409,

6346

ORIG_TS_HTTP_STATUS_GONE = 410,

6347

ORIG_TS_HTTP_STATUS_LENGTH_REQUIRED = 411,

6348

ORIG_TS_HTTP_STATUS_PRECONDITION_FAILED = 412,

6349

ORIG_TS_HTTP_STATUS_REQUEST_ENTITY_TOO_LARGE = 413,

6350

ORIG_TS_HTTP_STATUS_REQUEST_URI_TOO_LONG = 414,

6351

ORIG_TS_HTTP_STATUS_UNSUPPORTED_MEDIA_TYPE = 415,

6352

6353

ORIG_TS_HTTP_STATUS_INTERNAL_SERVER_ERROR = 500,

6354

ORIG_TS_HTTP_STATUS_NOT_IMPLEMENTED = 501,

6355

ORIG_TS_HTTP_STATUS_BAD_GATEWAY = 502,

6356

ORIG_TS_HTTP_STATUS_SERVICE_UNAVAILABLE = 503,

6357

ORIG_TS_HTTP_STATUS_GATEWAY_TIMEOUT = 504,

6358

ORIG_TS_HTTP_STATUS_HTTPVER_NOT_SUPPORTED = 505

6359

} ORIG_TSHttpStatus;

6360

6361

typedef enum

6362

{

6363

ORIG_TS_HTTP_READ_REQUEST_HDR_HOOK,

6364

ORIG_TS_HTTP_OS_DNS_HOOK,

6365

ORIG_TS_HTTP_SEND_REQUEST_HDR_HOOK,

6366

ORIG_TS_HTTP_READ_CACHE_HDR_HOOK,

6367

ORIG_TS_HTTP_READ_RESPONSE_HDR_HOOK,

6368

ORIG_TS_HTTP_SEND_RESPONSE_HDR_HOOK,

6369

ORIG_TS_HTTP_REQUEST_TRANSFORM_HOOK,

6370

ORIG_TS_HTTP_RESPONSE_TRANSFORM_HOOK,

6371

ORIG_TS_HTTP_SELECT_ALT_HOOK,

6372

ORIG_TS_HTTP_TXN_START_HOOK,

6373

ORIG_TS_HTTP_TXN_CLOSE_HOOK,

6374

ORIG_TS_HTTP_SSN_START_HOOK,

6375

ORIG_TS_HTTP_SSN_CLOSE_HOOK,

6376

ORIG_TS_HTTP_CACHE_LOOKUP_COMPLETE_HOOK,

6377

ORIG_TS_HTTP_PRE_REMAP_HOOK,

6378

ORIG_TS_HTTP_POST_REMAP_HOOK,

6379

ORIG_TS_HTTP_LAST_HOOK

6380

} ORIG_TSHttpHookID;

6381

6382

typedef enum

6383

{

6384

ORIG_TS_EVENT_NONE = 0,

6385

ORIG_TS_EVENT_IMMEDIATE = 1,

6386

ORIG_TS_EVENT_TIMEOUT = 2,

6387

ORIG_TS_EVENT_ERROR = 3,

6388

ORIG_TS_EVENT_CONTINUE = 4,

6389

6390

ORIG_TS_EVENT_VCONN_READ_READY = 100,

6391

ORIG_TS_EVENT_VCONN_WRITE_READY = 101,

6392

ORIG_TS_EVENT_VCONN_READ_COMPLETE = 102,

6393

ORIG_TS_EVENT_VCONN_WRITE_COMPLETE = 103,

6394

ORIG_TS_EVENT_VCONN_EOS = 104,

6395

6396

ORIG_TS_EVENT_NET_CONNECT = 200,

6397

ORIG_TS_EVENT_NET_CONNECT_FAILED = 201,

6398

ORIG_TS_EVENT_NET_ACCEPT = 202,

6399

ORIG_TS_EVENT_NET_ACCEPT_FAILED = 204,

6400

6401

ORIG_TS_EVENT_HOST_LOOKUP = 500,

6402

6403

ORIG_TS_EVENT_CACHE_OPEN_READ = 1102,

6404

ORIG_TS_EVENT_CACHE_OPEN_READ_FAILED = 1103,

6405

ORIG_TS_EVENT_CACHE_OPEN_WRITE = 1108,

6406

ORIG_TS_EVENT_CACHE_OPEN_WRITE_FAILED = 1109,

6407

ORIG_TS_EVENT_CACHE_REMOVE = 1112,

6408

ORIG_TS_EVENT_CACHE_REMOVE_FAILED = 1113,

6409

ORIG_TS_EVENT_CACHE_SCAN = 1120,

6410

ORIG_TS_EVENT_CACHE_SCAN_FAILED = 1121,

6411

ORIG_TS_EVENT_CACHE_SCAN_OBJECT = 1122,

6412

ORIG_TS_EVENT_CACHE_SCAN_OPERATION_BLOCKED = 1123,

6413

ORIG_TS_EVENT_CACHE_SCAN_OPERATION_FAILED = 1124,

6414

ORIG_TS_EVENT_CACHE_SCAN_DONE = 1125,

6415

6416

ORIG_TS_EVENT_HTTP_CONTINUE = 60000,

6417

ORIG_TS_EVENT_HTTP_ERROR = 60001,

6418

ORIG_TS_EVENT_HTTP_READ_REQUEST_HDR = 60002,

6419

ORIG_TS_EVENT_HTTP_OS_DNS = 60003,

6420

ORIG_TS_EVENT_HTTP_SEND_REQUEST_HDR = 60004,

6421

ORIG_TS_EVENT_HTTP_READ_CACHE_HDR = 60005,

6422

ORIG_TS_EVENT_HTTP_READ_RESPONSE_HDR = 60006,

6423

ORIG_TS_EVENT_HTTP_SEND_RESPONSE_HDR = 60007,

6424

ORIG_TS_EVENT_HTTP_REQUEST_TRANSFORM = 60008,

6425

ORIG_TS_EVENT_HTTP_RESPONSE_TRANSFORM = 60009,

6426

ORIG_TS_EVENT_HTTP_SELECT_ALT = 60010,

6427

ORIG_TS_EVENT_HTTP_TXN_START = 60011,

6428

ORIG_TS_EVENT_HTTP_TXN_CLOSE = 60012,

6429

ORIG_TS_EVENT_HTTP_SSN_START = 60013,

6430

ORIG_TS_EVENT_HTTP_SSN_CLOSE = 60014,

6431

ORIG_TS_EVENT_HTTP_CACHE_LOOKUP_COMPLETE = 60015,

6432

6433

ORIG_TS_EVENT_MGMT_UPDATE = 60100

6434

} ORIG_TSEvent;

6435

6436

typedef enum

6437

{

6438

ORIG_TS_CACHE_LOOKUP_MISS,

6439

ORIG_TS_CACHE_LOOKUP_HIT_STALE,

6440

ORIG_TS_CACHE_LOOKUP_HIT_FRESH

6441

} ORIG_TSCacheLookupResult;

6442

6443

typedef enum

6444

{

6445

ORIG_TS_CACHE_DATA_TYPE_NONE,

6446

ORIG_TS_CACHE_DATA_TYPE_HTTP,

6447

ORIG_TS_CACHE_DATA_TYPE_OTHER

6448

} ORIG_TSCacheDataType;

6449

6450

typedef enum

6451

{

6452

ORIG_TS_CACHE_ERROR_NO_DOC = -20400,

6453

ORIG_TS_CACHE_ERROR_DOC_BUSY = -20401,

6454

ORIG_TS_CACHE_ERROR_NOT_READY = -20407

6455

} ORIG_TSCacheError;

6456

6457

typedef enum

6458

{

6459

ORIG_TS_CACHE_SCAN_RESULT_DONE = 0,

6460

ORIG_TS_CACHE_SCAN_RESULT_CONTINUE = 1,

6461

ORIG_TS_CACHE_SCAN_RESULT_DELETE = 10,

6462

ORIG_TS_CACHE_SCAN_RESULT_DELETE_ALL_ALTERNATES,

6463

ORIG_TS_CACHE_SCAN_RESULT_UPDATE,

6464

ORIG_TS_CACHE_SCAN_RESULT_RETRY

6465

} ORIG_TSCacheScanResult;

6466

6467

typedef enum

6468

{

6469

ORIG_TS_DATA_ALLOCATE,

6470

ORIG_TS_DATA_MALLOCED,

6471

ORIG_TS_DATA_CONSTANT

6472

} ORIG_TSIOBufferDataFlags;

6473

6474

typedef enum

6475

{

6476

ORIG_TS_VC_CLOSE_ABORT = -1,

6477

ORIG_TS_VC_CLOSE_NORMAL = 1

6478

} ORIG_TSVConnCloseFlags;

6479

6480

typedef enum

6481

{

6482

ORIG_TS_SDK_VERSION_2_0 = 0,

6483

ORIG_TS_SDK_VERSION_3_0

6484

} ORIG_TSSDKVersion;

6485

6486

typedef enum

6487

{

6488

ORIG_TS_ERROR = -1,

6489

ORIG_TS_SUCCESS = 0

6490

} ORIG_TSReturnCode;

6491

6492

6493

REGRESSION_TEST(SDK_API_TSConstant) (RegressionTest * test, int atype, int *pstatus)

6494

{

6495

NOWARN_UNUSED(atype);

6496

*pstatus = REGRESSION_TEST_INPROGRESS;

6497

bool test_passed = true;

6498

6499

PRINT_DIFF(TS_PARSE_ERROR);

6500

PRINT_DIFF(TS_PARSE_DONE);

6501

PRINT_DIFF(TS_PARSE_OK);

6502

PRINT_DIFF(TS_PARSE_CONT);

6503

6504

PRINT_DIFF(TS_HTTP_STATUS_NONE);

6505

PRINT_DIFF(TS_HTTP_STATUS_CONTINUE);

6506

PRINT_DIFF(TS_HTTP_STATUS_SWITCHING_PROTOCOL);

6507

PRINT_DIFF(TS_HTTP_STATUS_OK);

6508

PRINT_DIFF(TS_HTTP_STATUS_CREATED);

6509

6510

6511

PRINT_DIFF(TS_HTTP_STATUS_ACCEPTED);

6512

PRINT_DIFF(TS_HTTP_STATUS_NON_AUTHORITATIVE_INFORMATION);

6513

PRINT_DIFF(TS_HTTP_STATUS_NO_CONTENT);

6514

PRINT_DIFF(TS_HTTP_STATUS_RESET_CONTENT);

6515

PRINT_DIFF(TS_HTTP_STATUS_PARTIAL_CONTENT);

6516

6517

PRINT_DIFF(TS_HTTP_STATUS_MULTIPLE_CHOICES);

6518

PRINT_DIFF(TS_HTTP_STATUS_MOVED_PERMANENTLY);

6519

PRINT_DIFF(TS_HTTP_STATUS_MOVED_TEMPORARILY);

6520

PRINT_DIFF(TS_HTTP_STATUS_SEE_OTHER);

6521

PRINT_DIFF(TS_HTTP_STATUS_NOT_MODIFIED);

6522

PRINT_DIFF(TS_HTTP_STATUS_USE_PROXY);

6523

PRINT_DIFF(TS_HTTP_STATUS_BAD_REQUEST);

6524

PRINT_DIFF(TS_HTTP_STATUS_UNAUTHORIZED);

6525

PRINT_DIFF(TS_HTTP_STATUS_FORBIDDEN);

6526

PRINT_DIFF(TS_HTTP_STATUS_NOT_FOUND);

6527

PRINT_DIFF(TS_HTTP_STATUS_METHOD_NOT_ALLOWED);

6528

PRINT_DIFF(TS_HTTP_STATUS_NOT_ACCEPTABLE);

6529

PRINT_DIFF(TS_HTTP_STATUS_PROXY_AUTHENTICATION_REQUIRED);

6530

PRINT_DIFF(TS_HTTP_STATUS_REQUEST_TIMEOUT);

6531

PRINT_DIFF(TS_HTTP_STATUS_CONFLICT);

6532

PRINT_DIFF(TS_HTTP_STATUS_GONE);

6533

PRINT_DIFF(TS_HTTP_STATUS_PRECONDITION_FAILED);

6534

PRINT_DIFF(TS_HTTP_STATUS_REQUEST_ENTITY_TOO_LARGE);

6535

PRINT_DIFF(TS_HTTP_STATUS_REQUEST_URI_TOO_LONG);

6536

PRINT_DIFF(TS_HTTP_STATUS_UNSUPPORTED_MEDIA_TYPE);

6537

PRINT_DIFF(TS_HTTP_STATUS_INTERNAL_SERVER_ERROR);

6538

PRINT_DIFF(TS_HTTP_STATUS_NOT_IMPLEMENTED);

6539

PRINT_DIFF(TS_HTTP_STATUS_BAD_GATEWAY);

6540

PRINT_DIFF(TS_HTTP_STATUS_GATEWAY_TIMEOUT);

6541

PRINT_DIFF(TS_HTTP_STATUS_HTTPVER_NOT_SUPPORTED);

6542

6543

PRINT_DIFF(TS_HTTP_READ_REQUEST_HDR_HOOK);

6544

PRINT_DIFF(TS_HTTP_OS_DNS_HOOK);

6545

PRINT_DIFF(TS_HTTP_SEND_REQUEST_HDR_HOOK);

6546

PRINT_DIFF(TS_HTTP_READ_RESPONSE_HDR_HOOK);

6547

PRINT_DIFF(TS_HTTP_SEND_RESPONSE_HDR_HOOK);

6548

PRINT_DIFF(TS_HTTP_REQUEST_TRANSFORM_HOOK);

6549

PRINT_DIFF(TS_HTTP_RESPONSE_TRANSFORM_HOOK);

6550

PRINT_DIFF(TS_HTTP_SELECT_ALT_HOOK);

6551

PRINT_DIFF(TS_HTTP_TXN_START_HOOK);

6552

PRINT_DIFF(TS_HTTP_TXN_CLOSE_HOOK);

6553

PRINT_DIFF(TS_HTTP_SSN_START_HOOK);

6554

PRINT_DIFF(TS_HTTP_SSN_CLOSE_HOOK);

6555

PRINT_DIFF(TS_HTTP_CACHE_LOOKUP_COMPLETE_HOOK);

6556

PRINT_DIFF(TS_HTTP_LAST_HOOK);

6557

6558

PRINT_DIFF(TS_EVENT_NONE);

6559

PRINT_DIFF(TS_EVENT_IMMEDIATE);

6560

PRINT_DIFF(TS_EVENT_TIMEOUT);

6561

PRINT_DIFF(TS_EVENT_ERROR);

6562

6563

PRINT_DIFF(TS_EVENT_CONTINUE);

6564

PRINT_DIFF(TS_EVENT_VCONN_READ_READY);

6565

PRINT_DIFF(TS_EVENT_VCONN_WRITE_READY);

6566

PRINT_DIFF(TS_EVENT_VCONN_READ_COMPLETE);

6567

PRINT_DIFF(TS_EVENT_VCONN_WRITE_COMPLETE);

6568

PRINT_DIFF(TS_EVENT_VCONN_EOS);

6569

6570

PRINT_DIFF(TS_EVENT_NET_CONNECT);

6571

PRINT_DIFF(TS_EVENT_NET_CONNECT_FAILED);

6572

PRINT_DIFF(TS_EVENT_NET_ACCEPT);

6573

PRINT_DIFF(TS_EVENT_NET_ACCEPT_FAILED);

6574

6575

PRINT_DIFF(TS_EVENT_HOST_LOOKUP);

6576

6577

PRINT_DIFF(TS_EVENT_CACHE_OPEN_READ);

6578

PRINT_DIFF(TS_EVENT_CACHE_OPEN_READ_FAILED);

6579

PRINT_DIFF(TS_EVENT_CACHE_OPEN_WRITE);

6580

PRINT_DIFF(TS_EVENT_CACHE_OPEN_WRITE_FAILED);

6581

PRINT_DIFF(TS_EVENT_CACHE_REMOVE);

6582

PRINT_DIFF(TS_EVENT_CACHE_REMOVE_FAILED);

6583

PRINT_DIFF(TS_EVENT_CACHE_SCAN);

6584

PRINT_DIFF(TS_EVENT_CACHE_SCAN_FAILED);

6585

PRINT_DIFF(TS_EVENT_CACHE_SCAN_OBJECT);

6586

PRINT_DIFF(TS_EVENT_CACHE_SCAN_OPERATION_BLOCKED);

6587

PRINT_DIFF(TS_EVENT_CACHE_SCAN_OPERATION_FAILED);

6588

PRINT_DIFF(TS_EVENT_CACHE_SCAN_DONE);

6589

6590

PRINT_DIFF(TS_EVENT_HTTP_CONTINUE);

6591

PRINT_DIFF(TS_EVENT_HTTP_ERROR);

6592

PRINT_DIFF(TS_EVENT_HTTP_READ_REQUEST_HDR);

6593

PRINT_DIFF(TS_EVENT_HTTP_OS_DNS);

6594

PRINT_DIFF(TS_EVENT_HTTP_SEND_REQUEST_HDR);

6595

PRINT_DIFF(TS_EVENT_HTTP_READ_CACHE_HDR);

6596

PRINT_DIFF(TS_EVENT_HTTP_READ_RESPONSE_HDR);

6597

PRINT_DIFF(TS_EVENT_HTTP_SEND_RESPONSE_HDR);

6598

PRINT_DIFF(TS_EVENT_HTTP_REQUEST_TRANSFORM);

6599

PRINT_DIFF(TS_EVENT_HTTP_RESPONSE_TRANSFORM);

6600

PRINT_DIFF(TS_EVENT_HTTP_SELECT_ALT);

6601

PRINT_DIFF(TS_EVENT_HTTP_TXN_START);

6602

PRINT_DIFF(TS_EVENT_HTTP_TXN_CLOSE);

6603

PRINT_DIFF(TS_EVENT_HTTP_SSN_START);

6604

PRINT_DIFF(TS_EVENT_HTTP_SSN_CLOSE);

6605

PRINT_DIFF(TS_EVENT_HTTP_CACHE_LOOKUP_COMPLETE);

6606

6607

PRINT_DIFF(TS_EVENT_MGMT_UPDATE);

6608

6609

PRINT_DIFF(TS_CACHE_LOOKUP_MISS);

6610

PRINT_DIFF(TS_CACHE_LOOKUP_HIT_STALE);

6611

PRINT_DIFF(TS_CACHE_LOOKUP_HIT_FRESH);

6612

6613

PRINT_DIFF(TS_CACHE_DATA_TYPE_NONE);

6614

PRINT_DIFF(TS_CACHE_DATA_TYPE_HTTP);

6615

PRINT_DIFF(TS_CACHE_DATA_TYPE_OTHER);

6616

6617

PRINT_DIFF(TS_CACHE_ERROR_NO_DOC);

6618

PRINT_DIFF(TS_CACHE_ERROR_DOC_BUSY);

6619

PRINT_DIFF(TS_CACHE_ERROR_NOT_READY);

6620

6621

PRINT_DIFF(TS_CACHE_SCAN_RESULT_DONE);

6622

PRINT_DIFF(TS_CACHE_SCAN_RESULT_CONTINUE);

6623

PRINT_DIFF(TS_CACHE_SCAN_RESULT_DELETE);

6624

PRINT_DIFF(TS_CACHE_SCAN_RESULT_DELETE_ALL_ALTERNATES);

6625

PRINT_DIFF(TS_CACHE_SCAN_RESULT_UPDATE);

6626

PRINT_DIFF(TS_CACHE_SCAN_RESULT_RETRY);

6627

6628

PRINT_DIFF(TS_DATA_ALLOCATE);

6629

PRINT_DIFF(TS_DATA_MALLOCED);

6630

PRINT_DIFF(TS_DATA_CONSTANT);

6631

6632

PRINT_DIFF(TS_VC_CLOSE_ABORT);

6633

PRINT_DIFF(TS_VC_CLOSE_NORMAL);

6634

6635

PRINT_DIFF(TS_SDK_VERSION_2_0);

6636

PRINT_DIFF(TS_SDK_VERSION_3_0);

6637

6638

PRINT_DIFF(TS_ERROR);

6639

PRINT_DIFF(TS_SUCCESS);

6640

6641

6642

if (test_passed) {

6643

*pstatus = REGRESSION_TEST_PASSED;

6644

} else {

6645

*pstatus = REGRESSION_TEST_FAILED;

6646

}

6647

6648

}

6649

6650

//////////////////////////////////////////////

6651

// SDK_API_TSHttpSsn

6652

6653

// Unit Test for API: TSHttpSsnHookAdd

6654

// TSHttpSsnReenable

6655

// TSHttpTxnHookAdd

6656

// TSHttpTxnErrorBodySet

6657

// TSHttpTxnParentProxyGet

6658

// TSHttpTxnParentProxySet

6659

//////////////////////////////////////////////

6660

6661

6662

typedef struct

6663

{

6664

RegressionTest *test;

6665

int *pstatus;

6666

SocketServer *os;

6667

ClientTxn *browser;

6668

TSHttpSsn ssnp;

6669

int test_passed_ssn_hook_add;

6670

int test_passed_ssn_reenable;

6671

int test_passed_txn_ssn_get;

6672

int test_passed_txn_hook_add;

6673

int test_passed_txn_error_body_set;

6674

bool test_passed_Parent_Proxy;

6675

int magic;

6676

} ContData;

6677

6678

static int

6679

checkHttpTxnParentProxy(ContData * data, TSHttpTxn txnp)

6680

{

6681

6682

const char *hostname = "txnpp.example.com";

6683

int port = 10180;

6684

char *hostnameget = NULL;

6685

int portget = 0;

6686

6687

if (TSHttpTxnParentProxySet(txnp, (char*)hostname, port) != TS_SUCCESS) {

6688

SDK_RPRINT(data->test, "TSHttpTxnParentProxySet", "TestCase1", TC_FAIL,

6689

"TSHttpTxnParentProxySet doesn't return TS_SUCCESS");

6690

SDK_RPRINT(data->test, "TSHttpTxnParentProxyGet", "TestCase1", TC_FAIL,

6691

"TSHttpTxnParentProxySet doesn't return TS_SUCCESS");

6692

return TS_EVENT_CONTINUE;

6693

}

6694

6695

if (TSHttpTxnParentProxyGet(txnp, &hostnameget, &portget) != TS_SUCCESS) {

6696

SDK_RPRINT(data->test, "TSHttpTxnParentProxySet", "TestCase1", TC_FAIL,

6697

"TSHttpTxnParentProxyGet doesn't return TS_SUCCESS");

6698

SDK_RPRINT(data->test, "TSHttpTxnParentProxyGet", "TestCase1", TC_FAIL,

6699

"TSHttpTxnParentProxyGet doesn't return TS_SUCCESS");

6700

return TS_EVENT_CONTINUE;

6701

}

6702

6703

if ((strcmp(hostname, hostnameget) == 0) && (port == portget)) {

6704

SDK_RPRINT(data->test, "TSHttpTxnParentProxySet", "TestCase1", TC_PASS, "ok");

6705

SDK_RPRINT(data->test, "TSHttpTxnParentProxyGet", "TestCase1", TC_PASS, "ok");

6706

data->test_passed_Parent_Proxy = true;

6707

} else {

6708

SDK_RPRINT(data->test, "TSHttpTxnParentProxySet", "TestCase1", TC_FAIL, "Value's Mismatch");

6709

SDK_RPRINT(data->test, "TSHttpTxnParentProxyGet", "TestCase1", TC_FAIL, "Value's Mismatch");

6710

}

6711

6712

return TS_EVENT_CONTINUE;

6713

}

6714

6715

6716

static int

6717

ssn_handler(TSCont contp, TSEvent event, void *edata)

6718

{

6719

6720

TSHttpTxn txnp = NULL;

6721

ContData *data = NULL;

6722

data = (ContData *) TSContDataGet(contp);

6723

if ((data == TS_ERROR_PTR) || (data == NULL)) {

6724

switch (event) {

6725

case TS_EVENT_HTTP_SSN_START:

6726

TSHttpSsnReenable((TSHttpSsn) edata, TS_EVENT_HTTP_CONTINUE);

6727

break;

6728

case TS_EVENT_IMMEDIATE:

6729

case TS_EVENT_TIMEOUT:

6730

break;

6731

case TS_EVENT_HTTP_TXN_START:

6732

default:

6733

TSHttpTxnReenable((TSHttpTxn) edata, TS_EVENT_HTTP_CONTINUE);

6734

break;

6735

}

6736

return 0;

6737

}

6738

6739

switch (event) {

6740

case TS_EVENT_HTTP_SSN_START:

6741

data->ssnp = (TSHttpSsn) edata;

6742

if (TSHttpSsnHookAdd(data->ssnp, TS_HTTP_TXN_START_HOOK, contp) != TS_SUCCESS) {

6743

SDK_RPRINT(data->test, "TSHttpSsnHookAdd", "TestCase1", TC_FAIL, "TSHttpSsnHookAdd doesn't return TS_SUCCESS");

6744

data->test_passed_ssn_hook_add--;

6745

}

6746

if (TSHttpSsnReenable(data->ssnp, TS_EVENT_HTTP_CONTINUE) != TS_SUCCESS) {

6747

SDK_RPRINT(data->test, "TSHttpSsnReenable", "TestCase1", TC_FAIL,

6748

"TSHttpSsnReenable doesn't return TS_SUCCESS");

6749

data->test_passed_ssn_reenable--;

6750

}

6751

break;

6752

6753

case TS_EVENT_HTTP_TXN_START:

6754

TSSkipRemappingSet((TSHttpTxn) edata,1);

6755

SDK_RPRINT(data->test, "TSHttpSsnReenable", "TestCase", TC_PASS, "ok");

6756

data->test_passed_ssn_reenable++;

6757

{

6758

txnp = (TSHttpTxn) edata;

6759

TSHttpSsn ssnp = TSHttpTxnSsnGet(txnp);

6760

if (ssnp != data->ssnp) {

6761

SDK_RPRINT(data->test, "TSHttpSsnHookAdd", "TestCase", TC_FAIL, "Value's mismatch");

6762

data->test_passed_ssn_hook_add--;

6763

SDK_RPRINT(data->test, "TSHttpTxnSsnGet", "TestCase", TC_FAIL, "Session doesn't match");

6764

data->test_passed_txn_ssn_get--;

6765

} else {

6766

SDK_RPRINT(data->test, "TSHttpSsnHookAdd", "TestCase1", TC_PASS, "ok");

6767

data->test_passed_ssn_hook_add++;

6768

SDK_RPRINT(data->test, "TSHttpTxnSsnGet", "TestCase1", TC_PASS, "ok");

6769

data->test_passed_txn_ssn_get++;

6770

}

6771

if (TSHttpTxnHookAdd(txnp, TS_HTTP_OS_DNS_HOOK, contp) != TS_SUCCESS) {

6772

SDK_RPRINT(data->test, "TSHttpTxnHookAdd", "TestCase1", TC_FAIL,

6773

"TSHttpTxnHookAdd doesn't return TS_SUCCESS");

6774

data->test_passed_txn_hook_add--;

6775

}

6776

if (TSHttpTxnReenable(txnp, TS_EVENT_HTTP_CONTINUE) != TS_SUCCESS) {

6777

SDK_RPRINT(data->test, "TSHttpSsn", "TestCase1", TC_FAIL, "TSHttpTxnReenable doesn't return TS_SUCCESS");

6778

}

6779

}

6780

break;

6781

6782

case TS_EVENT_HTTP_OS_DNS:

6783

SDK_RPRINT(data->test, "TSHttpTxnHookAdd", "TestCase1", TC_PASS, "ok");

6784

data->test_passed_txn_hook_add++;

6785

txnp = (TSHttpTxn) edata;

6786

6787

if (TSHttpTxnHookAdd(txnp, TS_HTTP_SEND_RESPONSE_HDR_HOOK, contp) != TS_SUCCESS) {

6788

SDK_RPRINT(data->test, "TSHttpTxnHookAdd", "TestCase1", TC_FAIL, "TSHttpTxnHookAdd doesn't return TS_SUCCESS");

6789

data->test_passed_txn_hook_add--;

6790

}

6791

6792

checkHttpTxnParentProxy(data, txnp);

6793

6794

if (TSHttpTxnReenable(txnp, TS_EVENT_HTTP_ERROR) != TS_SUCCESS) {

6795

SDK_RPRINT(data->test, "TSHttpSsn", "TestCase1", TC_FAIL, "TSHttpTxnReenable doesn't return TS_SUCCESS");

6796

}

6797

break;

6798

6799

case TS_EVENT_HTTP_SEND_RESPONSE_HDR:

6800

SDK_RPRINT(data->test, "TSHttpTxnHookAdd", "TestCase2", TC_PASS, "ok");

6801

data->test_passed_txn_hook_add++;

6802

txnp = (TSHttpTxn) edata;

6803

if (1) {

6804

char *temp = TSstrdup(ERROR_BODY);

6805

if (TSHttpTxnErrorBodySet(txnp, temp, strlen(temp), NULL) != TS_SUCCESS) {

6806

SDK_RPRINT(data->test, "TSHttpTxnErrorBodySet", "TestCase1", TC_FAIL,

6807

"TSHttpTxnErrorBodySet doesn't return TS_SUCCESS");

6808

data->test_passed_txn_error_body_set--;

6809

}

6810

}

6811

if (TSHttpTxnReenable(txnp, TS_EVENT_HTTP_CONTINUE) != TS_SUCCESS) {

6812

SDK_RPRINT(data->test, "TSHttpSsn", "TestCase1", TC_FAIL, "TSHttpTxnReenable doesn't return TS_SUCCESS");

6813

}

6814

break;

6815

6816

case TS_EVENT_IMMEDIATE:

6817

case TS_EVENT_TIMEOUT:

6818

/* Browser still waiting the response ? */

6819

if (data->browser->status == REQUEST_INPROGRESS) {

6820

TSContSchedule(contp, 25, TS_THREAD_POOL_DEFAULT);

6821

}

6822

/* Browser got the response. test is over. clean up */

6823

else {

6824

/* Check if browser response body is the one we expected */

6825

char *temp = data->browser->response;

6826

temp = strstr(temp, "\r\n\r\n");

6827

if (temp != NULL) {

6828

temp += strlen("\r\n\r\n");

6829

if ((temp[0] == '\0') || (strncmp(temp, "\r\n\r\n", 4) == 0)) {

6830

SDK_RPRINT(data->test, "TSHttpTxnErrorBodySet", "TestCase1", TC_FAIL, "No Error Body found");

6831

data->test_passed_txn_error_body_set--;

6832

}

6833

if (strncmp(temp, ERROR_BODY, strlen(ERROR_BODY)) == 0) {

6834

SDK_RPRINT(data->test, "TSHttpTxnErrorBodySet", "TestCase1", TC_PASS, "ok");

6835

data->test_passed_txn_error_body_set++;

6836

}

6837

} else {

6838

SDK_RPRINT(data->test, "TSHttpTxnErrorBodySet", "TestCase1", TC_FAIL,

6839

"strstr returns NULL. Didn't find end of headers.");

6840

data->test_passed_txn_error_body_set--;

6841

}

6842

6843

/* Note: response is available using test->browser->response pointer */

6844

if ((data->browser->status == REQUEST_SUCCESS) &&

6845

(data->test_passed_ssn_hook_add == 1) &&

6846

(data->test_passed_ssn_reenable == 1) &&

6847

(data->test_passed_txn_ssn_get == 1) &&

6848

(data->test_passed_txn_hook_add == 2) && (data->test_passed_txn_error_body_set == 1)

6849

&& (data->test_passed_Parent_Proxy == true)

6850

) {

6851

*(data->pstatus) = REGRESSION_TEST_PASSED;

6852

} else {

6853

*(data->pstatus) = REGRESSION_TEST_FAILED;

6854

}

6855

6856

// transaction is over. clean up.

6857

synclient_txn_delete(data->browser);

6858

/* Don't need it as didn't initialize the server

6859

synserver_delete(data->os);

6860

6861

data->magic = MAGIC_DEAD;

6862

TSfree(data);

6863

TSContDataSet(contp, NULL);

6864

}

6865

break;

6866

6867

default:

6868

*(data->pstatus) = REGRESSION_TEST_FAILED;

6869

SDK_RPRINT(data->test, "TSHttpSsn", "TestCase1", TC_FAIL, "Unexpected event %d", event);

6870

break;

6871

}

6872

return 0;

6873

}

6874

6875

6876

EXCLUSIVE_REGRESSION_TEST(SDK_API_HttpSsn) (RegressionTest * test, int atype, int *pstatus)

6877

{

6878

NOWARN_UNUSED(atype);

6879

*pstatus = REGRESSION_TEST_INPROGRESS;

6880

6881

TSCont cont = TSContCreate(ssn_handler, TSMutexCreate());

6882

if ((cont == NULL) || (cont == TS_ERROR_PTR)) {

6883

SDK_RPRINT(test, "TSHttpSsn", "TestCase1", TC_FAIL, "Unable to create Continuation.");

6884

*pstatus = REGRESSION_TEST_FAILED;

6885

return;

6886

}

6887

6888

ContData *socktest = (ContData *) TSmalloc(sizeof(ContData));

6889

socktest->test = test;

6890

socktest->pstatus = pstatus;

6891

socktest->test_passed_ssn_hook_add = 0;

6892

socktest->test_passed_ssn_reenable = 0;

6893

socktest->test_passed_txn_ssn_get = 0;

6894

socktest->test_passed_txn_hook_add = 0;

6895

socktest->test_passed_txn_error_body_set = 0;

6896

socktest->test_passed_Parent_Proxy = false;

6897

socktest->magic = MAGIC_ALIVE;

6898

TSContDataSet(cont, socktest);

6899

6900

/* Register to HTTP hooks that are called in case of a cache MISS */

6901

TSHttpHookAdd(TS_HTTP_SSN_START_HOOK, cont);

6902

6903

/* Create a client transaction */

6904

socktest->browser = synclient_txn_create();

6905

char *request = generate_request(3); // response is expected to be error case

6906

synclient_txn_send_request(socktest->browser, request);

6907

TSfree(request);

6908

6909

/* Wait until transaction is done */

6910

if (socktest->browser->status == REQUEST_INPROGRESS) {

6911

TSContSchedule(cont, 25, TS_THREAD_POOL_DEFAULT);

6912

}

6913

6914

return;

6915

}

6916

6917

/////////////////////////////////////////////////////

6918

// SDK_API_TSHttpTxnCache

6919

6920

// Unit Test for API: TSHttpTxnCachedReqGet

6921

// TSHttpTxnCachedRespGet

6922

// TSHttpTxnCacheLookupStatusGet

6923

/////////////////////////////////////////////////////

6924

6925

typedef struct

6926

{

6927

RegressionTest *test;

6928

int *pstatus;

6929

SocketServer *os;

6930

ClientTxn *browser1;

6931

ClientTxn *browser2;

6932

char *request;

6933

bool test_passed_txn_cached_req_get;

6934

bool test_passed_txn_cached_resp_get;

6935

bool test_passed_txn_cache_lookup_status;

6936

bool first_time;

6937

int magic;

6938

} CacheTestData;

6939

6940

static int

6941

cache_hook_handler(TSCont contp, TSEvent event, void *edata)

6942

{

6943

6944

TSHttpTxn txnp = NULL;

6945

CacheTestData *data = NULL;

6946

data = (CacheTestData *) TSContDataGet(contp);

6947

if ((data == TS_ERROR_PTR) || (data == NULL)) {

6948

switch (event) {

6949

case TS_EVENT_IMMEDIATE:

6950

case TS_EVENT_TIMEOUT:

6951

break;

6952

case TS_EVENT_HTTP_READ_CACHE_HDR:

6953

default:

6954

TSHttpTxnReenable((TSHttpTxn) edata, TS_EVENT_HTTP_CONTINUE);

6955

break;

6956

}

6957

return 0;

6958

}

6959

6960

switch (event) {

6961

case TS_EVENT_HTTP_READ_REQUEST_HDR:

6962

txnp = (TSHttpTxn) edata;

6963

TSSkipRemappingSet(txnp,1);

6964

TSHttpTxnReenable(txnp, TS_EVENT_HTTP_CONTINUE);

6965

break;

6966

6967

6968

case TS_EVENT_HTTP_CACHE_LOOKUP_COMPLETE:

6969

{

6970

int lookup_status;

6971

if (data->first_time == true) {

6972

txnp = (TSHttpTxn) edata;

6973

if (TSHttpTxnCacheLookupStatusGet(txnp, &lookup_status) != TS_SUCCESS) {

6974

SDK_RPRINT(data->test, "TSHttpTxnCacheLookupStatusGet", "TestCase1", TC_FAIL,

6975

"TSHttpTxnCacheLookupStatus doesn't return TS_SUCCESS");

6976

} else {

6977

if (lookup_status == TS_CACHE_LOOKUP_MISS) {

6978

SDK_RPRINT(data->test, "TSHttpTxnCacheLookupStatusGet", "TestCase1", TC_PASS, "ok");

6979

data->test_passed_txn_cache_lookup_status = true;

6980

} else {

6981

SDK_RPRINT(data->test, "TSHttpTxnCacheLookupStatusGet", "TestCase1", TC_FAIL,

6982

"Incorrect Value returned by TSHttpTxnCacheLookupStatusGet");

6983

}

6984

}

6985

} else {

6986

txnp = (TSHttpTxn) edata;

6987

if (TSHttpTxnCacheLookupStatusGet(txnp, &lookup_status) != TS_SUCCESS) {

6988

SDK_RPRINT(data->test, "TSHttpTxnCacheLookupStatusGet", "TestCase2", TC_FAIL,

6989

"TSHttpTxnCacheLookupStatus doesn't return TS_SUCCESS");

6990

data->test_passed_txn_cache_lookup_status = false;

6991

} else {

6992

if (lookup_status == TS_CACHE_LOOKUP_HIT_FRESH) {

6993

SDK_RPRINT(data->test, "TSHttpTxnCacheLookupStatusGet", "TestCase2", TC_PASS, "ok");

6994

} else {

6995

SDK_RPRINT(data->test, "TSHttpTxnCacheLookupStatusGet", "TestCase2", TC_FAIL,

6996

"Incorrect Value returned by TSHttpTxnCacheLookupStatusGet");

6997

data->test_passed_txn_cache_lookup_status = false;

6998

}

6999

}

7000

}

7001

if (TSHttpTxnReenable(txnp, TS_EVENT_HTTP_CONTINUE) != TS_SUCCESS) {

7002

SDK_RPRINT(data->test, "TSHttpTxnCacheLookupStatusGet", "", TC_FAIL, "Unable to reenable the transaction");

7003

}

7004

}

7005

break;

7006

case TS_EVENT_HTTP_READ_CACHE_HDR:

7007

{

7008

TSMBuffer reqbuf;

7009

TSMBuffer respbuf;

7010

7011

TSMLoc reqhdr;

7012

TSMLoc resphdr;

7013

7014

txnp = (TSHttpTxn) edata;

7015

7016

if (TSHttpTxnCachedReqGet(txnp, &reqbuf, &reqhdr) == 0) {

7017

SDK_RPRINT(data->test, "TSHttpTxnCachedReqGet", "TestCase1", TC_FAIL, "TSHttpTxnCachedReqGet returns 0");

7018

} else {

7019

if ((reqbuf == (((HttpSM *) txnp)->t_state.cache_req_hdr_heap_handle)) &&

7020

(reqhdr == ((((HttpSM *) txnp)->t_state.cache_info.object_read->request_get())->m_http))

7021

) {

7022

SDK_RPRINT(data->test, "TSHttpTxnCachedReqGet", "TestCase1", TC_PASS, "ok");

7023

data->test_passed_txn_cached_req_get = true;

7024

} else {

7025

SDK_RPRINT(data->test, "TSHttpTxnCachedReqGet", "TestCase1", TC_FAIL, "Value's Mismatch");

7026

}

7027

}

7028

7029

if (TSHttpTxnCachedRespGet(txnp, &respbuf, &resphdr) == 0) {

7030

SDK_RPRINT(data->test, "TSHttpTxnCachedRespGet", "TestCase1", TC_FAIL, "TSHttpTxnCachedRespGet returns 0");

7031

} else {

7032

if ((respbuf == (((HttpSM *) txnp)->t_state.cache_resp_hdr_heap_handle)) &&

7033

(resphdr == ((((HttpSM *) txnp)->t_state.cache_info.object_read->response_get())->m_http))

7034

) {

7035

SDK_RPRINT(data->test, "TSHttpTxnCachedRespGet", "TestCase1", TC_PASS, "ok");

7036

data->test_passed_txn_cached_resp_get = true;

7037

} else {

7038

SDK_RPRINT(data->test, "TSHttpTxnCachedRespGet", "TestCase1", TC_FAIL, "Value's Mismatch");

7039

}

7040

}

7041

7042

if ((TSHandleMLocRelease(reqbuf, TS_NULL_MLOC, reqhdr) != TS_SUCCESS) ||

7043

(TSHandleMLocRelease(respbuf, TS_NULL_MLOC, resphdr) != TS_SUCCESS)

7044

) {

7045

SDK_RPRINT(data->test, "TSHttpTxnCache", "", TC_FAIL, "Unable to release handle to headers.");

7046

}

7047

7048

if (TSHttpTxnReenable(txnp, TS_EVENT_HTTP_CONTINUE) != TS_SUCCESS) {

7049

SDK_RPRINT(data->test, "TSHttpTxnCache", "", TC_FAIL, "Unable to reenable the transaction.");

7050

}

7051

}

7052

7053

break;

7054

7055

case TS_EVENT_IMMEDIATE:

7056

case TS_EVENT_TIMEOUT:

7057

/* Browser still waiting the response ? */

7058

if (data->first_time == true) {

7059

if (data->browser1->status == REQUEST_INPROGRESS) {

7060

TSContSchedule(contp, 25, TS_THREAD_POOL_DEFAULT);

7061

return 0;

7062

}

7063

} else {

7064

if (data->browser2->status == REQUEST_INPROGRESS) {

7065

TSContSchedule(contp, 25, TS_THREAD_POOL_DEFAULT);

7066

return 0;

7067

}

7068

}

7069

7070

/* Browser got the response. test is over. clean up */

7071

{

7072

/* If this is the first time, then the response is in cache and we should make */

7073

/* another request to get cache hit */

7074

if (data->first_time == true) {

7075

data->first_time = false;

7076

/* Kill the origin server */

7077

synserver_delete(data->os);

7078

/* Send another similar client request */

7079

synclient_txn_send_request(data->browser2, data->request);

7080

TSfree(data->request);

7081

TSContSchedule(contp, 25, TS_THREAD_POOL_DEFAULT);

7082

return 0;

7083

}

7084

7085

/* Note: response is available using test->browser->response pointer */

7086

if ((data->browser1->status == REQUEST_SUCCESS) &&

7087

(data->browser2->status == REQUEST_SUCCESS) &&

7088

(data->test_passed_txn_cached_req_get == true) &&

7089

(data->test_passed_txn_cached_resp_get == true) && (data->test_passed_txn_cache_lookup_status == true)

7090

) {

7091

*(data->pstatus) = REGRESSION_TEST_PASSED;

7092

} else {

7093

*(data->pstatus) = REGRESSION_TEST_FAILED;

7094

}

7095

7096

// transaction is over. clean up.

7097

synclient_txn_delete(data->browser1);

7098

synclient_txn_delete(data->browser2);

7099

7100

data->magic = MAGIC_DEAD;

7101

TSfree(data);

7102

TSContDataSet(contp, NULL);

7103

}

7104

break;

7105

7106

default:

7107

*(data->pstatus) = REGRESSION_TEST_FAILED;

7108

SDK_RPRINT(data->test, "TSHttpTxnCache", "TestCase1", TC_FAIL, "Unexpected event %d", event);

7109

break;

7110

}

7111

return 0;

7112

}

7113

7114

7115

EXCLUSIVE_REGRESSION_TEST(SDK_API_HttpTxnCache) (RegressionTest * test, int atype, int *pstatus)

7116

{

7117

NOWARN_UNUSED(atype);

7118

*pstatus = REGRESSION_TEST_INPROGRESS;

7119

7120

TSCont cont = TSContCreate(cache_hook_handler, TSMutexCreate());

7121

if ((cont == NULL) || (cont == TS_ERROR_PTR)) {

7122

SDK_RPRINT(test, "TSHttpSsn", "TestCase1", TC_FAIL, "Unable to create Continuation.");

7123

*pstatus = REGRESSION_TEST_FAILED;

7124

return;

7125

}

7126

7127

CacheTestData *socktest = (CacheTestData *) TSmalloc(sizeof(CacheTestData));

7128

socktest->test = test;

7129

socktest->pstatus = pstatus;

7130

socktest->test_passed_txn_cached_req_get = false;

7131

socktest->test_passed_txn_cached_resp_get = false;

7132

socktest->first_time = true;

7133

socktest->magic = MAGIC_ALIVE;

7134

TSContDataSet(cont, socktest);

7135

7136

TSHttpHookAdd(TS_HTTP_READ_REQUEST_HDR_HOOK, cont);

7137

/* Register to HTTP hooks that are called in case of a cache MISS */

7138

TSHttpHookAdd(TS_HTTP_READ_CACHE_HDR_HOOK, cont);

7139

TSHttpHookAdd(TS_HTTP_CACHE_LOOKUP_COMPLETE_HOOK, cont);

7140

7141

/* Create a new synthetic server */

7142

socktest->os = synserver_create(SYNSERVER_LISTEN_PORT);

7143

synserver_start(socktest->os);

7144

7145

/* Create a client transaction */

7146

socktest->browser1 = synclient_txn_create();

7147

socktest->browser2 = synclient_txn_create();

7148

socktest->request = generate_request(2);

7149

synclient_txn_send_request(socktest->browser1, socktest->request);

7150

7151

/* Wait until transaction is done */

7152

TSContSchedule(cont, 25, TS_THREAD_POOL_DEFAULT);

7153

7154

return;

7155

}

7156

7157

///////////////////////////////////////////////////////

7158

// SDK_API_TSHttpTxnTransform

7159

7160

// Unit Test for API: TSHttpTxnTransformRespGet

7161

// TSHttpTxnTransformedRespCache

7162

// TSHttpTxnUntransformedRespCache

7163

///////////////////////////////////////////////////////

7164

7165

/** Append Transform Data Structure **/

7166

typedef struct

7167

{

7168

TSVIO output_vio;

7169

TSIOBuffer output_buffer;

7170

TSIOBufferReader output_reader;

7171

int append_needed;

7172

} MyTransformData;

7173

/** Append Transform Data Structure Ends **/

7174

7175

typedef struct

7176

{

7177

RegressionTest *test;

7178

int *pstatus;

7179

SocketServer *os;

7180

ClientTxn *browser1;

7181

ClientTxn *browser2;

7182

ClientTxn *browser3;

7183

ClientTxn *browser4;

7184

char *request1;

7185

char *request2;

7186

bool test_passed_txn_transform_resp_get;

7187

bool test_passed_txn_transformed_resp_cache;

7188

bool test_passed_txn_untransformed_resp_cache;

7189

bool test_passed_transform_create;

7190

int req_no;

7191

MyTransformData *transformData;

7192

int magic;

7193

} TransformTestData;

7194

7195

/**** Append Transform Code (Tailored to needs)****/

7196

7197

static TSIOBuffer append_buffer;

7198

static TSIOBufferReader append_buffer_reader;

7199

static int64_t append_buffer_length;

7200

7201

static MyTransformData *

7202

my_data_alloc()

7203

{

7204

MyTransformData *data;

7205

7206

data = (MyTransformData *) TSmalloc(sizeof(MyTransformData));

7207

data->output_vio = NULL;

7208

data->output_buffer = NULL;

7209

data->output_reader = NULL;

7210

data->append_needed = 1;

7211

7212

return data;

7213

}

7214

7215

static void

7216

my_data_destroy(MyTransformData * data)

7217

{

7218

if (data) {

7219

if (data->output_buffer) {

7220

TSIOBufferDestroy(data->output_buffer);

7221

}

7222

TSfree(data);

7223

}

7224

}

7225

7226

static void

7227

handle_transform(TSCont contp)

7228

{

7229

TSVConn output_conn;

7230

TSVIO write_vio;

7231

TransformTestData *contData;

7232

MyTransformData *data;

7233

int64_t towrite;

7234

int64_t avail;

7235

7236

/* Get the output connection where we'll write data to. */

7237

output_conn = TSTransformOutputVConnGet(contp);

7238

7239

/* Get the write VIO for the write operation that was performed on

7240

ourself. This VIO contains the buffer that we are to read from

7241

as well as the continuation we are to call when the buffer is

7242

empty. */

7243

write_vio = TSVConnWriteVIOGet(contp);

7244

7245

/* Get our data structure for this operation. The private data

7246

structure contains the output VIO and output buffer. If the

7247

private data structure pointer is NULL, then we'll create it

7248

and initialize its internals. */

7249

contData = (TransformTestData *) TSContDataGet(contp);

7250

data = contData->transformData;

7251

if (!data) {

7252

towrite = TSVIONBytesGet(write_vio);

7253

if (towrite != INT64_MAX) {

7254

towrite += append_buffer_length;

7255

}

7256

contData->transformData = my_data_alloc();

7257

data = contData->transformData;

7258

data->output_buffer = TSIOBufferCreate();

7259

data->output_reader = TSIOBufferReaderAlloc(data->output_buffer);

7260

data->output_vio = TSVConnWrite(output_conn, contp, data->output_reader, towrite);

7261

// Don't need this as the structure is encapsulated in another structure

7262

// which is set to be Continuation's Data.

7263

// TSContDataSet (contp, data);

7264

}

7265

7266

/* We also check to see if the write VIO's buffer is non-NULL. A

7267

NULL buffer indicates that the write operation has been

7268

shutdown and that the continuation does not want us to send any

7269

more WRITE_READY or WRITE_COMPLETE events. For this simplistic

7270

transformation that means we're done. In a more complex

7271

transformation we might have to finish writing the transformed

7272

data to our output connection. */

7273

if (!TSVIOBufferGet(write_vio)) {

7274

if (data->append_needed) {

7275

data->append_needed = 0;

7276

TSIOBufferCopy(TSVIOBufferGet(data->output_vio), append_buffer_reader, append_buffer_length, 0);

7277

}

7278

7279

TSVIONBytesSet(data->output_vio, TSVIONDoneGet(write_vio) + append_buffer_length);

7280

TSVIOReenable(data->output_vio);

7281

return;

7282

}

7283

7284

/* Determine how much data we have left to read. For this append

7285

transform plugin this is also the amount of data we have left

7286

to write to the output connection. */

7287

towrite = TSVIONTodoGet(write_vio);

7288

if (towrite > 0) {

7289

/* The amount of data left to read needs to be truncated by

7290

the amount of data actually in the read buffer. */

7291

avail = TSIOBufferReaderAvail(TSVIOReaderGet(write_vio));

7292

if (towrite > avail) {

7293

towrite = avail;

7294

}

7295

7296

if (towrite > 0) {

7297

/* Copy the data from the read buffer to the output buffer. */

7298

TSIOBufferCopy(TSVIOBufferGet(data->output_vio), TSVIOReaderGet(write_vio), towrite, 0);

7299

7300

/* Tell the read buffer that we have read the data and are no

7301

longer interested in it. */

7302

TSIOBufferReaderConsume(TSVIOReaderGet(write_vio), towrite);

7303

7304

/* Modify the write VIO to reflect how much data we've

7305

completed. */

7306

TSVIONDoneSet(write_vio, TSVIONDoneGet(write_vio) + towrite);

7307

}

7308

}

7309

7310

/* Now we check the write VIO to see if there is data left to

7311

read. */

7312

if (TSVIONTodoGet(write_vio) > 0) {

7313

if (towrite > 0) {

7314

/* If there is data left to read, then we reenable the output

7315

connection by reenabling the output VIO. This will wakeup

7316

the output connection and allow it to consume data from the

7317

output buffer. */

7318

TSVIOReenable(data->output_vio);

7319

7320

/* Call back the write VIO continuation to let it know that we

7321

are ready for more data. */

7322

TSContCall(TSVIOContGet(write_vio), TS_EVENT_VCONN_WRITE_READY, write_vio);

7323

}

7324

} else {

7325

if (data->append_needed) {

7326

data->append_needed = 0;

7327

TSIOBufferCopy(TSVIOBufferGet(data->output_vio), append_buffer_reader, append_buffer_length, 0);

7328

}

7329

7330

/* If there is no data left to read, then we modify the output

7331

VIO to reflect how much data the output connection should

7332

expect. This allows the output connection to know when it

7333

is done reading. We then reenable the output connection so

7334

that it can consume the data we just gave it. */

7335

TSVIONBytesSet(data->output_vio, TSVIONDoneGet(write_vio) + append_buffer_length);

7336

TSVIOReenable(data->output_vio);

7337

7338

/* Call back the write VIO continuation to let it know that we

7339

have completed the write operation. */

7340

TSContCall(TSVIOContGet(write_vio), TS_EVENT_VCONN_WRITE_COMPLETE, write_vio);

7341

}

7342

}

7343

7344

static int

7345

transformtest_transform(TSCont contp, TSEvent event, void *edata)

7346

{

7347

NOWARN_UNUSED(edata);

7348

TransformTestData *contData = (TransformTestData *) TSContDataGet(contp);

7349

if (contData->test_passed_transform_create == false) {

7350

contData->test_passed_transform_create = true;

7351

SDK_RPRINT(contData->test, "TSTransformCreate", "TestCase1", TC_PASS, "ok");

7352

}

7353

/* Check to see if the transformation has been closed by a call to

7354

TSVConnClose. */

7355

if (TSVConnClosedGet(contp)) {

7356

my_data_destroy(contData->transformData);

7357

contData->transformData = NULL;

7358

TSContDestroy(contp);

7359

return 0;

7360

} else {

7361

switch (event) {

7362

case TS_EVENT_ERROR:

7363

{

7364

TSVIO write_vio;

7365

7366

/* Get the write VIO for the write operation that was

7367

performed on ourself. This VIO contains the continuation of

7368

our parent transformation. */

7369

write_vio = TSVConnWriteVIOGet(contp);

7370

7371

/* Call back the write VIO continuation to let it know that we

7372

have completed the write operation. */

7373

TSContCall(TSVIOContGet(write_vio), TS_EVENT_ERROR, write_vio);

7374

}

7375

break;

7376

case TS_EVENT_VCONN_WRITE_COMPLETE:

7377

/* When our output connection says that it has finished

7378

reading all the data we've written to it then we should

7379

shutdown the write portion of its connection to

7380

indicate that we don't want to hear about it anymore. */

7381

TSVConnShutdown(TSTransformOutputVConnGet(contp), 0, 1);

7382

break;

7383

case TS_EVENT_VCONN_WRITE_READY:

7384

default:

7385

/* If we get a WRITE_READY event or any other type of

7386

event (sent, perhaps, because we were reenabled) then

7387

we'll attempt to transform more data. */

7388

handle_transform(contp);

7389

break;

7390

}

7391

}

7392

7393

return 0;

7394

}

7395

7396

static int

7397

transformable(TSHttpTxn txnp, TransformTestData * data)

7398

{

7399

TSMBuffer bufp;

7400

TSMLoc hdr_loc;

7401

7402

if (TSHttpTxnServerRespGet(txnp, &bufp, &hdr_loc) == 0) {

7403

SDK_RPRINT(data->test, "TSHttpTxnTransform", "", TC_FAIL, "[transformable]: TSHttpTxnServerRespGet return 0");

7404

}

7405

7406

7407

* We are only interested in "200 OK" responses.

7408

7409

7410

if (TS_HTTP_STATUS_OK == TSHttpHdrStatusGet(bufp, hdr_loc)) {

7411

return 1;

7412

}

7413

// XXX - Can't return TS_ERROR because that is a different type

7414

// -bcall 7/24/07

7415

// if (resp_status == TS_ERROR) {

7416

// SDK_RPRINT(data->test,"TSHttpTxnTransform","",TC_FAIL,"[transformable]: TSHttpHdrStatusGet returns TS_ERROR");

7417

// }

7418

7419

return 0; /* not a 200 */

7420

}

7421

7422

static void

7423

transform_add(TSHttpTxn txnp, TransformTestData * data)

7424

{

7425

TSVConn connp;

7426

7427

connp = TSTransformCreate(transformtest_transform, txnp);

7428

TSContDataSet(connp, data);

7429

if ((connp == NULL) || (connp == TS_ERROR_PTR)) {

7430

SDK_RPRINT(data->test, "TSHttpTxnTransform", "", TC_FAIL, "Unable to create Transformation.");

7431

return;

7432

}

7433

7434

if (TSHttpTxnHookAdd(txnp, TS_HTTP_RESPONSE_TRANSFORM_HOOK, connp) != TS_SUCCESS) {

7435

SDK_RPRINT(data->test, "TSHttpTxnTransform", "", TC_FAIL, "Unable to add Transformation to the transform hook.");

7436

}

7437

return;

7438

}

7439

7440

static int

7441

load(const char *append_string)

7442

{

7443

TSIOBufferBlock blk;

7444

char *p;

7445

int64_t avail;

7446

7447

append_buffer = TSIOBufferCreate();

7448

append_buffer_reader = TSIOBufferReaderAlloc(append_buffer);

7449

7450

blk = TSIOBufferStart(append_buffer);

7451

p = TSIOBufferBlockWriteStart(blk, &avail);

7452

7453

ink_strncpy(p, append_string, avail);

7454

if (append_string != NULL) {

7455

TSIOBufferProduce(append_buffer, strlen(append_string));

7456

}

7457

7458

append_buffer_length = TSIOBufferReaderAvail(append_buffer_reader);

7459

7460

return 1;

7461

}

7462

7463

/**** Append Transform Code Ends ****/

7464

7465

static int

7466

transform_hook_handler(TSCont contp, TSEvent event, void *edata)

7467

{

7468

TSHttpTxn txnp = NULL;

7469

TransformTestData *data = NULL;

7470

data = (TransformTestData *) TSContDataGet(contp);

7471

if ((data == TS_ERROR_PTR) || (data == NULL)) {

7472

switch (event) {

7473

case TS_EVENT_IMMEDIATE:

7474

case TS_EVENT_TIMEOUT:

7475

break;

7476

case TS_EVENT_HTTP_READ_RESPONSE_HDR:

7477

default:

7478

TSHttpTxnReenable((TSHttpTxn) edata, TS_EVENT_HTTP_CONTINUE);

7479

break;

7480

}

7481

return 0;

7482

}

7483

7484

switch (event) {

7485

case TS_EVENT_HTTP_READ_REQUEST_HDR:

7486

txnp = (TSHttpTxn) edata;

7487

TSSkipRemappingSet(txnp,1);

7488

TSHttpTxnReenable(txnp, TS_EVENT_HTTP_CONTINUE);

7489

break;

7490

case TS_EVENT_HTTP_READ_RESPONSE_HDR:

7491

txnp = (TSHttpTxn) edata;

7492

/* Setup hooks for Transformation */

7493

if (transformable(txnp, data)) {

7494

transform_add(txnp, data);

7495

}

7496

/* Call TransformedRespCache or UntransformedRespCache depending on request */

7497

{

7498

TSMBuffer bufp;

7499

TSMLoc hdr;

7500

TSMLoc field;

7501

7502

if (TSHttpTxnClientReqGet(txnp, &bufp, &hdr) == 0) {

7503

SDK_RPRINT(data->test, "TSHttpTxnTransform", "TestCase", TC_FAIL, "TSHttpTxnClientReqGet returns 0");

7504

} else {

7505

field = TSMimeHdrFieldFind(bufp, hdr, "Request", -1);

7506

if ((field == NULL) || (field == TS_ERROR_PTR)) {

7507

SDK_RPRINT(data->test, "TSHttpTxnTransform", "TestCase", TC_FAIL, "Didn't find field request");

7508

} else {

7509

int reqid;

7510

if (TSMimeHdrFieldValueIntGet(bufp, hdr, field, 0, &reqid) != TS_SUCCESS) {

7511

SDK_RPRINT(data->test, "TSHttpTxnTransform", "TestCase", TC_FAIL, "Error in getting field Value");

7512

} else {

7513

if (reqid == 1) {

7514

if ((TSHttpTxnTransformedRespCache(txnp, 0) != TS_SUCCESS) ||

7515

(TSHttpTxnUntransformedRespCache(txnp, 1) != TS_SUCCESS)

7516

) {

7517

SDK_RPRINT(data->test, "TSHttpTxnTransformedRespCache", "TestCase", TC_FAIL,

7518

"TSHttpTxnTransformedRespCache or TSHttpTxnUntransformedRespCache doesn't return TS_SUCCESS.reqid=%d",

7519

reqid);

7520

}

7521

}

7522

if (reqid == 2) {

7523

if ((TSHttpTxnTransformedRespCache(txnp, 1) != TS_SUCCESS) ||

7524

(TSHttpTxnUntransformedRespCache(txnp, 0) != TS_SUCCESS)

7525

) {

7526

SDK_RPRINT(data->test, "TSHttpTxnTransformedRespCache", "TestCase", TC_FAIL,

7527

"TSHttpTxnTransformedRespCache or TSHttpTxnUntransformedRespCache doesn't return TS_SUCCESS.reqid=%d",

7528

reqid);

7529

}

7530

}

7531

}

7532

if (TSHandleMLocRelease(bufp, hdr, field) != TS_SUCCESS) {

7533

SDK_RPRINT(data->test, "TSHttpTxnTransform", "TestCase", TC_FAIL,

7534

"Unable to release handle to field in Client request");

7535

}

7536

}

7537

if (TSHandleMLocRelease(bufp, TS_NULL_MLOC, hdr) != TS_SUCCESS) {

7538

SDK_RPRINT(data->test, "TSHttpTxnTransform", "TestCase", TC_FAIL,

7539

"Unable to release handle to Client request");

7540

}

7541

}

7542

}

7543

7544

/* Add the transaction hook to SEND_RESPONSE_HDR_HOOK */

7545

if (TSHttpTxnHookAdd(txnp, TS_HTTP_SEND_RESPONSE_HDR_HOOK, contp) != TS_SUCCESS) {

7546

SDK_RPRINT(data->test, "TSHttpTxnTransform", "", TC_FAIL,

7547

"Cannot add transaction hook to SEND_RESPONSE_HDR_HOOK");

7548

}

7549

/* Reenable the transaction */

7550

if (TSHttpTxnReenable(txnp, TS_EVENT_HTTP_CONTINUE) != TS_SUCCESS) {

7551

SDK_RPRINT(data->test, "TSHttpTxnTransform", "", TC_FAIL,

7552

"Reenabling the transaction doesn't return TS_SUCCESS");

7553

}

7554

break;

7555

7556

case TS_EVENT_HTTP_SEND_RESPONSE_HDR:

7557

{

7558

TSMBuffer bufp;

7559

TSMLoc hdr;

7560

txnp = (TSHttpTxn) edata;

7561

if (TSHttpTxnTransformRespGet(txnp, &bufp, &hdr) == 0) {

7562

SDK_RPRINT(data->test, "TSHttpTxnTransformRespGet", "TestCase", TC_FAIL,

7563

"TSHttpTxnTransformRespGet returns 0");

7564

data->test_passed_txn_transform_resp_get = false;

7565

} else {

7566

if ((bufp == &(((HttpSM *) txnp)->t_state.hdr_info.transform_response)) &&

7567

(hdr == (&(((HttpSM *) txnp)->t_state.hdr_info.transform_response))->m_http)

7568

) {

7569

SDK_RPRINT(data->test, "TSHttpTxnTransformRespGet", "TestCase", TC_PASS, "ok");

7570

} else {

7571

SDK_RPRINT(data->test, "TSHttpTxnTransformRespGet", "TestCase", TC_FAIL, "Value's Mismatch");

7572

data->test_passed_txn_transform_resp_get = false;

7573

}

7574

if (TSHandleMLocRelease(bufp, TS_NULL_MLOC, hdr) != TS_SUCCESS) {

7575

SDK_RPRINT(data->test, "TSHttpTxnTransformRespGet", "TestCase", TC_FAIL,

7576

"Unable to release handle to Transform header handle");

7577

}

7578

7579

}

7580

}

7581

if (TSHttpTxnReenable(txnp, TS_EVENT_HTTP_CONTINUE) != TS_SUCCESS) {

7582

SDK_RPRINT(data->test, "TSHttpTxnTransformRespGet", "", TC_FAIL,

7583

"Reenabling the transaction doesn't return TS_SUCCESS");

7584

}

7585

break;

7586

7587

case TS_EVENT_IMMEDIATE:

7588

case TS_EVENT_TIMEOUT:

7589

7590

switch (data->req_no) {

7591

case 1:

7592

if (data->browser1->status == REQUEST_INPROGRESS) {

7593

TSContSchedule(contp, 25, TS_THREAD_POOL_DEFAULT);

7594

return 0;

7595

}

7596

data->req_no++;

7597

Debug(UTDBG_TAG "_transform", "Running Browser 2");

7598

synclient_txn_send_request(data->browser2, data->request2);

7599

TSContSchedule(contp, 25, TS_THREAD_POOL_DEFAULT);

7600

return 0;

7601

case 2:

7602

if (data->browser2->status == REQUEST_INPROGRESS) {

7603

TSContSchedule(contp, 25, TS_THREAD_POOL_DEFAULT);

7604

return 0;

7605

}

7606

data->req_no++;

7607

Debug(UTDBG_TAG "_transform", "Running Browser 3");

7608

synclient_txn_send_request(data->browser3, data->request1);

7609

TSContSchedule(contp, 25, TS_THREAD_POOL_DEFAULT);

7610

return 0;

7611

case 3:

7612

if (data->browser3->status == REQUEST_INPROGRESS) {

7613

TSContSchedule(contp, 25, TS_THREAD_POOL_DEFAULT);

7614

return 0;

7615

}

7616

data->req_no++;

7617

Debug(UTDBG_TAG "_transform", "Running Browser 4");

7618

synclient_txn_send_request(data->browser4, data->request2);

7619

TSContSchedule(contp, 25, TS_THREAD_POOL_DEFAULT);

7620

return 0;

7621

case 4:

7622

if (data->browser4->status == REQUEST_INPROGRESS) {

7623

TSContSchedule(contp, 25, TS_THREAD_POOL_DEFAULT);

7624

return 0;

7625

}

7626

synserver_delete(data->os);

7627

data->req_no++;

7628

TSfree(data->request1);

7629

TSfree(data->request2);

7630

// for squid log: if this is the last (or only) test in your

7631

// regression run you will not see any log entries in squid

7632

// (because logging is buffered and not flushed before

7633

// termination when running regressions)

7634

// sleep(10);

7635

break;

7636

default:

7637

SDK_RPRINT(data->test, "TSHttpTxnTransform", "TestCase", TC_FAIL, "Something terribly wrong with the test");

7638

exit(0);

7639

7640

}

7641

/* Browser got the response. test is over */

7642

{

7643

/* Check if we got the response we were expecting or not */

7644

if ((strstr(data->browser1->response, TRANSFORM_APPEND_STRING) != NULL) &&

7645

(strstr(data->browser3->response, TRANSFORM_APPEND_STRING) == NULL)

7646

) {

7647

SDK_RPRINT(data->test, "TSHttpTxnUntransformedResponseCache", "TestCase1", TC_PASS, "ok");

7648

data->test_passed_txn_untransformed_resp_cache = true;

7649

} else {

7650

SDK_RPRINT(data->test, "TSHttpTxnUntransformedResponseCache", "TestCase1", TC_FAIL, "Value's Mismatch");

7651

}

7652

7653

if ((strstr(data->browser2->response, TRANSFORM_APPEND_STRING) != NULL) &&

7654

(strstr(data->browser4->response, TRANSFORM_APPEND_STRING) != NULL)

7655

) {

7656

SDK_RPRINT(data->test, "TSHttpTxnTransformedResponseCache", "TestCase1", TC_PASS, "ok");

7657

data->test_passed_txn_transformed_resp_cache = true;

7658

} else {

7659

SDK_RPRINT(data->test, "TSHttpTxnTransformedResponseCache", "TestCase1", TC_FAIL, "Value's Mismatch");

7660

}

7661

7662

/* Note: response is available using test->browser->response pointer */

7663

*(data->pstatus) = REGRESSION_TEST_PASSED;

7664

if (data->browser1->status != REQUEST_SUCCESS) {

7665

SDK_RPRINT(data->test, "TSTransformCreate", "TestCase1", TC_FAIL, "Browser 1 status was not REQUEST_SUCCESS");

7666

*(data->pstatus) = REGRESSION_TEST_FAILED;

7667

}

7668

if (data->browser2->status != REQUEST_SUCCESS) {

7669

SDK_RPRINT(data->test, "TSTransformCreate", "TestCase1", TC_FAIL, "Browser 2 status was not REQUEST_SUCCESS");

7670

*(data->pstatus) = REGRESSION_TEST_FAILED;

7671

}

7672

if (data->browser3->status != REQUEST_SUCCESS) {

7673

SDK_RPRINT(data->test, "TSTransformCreate", "TestCase1", TC_FAIL, "Browser 3 status was not REQUEST_SUCCESS");

7674

*(data->pstatus) = REGRESSION_TEST_FAILED;

7675

}

7676

if (data->browser4->status != REQUEST_SUCCESS) {

7677

SDK_RPRINT(data->test, "TSTransformCreate", "TestCase1", TC_FAIL, "Browser 4 status was not REQUEST_SUCCESS");

7678

*(data->pstatus) = REGRESSION_TEST_FAILED;

7679

}

7680

if (data->test_passed_txn_transform_resp_get != true) {

7681

SDK_RPRINT(data->test, "TSTransformCreate", "TestCase1", TC_FAIL, "did not pass transform_resp_get");

7682

*(data->pstatus) = REGRESSION_TEST_FAILED;

7683

}

7684

if (data->test_passed_txn_transformed_resp_cache != true) {

7685

SDK_RPRINT(data->test, "TSTransformCreate", "TestCase1", TC_FAIL, "did not pass transformed_resp_cache");

7686

*(data->pstatus) = REGRESSION_TEST_FAILED;

7687

}

7688

if (data->test_passed_txn_untransformed_resp_cache != true) {

7689

SDK_RPRINT(data->test, "TSTransformCreate", "TestCase1", TC_FAIL, "did not pass untransformed_resp_cache");

7690

*(data->pstatus) = REGRESSION_TEST_FAILED;

7691

}

7692

if (data->test_passed_transform_create != true) {

7693

SDK_RPRINT(data->test, "TSTransformCreate", "TestCase1", TC_FAIL, "did not pass transform_create");

7694

*(data->pstatus) = REGRESSION_TEST_FAILED;

7695

}

7696

// transaction is over. clean up.

7697

synclient_txn_delete(data->browser1);

7698

synclient_txn_delete(data->browser2);

7699

synclient_txn_delete(data->browser3);

7700

synclient_txn_delete(data->browser4);

7701

7702

data->magic = MAGIC_DEAD;

7703

TSfree(data);

7704

TSContDataSet(contp, NULL);

7705

}

7706

break;

7707

7708

default:

7709

*(data->pstatus) = REGRESSION_TEST_FAILED;

7710

SDK_RPRINT(data->test, "TSHttpTxnTransform", "TestCase1", TC_FAIL, "Unexpected event %d", event);

7711

break;

7712

}

7713

return 0;

7714

}

7715

7716

7717

EXCLUSIVE_REGRESSION_TEST(SDK_API_HttpTxnTransform) (RegressionTest * test, int atype, int *pstatus)

7718

{

7719

NOWARN_UNUSED(atype);

7720

*pstatus = REGRESSION_TEST_INPROGRESS;

7721

7722

Debug(UTDBG_TAG "_transform", "Starting test");

7723

7724

TSCont cont = TSContCreate(transform_hook_handler, TSMutexCreate());

7725

if ((cont == NULL) || (cont == TS_ERROR_PTR)) {

7726

SDK_RPRINT(test, "TSHttpSsn", "TestCase1", TC_FAIL, "Unable to create Continuation.");

7727

*pstatus = REGRESSION_TEST_FAILED;

7728

return;

7729

}

7730

7731

TransformTestData *socktest = (TransformTestData *) TSmalloc(sizeof(TransformTestData));

7732

socktest->test = test;

7733

socktest->pstatus = pstatus;

7734

socktest->test_passed_txn_transform_resp_get = true;

7735

socktest->test_passed_txn_transformed_resp_cache = false;

7736

socktest->test_passed_txn_transformed_resp_cache = false;

7737

socktest->test_passed_transform_create = false;

7738

socktest->transformData = NULL;

7739

socktest->req_no = 1;

7740

socktest->magic = MAGIC_ALIVE;

7741

TSContDataSet(cont, socktest);

7742

7743

/* Prepare the buffer to be appended to responses */

7744

load(TRANSFORM_APPEND_STRING);

7745

7746

TSHttpHookAdd(TS_HTTP_READ_REQUEST_HDR_HOOK, cont); //so we can skip remapping

7747

7748

/* Register to HTTP hooks that are called in case of a cache MISS */

7749

TSHttpHookAdd(TS_HTTP_READ_RESPONSE_HDR_HOOK, cont);

7750

7751

/* Create a new synthetic server */

7752

socktest->os = synserver_create(SYNSERVER_LISTEN_PORT);

7753

synserver_start(socktest->os);

7754

7755

/* Create a client transaction */

7756

socktest->browser1 = synclient_txn_create();

7757

socktest->browser2 = synclient_txn_create();

7758

socktest->browser3 = synclient_txn_create();

7759

socktest->browser4 = synclient_txn_create();

7760

socktest->request1 = generate_request(4);

7761

socktest->request2 = generate_request(5);

7762

Debug(UTDBG_TAG "_transform", "Running Browser 1");

7763

synclient_txn_send_request(socktest->browser1, socktest->request1);

7764

// synclient_txn_send_request(socktest->browser2, socktest->request2);

7765

7766

/* Wait until transaction is done */

7767

TSContSchedule(cont, 25, TS_THREAD_POOL_DEFAULT);

7768

7769

return;

7770

}

7771

7772

//////////////////////////////////////////////

7773

// SDK_API_TSHttpTxnAltInfo

7774

7775

// Unit Test for API: TSHttpTxnCachedReqGet

7776

// TSHttpTxnCachedRespGet

7777

//////////////////////////////////////////////

7778

7779

typedef struct

7780

{

7781

RegressionTest *test;

7782

int *pstatus;

7783

SocketServer *os;

7784

ClientTxn *browser1;

7785

ClientTxn *browser2;

7786

ClientTxn *browser3;

7787

char *request1;

7788

char *request2;

7789

char *request3;

7790

bool test_passed_txn_alt_info_client_req_get;

7791

bool test_passed_txn_alt_info_cached_req_get;

7792

bool test_passed_txn_alt_info_cached_resp_get;

7793

bool test_passed_txn_alt_info_quality_set;

7794

bool run_at_least_once;

7795

bool first_time;

7796

int magic;

7797

} AltInfoTestData;

7798

7799

static int

7800

altinfo_hook_handler(TSCont contp, TSEvent event, void *edata)

7801

{

7802

AltInfoTestData *data = NULL;

7803

TSHttpTxn txnp = NULL;

7804

7805

data = (AltInfoTestData *) TSContDataGet(contp);

7806

if ((data == TS_ERROR_PTR) || (data == NULL)) {

7807

switch (event) {

7808

case TS_EVENT_IMMEDIATE:

7809

case TS_EVENT_TIMEOUT:

7810

break;

7811

case TS_EVENT_HTTP_SELECT_ALT:

7812

break;

7813

default:

7814

TSHttpTxnReenable((TSHttpTxn) edata, TS_EVENT_HTTP_CONTINUE);

7815

break;

7816

}

7817

return 0;

7818

}

7819

7820

switch (event) {

7821

case TS_EVENT_HTTP_READ_REQUEST_HDR:

7822

txnp = (TSHttpTxn) edata;

7823

TSSkipRemappingSet(txnp,1);

7824

TSHttpTxnReenable(txnp, TS_EVENT_HTTP_CONTINUE);

7825

break;

7826

7827

case TS_EVENT_HTTP_SELECT_ALT:

7828

{

7829

TSMBuffer clientreqbuf;

7830

TSMBuffer cachereqbuf;

7831

TSMBuffer cacherespbuf;

7832

7833

TSMLoc clientreqhdr;

7834

TSMLoc cachereqhdr;

7835

TSMLoc cacheresphdr;

7836

7837

TSHttpAltInfo infop = (TSHttpAltInfo) edata;

7838

7839

data->run_at_least_once = true;

7840

if (TSHttpAltInfoClientReqGet(infop, &clientreqbuf, &clientreqhdr) != TS_SUCCESS) {

7841

SDK_RPRINT(data->test, "TSHttpAltInfoClientReqGet", "TestCase", TC_FAIL,

7842

"TSHttpAltInfoClientReqGet doesn't return TS_SUCCESS");

7843

data->test_passed_txn_alt_info_client_req_get = false;

7844

} else {

7845

if ((clientreqbuf == (&(((HttpAltInfo *) infop)->m_client_req))) &&

7846

(clientreqhdr == ((HttpAltInfo *) infop)->m_client_req.m_http)

7847

) {

7848

SDK_RPRINT(data->test, "TSHttpAltInfoClientReqGet", "TestCase", TC_PASS, "ok");

7849

} else {

7850

SDK_RPRINT(data->test, "TSHttpAltInfoClientReqGet", "TestCase", TC_FAIL, "Value's Mismatch");

7851

data->test_passed_txn_alt_info_client_req_get = false;

7852

}

7853

}

7854

7855

if (TSHttpAltInfoCachedReqGet(infop, &cachereqbuf, &cachereqhdr) != TS_SUCCESS) {

7856

SDK_RPRINT(data->test, "TSHttpAltInfoCachedReqGet", "TestCase", TC_FAIL,

7857

"TSHttpAltInfoCachedReqGet doesn't return TS_SUCCESS");

7858

data->test_passed_txn_alt_info_cached_req_get = false;

7859

} else {

7860

if ((cachereqbuf == (&(((HttpAltInfo *) infop)->m_cached_req))) &&

7861

(cachereqhdr == ((HttpAltInfo *) infop)->m_cached_req.m_http)

7862

) {

7863

SDK_RPRINT(data->test, "TSHttpAltInfoCachedReqGet", "TestCase", TC_PASS, "ok");

7864

} else {

7865

SDK_RPRINT(data->test, "TSHttpAltInfoCachedReqGet", "TestCase", TC_FAIL, "Value's Mismatch");

7866

data->test_passed_txn_alt_info_cached_req_get = false;

7867

}

7868

}

7869

7870

if (TSHttpAltInfoCachedRespGet(infop, &cacherespbuf, &cacheresphdr) != TS_SUCCESS) {

7871

SDK_RPRINT(data->test, "TSHttpAltInfoCachedRespGet", "TestCase", TC_FAIL,

7872

"TSHttpAltInfoCachedRespGet doesn't return TS_SUCCESS");

7873

data->test_passed_txn_alt_info_cached_resp_get = false;

7874

} else {

7875

if ((cacherespbuf == (&(((HttpAltInfo *) infop)->m_cached_resp))) &&

7876

(cacheresphdr == ((HttpAltInfo *) infop)->m_cached_resp.m_http)

7877

) {

7878

SDK_RPRINT(data->test, "TSHttpAltInfoCachedRespGet", "TestCase", TC_PASS, "ok");

7879

} else {

7880

SDK_RPRINT(data->test, "TSHttpAltInfoCachedRespGet", "TestCase", TC_FAIL, "Value's Mismatch");

7881

data->test_passed_txn_alt_info_cached_resp_get = false;

7882

}

7883

}

7884

7885

if (TSHttpAltInfoQualitySet(infop, 0.5) != TS_SUCCESS) {

7886

SDK_RPRINT(data->test, "TSHttpAltInfoQualityset", "TestCase", TC_FAIL,

7887

"TSHttpAltInfoQualitySet doesn't return TS_SUCCESS");

7888

data->test_passed_txn_alt_info_quality_set = false;

7889

} else {

7890

SDK_RPRINT(data->test, "TSHttpAltInfoQualitySet", "TestCase", TC_PASS, "ok");

7891

}

7892

}

7893

7894

break;

7895

7896

case TS_EVENT_IMMEDIATE:

7897

case TS_EVENT_TIMEOUT:

7898

/* Browser still waiting the response ? */

7899

if (data->first_time == true) {

7900

if ((data->browser1->status == REQUEST_INPROGRESS) || (data->browser2->status == REQUEST_INPROGRESS)) {

7901

TSContSchedule(contp, 25, TS_THREAD_POOL_DEFAULT);

7902

return 0;

7903

}

7904

} else {

7905

if (data->browser3->status == REQUEST_INPROGRESS) {

7906

TSContSchedule(contp, 25, TS_THREAD_POOL_DEFAULT);

7907

return 0;

7908

}

7909

}

7910

7911

/* Browser got the response. test is over. clean up */

7912

{

7913

/* If this is the first time, then both the responses are in cache and we should make */

7914

/* another request to get cache hit */

7915

if (data->first_time == true) {

7916

data->first_time = false;

7917

/* Kill the origin server */

7918

synserver_delete(data->os);

7919

// ink_release_assert(0);

7920

/* Send another similar client request */

7921

synclient_txn_send_request(data->browser3, data->request3);

7922

7923

/* Register to HTTP hooks that are called in case of alternate selection */

7924

if (TSHttpHookAdd(TS_HTTP_SELECT_ALT_HOOK, contp) != TS_SUCCESS) {

7925

SDK_RPRINT(data->test, "TSHttpAltInfo", "", TC_FAIL, "TSHttpHookAdd doesn't return TS_SUCCESS");

7926

}

7927

7928

TSContSchedule(contp, 25, TS_THREAD_POOL_DEFAULT);

7929

return 0;

7930

}

7931

7932

/* Note: response is available using test->browser->response pointer */

7933

if ((data->browser3->status == REQUEST_SUCCESS) &&

7934

(data->test_passed_txn_alt_info_client_req_get == true) &&

7935

(data->test_passed_txn_alt_info_cached_req_get == true) &&

7936

(data->test_passed_txn_alt_info_cached_resp_get == true) &&

7937

(data->test_passed_txn_alt_info_quality_set == true) && (data->run_at_least_once == true)

7938

) {

7939

*(data->pstatus) = REGRESSION_TEST_PASSED;

7940

} else {

7941

if (data->run_at_least_once == false) {

7942

SDK_RPRINT(data->test, "TSHttpAltInfo", "All", TC_FAIL, "Test not executed even once");

7943

}

7944

*(data->pstatus) = REGRESSION_TEST_FAILED;

7945

}

7946

7947

// transaction is over. clean up.

7948

synclient_txn_delete(data->browser1);

7949

synclient_txn_delete(data->browser2);

7950

synclient_txn_delete(data->browser3);

7951

7952

TSfree(data->request1);

7953

TSfree(data->request2);

7954

TSfree(data->request3);

7955

7956

data->magic = MAGIC_DEAD;

7957

TSfree(data);

7958

TSContDataSet(contp, NULL);

7959

}

7960

break;

7961

7962

default:

7963

*(data->pstatus) = REGRESSION_TEST_FAILED;

7964

SDK_RPRINT(data->test, "TSHttpTxnCache", "TestCase1", TC_FAIL, "Unexpected event %d", event);

7965

break;

7966

}

7967

return 0;

7968

}

7969

7970

7971

7972

EXCLUSIVE_REGRESSION_TEST(SDK_API_HttpAltInfo) (RegressionTest * test, int atype, int *pstatus)

7973

{

7974

NOWARN_UNUSED(atype);

7975

*pstatus = REGRESSION_TEST_INPROGRESS;

7976

7977

TSCont cont = TSContCreate(altinfo_hook_handler, TSMutexCreate());

7978

if ((cont == NULL) || (cont == TS_ERROR_PTR)) {

7979

SDK_RPRINT(test, "TSHttpSsn", "TestCase1", TC_FAIL, "Unable to create Continuation.");

7980

*pstatus = REGRESSION_TEST_FAILED;

7981

return;

7982

}

7983

7984

TSHttpHookAdd(TS_HTTP_READ_REQUEST_HDR_HOOK, cont); //so we can skip remapping

7985

7986

AltInfoTestData *socktest = (AltInfoTestData *) TSmalloc(sizeof(AltInfoTestData));

7987

socktest->test = test;

7988

socktest->pstatus = pstatus;

7989

socktest->test_passed_txn_alt_info_client_req_get = true;

7990

socktest->test_passed_txn_alt_info_cached_req_get = true;

7991

socktest->test_passed_txn_alt_info_cached_resp_get = true;

7992

socktest->test_passed_txn_alt_info_quality_set = true;

7993

socktest->run_at_least_once = false;

7994

socktest->first_time = true;

7995

socktest->magic = MAGIC_ALIVE;

7996

TSContDataSet(cont, socktest);

7997

7998

/* Create a new synthetic server */

7999

socktest->os = synserver_create(SYNSERVER_LISTEN_PORT);

8000

synserver_start(socktest->os);

8001

8002

/* Create a client transaction */

8003

socktest->browser1 = synclient_txn_create();

8004

socktest->browser2 = synclient_txn_create();

8005

socktest->browser3 = synclient_txn_create();

8006

socktest->request1 = generate_request(6);

8007

socktest->request2 = generate_request(7);

8008

socktest->request3 = generate_request(8);

8009

synclient_txn_send_request(socktest->browser1, socktest->request1);

8010

synclient_txn_send_request(socktest->browser2, socktest->request2);

8011

8012

/* Wait until transaction is done */

8013

TSContSchedule(cont, 25, TS_THREAD_POOL_DEFAULT);

8014

8015

return;

8016

}

8017

8018

8019

//////////////////////////////////////////////

8020

// SDK_API_TSHttpConnect

8021

8022

// Unit Test for APIs:

8023

// - TSHttpConnect

8024

// - TSHttpTxnIntercept

8025

// - TSHttpTxnInterceptServer

8026

8027

8028

// 2 Test cases.

8029

8030

// Same test strategy:

8031

// - create a synthetic server listening on port A

8032

// - use HttpConnect to send a request to TS for an url on a remote host H, port B

8033

// - use TxnIntercept or TxnServerIntercept to forward the request

8034

// to the synthetic server on local host, port A

8035

// - make sure response is correct

8036

8037

//////////////////////////////////////////////

8038

8039

// Important: we create servers listening on different port than the default one

8040

// to make sure our synthetix servers are called

8041

8042

#define TEST_CASE_CONNECT_ID1 9 //TSHttpTxnIntercept

8043

#define TEST_CASE_CONNECT_ID2 10 //TSHttpTxnServerIntercept

8044

8045

#define SYNSERVER_DUMMY_PORT -1

8046

8047

typedef struct

8048

{

8049

RegressionTest *test;

8050

int *pstatus;

8051

int test_case;

8052

TSVConn vc;

8053

SocketServer *os;

8054

ClientTxn *browser;

8055

char *request;

8056

unsigned long magic;

8057

} ConnectTestData;

8058

8059

8060

static int

8061

cont_test_handler(TSCont contp, TSEvent event, void *edata)

8062

{

8063

TSHttpTxn txnp = (TSHttpTxn) edata;

8064

ConnectTestData *data = (ConnectTestData *) TSContDataGet(contp);

8065

int request_id = -1;

8066

8067

TSReleaseAssert(data->magic == MAGIC_ALIVE);

8068

TSReleaseAssert((data->test_case == TEST_CASE_CONNECT_ID1) || (data->test_case == TEST_CASE_CONNECT_ID2));

8069

8070

TSDebug(UTDBG_TAG, "Calling cont_test_handler with event %d", event);

8071

8072

switch (event) {

8073

case TS_EVENT_HTTP_READ_REQUEST_HDR:

8074

TSDebug(UTDBG_TAG, "cont_test_handler: event READ_REQUEST");

8075

8076

// First make sure we're getting called for either request 9 or txn 10

8077

// Otherwise, this is a request sent by another test. do nothing.

8078

request_id = get_request_id(txnp);

8079

TSReleaseAssert(request_id != -1);

8080

8081

TSDebug(UTDBG_TAG, "cont_test_handler: Request id = %d", request_id);

8082

8083

if ((request_id != TEST_CASE_CONNECT_ID1) && (request_id != TEST_CASE_CONNECT_ID2)) {

8084

TSDebug(UTDBG_TAG, "This is not an event for this test !");

8085

TSHttpTxnReenable(txnp, TS_EVENT_HTTP_CONTINUE);

8086

goto done;

8087

}

8088

8089

if ((request_id == TEST_CASE_CONNECT_ID1) && (data->test_case == TEST_CASE_CONNECT_ID1)) {

8090

TSDebug(UTDBG_TAG, "Calling TSHttpTxnIntercept");

8091

TSHttpTxnIntercept(data->os->accept_cont, txnp);

8092

} else if ((request_id == TEST_CASE_CONNECT_ID2) && (data->test_case == TEST_CASE_CONNECT_ID2)) {

8093

TSDebug(UTDBG_TAG, "Calling TSHttpTxnServerIntercept");

8094

TSHttpTxnServerIntercept(data->os->accept_cont, txnp);

8095

}

8096

8097

TSHttpTxnReenable(txnp, TS_EVENT_HTTP_CONTINUE);

8098

break;

8099

8100

case TS_EVENT_TIMEOUT:

8101

/* Browser still waiting the response ? */

8102

if (data->browser->status == REQUEST_INPROGRESS) {

8103

TSDebug(UTDBG_TAG, "Browser still waiting response...");

8104

TSContSchedule(contp, 25, TS_THREAD_POOL_DEFAULT);

8105

}

8106

/* Browser got the response */

8107

else {

8108

/* Check if browser response body is the one we expected */

8109

char *body_response = get_body_ptr(data->browser->response);

8110

const char *body_expected;

8111

if (data->test_case == TEST_CASE_CONNECT_ID1) {

8112

body_expected = "Body for response 9";

8113

} else {

8114

body_expected = "Body for response 10";

8115

}

8116

TSDebug(UTDBG_TAG, "Body Response = \n|%s|\nBody Expected = \n|%s|", body_response, body_expected);

8117

8118

if (strncmp(body_response, body_expected, strlen(body_expected)) != 0) {

8119

if (data->test_case == TEST_CASE_CONNECT_ID1) {

8120

SDK_RPRINT(data->test, "TSHttpConnect", "TestCase1", TC_FAIL, "Unexpected response");

8121

SDK_RPRINT(data->test, "TSHttpTxnIntercept", "TestCase1", TC_FAIL, "Unexpected response");

8122

} else {

8123

SDK_RPRINT(data->test, "TSHttpConnect", "TestCase2", TC_FAIL, "Unexpected response");

8124

SDK_RPRINT(data->test, "TSHttpTxnServerIntercept", "TestCase2", TC_FAIL, "Unexpected response");

8125

}

8126

*(data->pstatus) = REGRESSION_TEST_FAILED;

8127

8128

} else {

8129

if (data->test_case == TEST_CASE_CONNECT_ID1) {

8130

SDK_RPRINT(data->test, "TSHttpConnect", "TestCase1", TC_PASS, "ok");

8131

SDK_RPRINT(data->test, "TSHttpTxnIntercept", "TestCase1", TC_PASS, "ok");

8132

} else {

8133

SDK_RPRINT(data->test, "TSHttpConnect", "TestCase2", TC_PASS, "ok");

8134

SDK_RPRINT(data->test, "TSHttpTxnServerIntercept", "TestCase2", TC_PASS, "ok");

8135

}

8136

*(data->pstatus) = REGRESSION_TEST_PASSED;

8137

}

8138

8139

// transaction is over. clean it up.

8140

synclient_txn_delete(data->browser);

8141

synserver_delete(data->os);

8142

8143

// As we registered to a global hook, we may be called back again.

8144

// Do not destroy the continuation...

8145

// data->magic = MAGIC_DEAD;

8146

// TSfree(data);

8147

// TSContDataSet(contp, NULL);

8148

}

8149

break;

8150

8151

default:

8152

*(data->pstatus) = REGRESSION_TEST_FAILED;

8153

SDK_RPRINT(data->test, "TSHttpConnect", "TestCase1 or 2", TC_FAIL, "Unexpected event %d", event);

8154

break;

8155

}

8156

8157

done:

8158

return TS_EVENT_IMMEDIATE;

8159

}

8160

8161

8162

EXCLUSIVE_REGRESSION_TEST(SDK_API_TSHttpConnectIntercept) (RegressionTest * test, int atype, int *pstatus)

8163

{

8164

NOWARN_UNUSED(atype);

8165

*pstatus = REGRESSION_TEST_INPROGRESS;

8166

8167

TSDebug(UTDBG_TAG, "Starting test TSHttpConnectIntercept");

8168

8169

TSCont cont_test = TSContCreate(cont_test_handler, TSMutexCreate());

8170

ConnectTestData *data = (ConnectTestData *) TSmalloc(sizeof(ConnectTestData));

8171

TSContDataSet(cont_test, data);

8172

8173

data->test = test;

8174

data->pstatus = pstatus;

8175

data->magic = MAGIC_ALIVE;

8176

data->test_case = TEST_CASE_CONNECT_ID1;

8177

8178

/* Register to hook READ_REQUEST */

8179

TSHttpHookAdd(TS_HTTP_READ_REQUEST_HDR_HOOK, cont_test);

8180

8181

// Create a synthetic server which won't really listen on a socket port

8182

// It will be called by the Http SM with a VC

8183

data->os = synserver_create(SYNSERVER_DUMMY_PORT);

8184

8185

data->browser = synclient_txn_create();

8186

data->request = generate_request(9);

8187

8188

/* Now send a request to the OS via TS using TSHttpConnect */

8189

8190

/* ip and log do not matter as it is used for logging only */

8191

TSHttpConnect(1, 1, &(data->vc));

8192

8193

synclient_txn_send_request_to_vc(data->browser, data->request, data->vc);

8194

8195

/* Wait until transaction is done */

8196

TSContSchedule(cont_test, 25, TS_THREAD_POOL_DEFAULT);

8197

8198

return;

8199

}

8200

8201

8202

EXCLUSIVE_REGRESSION_TEST(SDK_API_TSHttpConnectServerIntercept) (RegressionTest * test, int atype, int *pstatus)

8203

{

8204

NOWARN_UNUSED(atype);

8205

*pstatus = REGRESSION_TEST_INPROGRESS;

8206

8207

TSDebug(UTDBG_TAG, "Starting test TSHttpConnectServerintercept");

8208

8209

TSCont cont_test = TSContCreate(cont_test_handler, TSMutexCreate());

8210

ConnectTestData *data = (ConnectTestData *) TSmalloc(sizeof(ConnectTestData));

8211

TSContDataSet(cont_test, data);

8212

8213

data->test = test;

8214

data->pstatus = pstatus;

8215

data->magic = MAGIC_ALIVE;

8216

data->test_case = TEST_CASE_CONNECT_ID2;

8217

8218

/* Register to hook READ_REQUEST */

8219

TSHttpHookAdd(TS_HTTP_READ_REQUEST_HDR_HOOK, cont_test);

8220

8221

/* This is cool ! we can use the code written for the synthetic server and client in InkAPITest.cc */

8222

data->os = synserver_create(SYNSERVER_DUMMY_PORT);

8223

8224

data->browser = synclient_txn_create();

8225

data->request = generate_request(10);

8226

8227

/* Now send a request to the OS via TS using TSHttpConnect */

8228

8229

/* ip and log do not matter as it is used for logging only */

8230

TSHttpConnect(2, 2, &(data->vc));

8231

8232

synclient_txn_send_request_to_vc(data->browser, data->request, data->vc);

8233

8234

/* Wait until transaction is done */

8235

TSContSchedule(cont_test, 25, TS_THREAD_POOL_DEFAULT);

8236

8237

return;

8238

}

8239

8240

8241

////////////////////////////////////////////////

8242

// SDK_API_OVERRIDABLE_CONFIGS

8243

8244

// Unit Test for API: TSHttpTxnConfigFind

8245

// TSHttpTxnConfigIntSet

8246

// TSHttpTxnConfigIntGet

8247

// TSHttpTxnConfigFloatSet

8248

// TSHttpTxnConfigFloatGet

8249

// TSHttpTxnConfigStringSet

8250

// TSHttpTxnConfigStringGet

8251

////////////////////////////////////////////////

8252

8253

// The order of these should be the same as TSOverridableConfigKey

8254

const char *SDK_Overridable_Configs[] = {

8255

"proxy.config.url_remap.pristine_host_hdr",

8256

"proxy.config.http.chunking_enabled",

8257

"proxy.config.http.negative_caching_enabled",

8258

"proxy.config.http.negative_caching_lifetime",

8259

"proxy.config.http.cache.when_to_revalidate",

8260

"proxy.config.http.keep_alive_enabled",

8261

"proxy.config.http.keep_alive_post_out",

8262

"proxy.config.net.sock_recv_buffer_size_out",

8263

"proxy.config.net.sock_send_buffer_size_out",

8264

"proxy.config.net.sock_option_flag_out",

8265

"proxy.config.http.anonymize_remove_from",

8266

"proxy.config.http.anonymize_remove_referer",

8267

"proxy.config.http.anonymize_remove_user_agent",

8268

"proxy.config.http.anonymize_remove_cookie",

8269

"proxy.config.http.anonymize_remove_client_ip",

8270

"proxy.config.http.anonymize_insert_client_ip",

8271

"proxy.config.http.append_xforwards_header",

8272

"proxy.config.http.response_server_enabled",

8273

"proxy.config.http.insert_squid_x_forwarded_for",

8274

"proxy.config.http.send_http11_requests",

8275

"proxy.config.http.cache.http",

8276

"proxy.config.http.cache.ignore_client_no_cache",

8277

"proxy.config.http.cache.ignore_client_cc_max_age",

8278

"proxy.config.http.cache.ims_on_client_no_cache",

8279

"proxy.config.http.cache.ignore_server_no_cache",

8280

"proxy.config.http.cache.cache_responses_to_cookies",

8281

"proxy.config.http.cache.ignore_authentication",

8282

"proxy.config.http.cache.cache_urls_that_look_dynamic",

8283

"proxy.config.http.cache.required_headers",

8284

"proxy.config.http.insert_request_via_str",

8285

"proxy.config.http.insert_response_via_str",

8286

"proxy.config.http.cache.heuristic_min_lifetime",

8287

"proxy.config.http.cache.heuristic_max_lifetime",

8288

"proxy.config.http.cache.guaranteed_min_lifetime",

8289

"proxy.config.http.cache.guaranteed_max_lifetime",

8290

"proxy.config.http.cache.max_stale_age",

8291

"proxy.config.http.keep_alive_no_activity_timeout_in",

8292

"proxy.config.http.transaction_no_activity_timeout_in",

8293

"proxy.config.http.transaction_no_activity_timeout_out",

8294

"proxy.config.http.transaction_active_timeout_out",

8295

"proxy.config.http.origin_max_connections",

8296

"proxy.config.http.connect_attempts_max_retries",

8297

"proxy.config.http.connect_attempts_max_retries_dead_server",

8298

"proxy.config.http.connect_attempts_rr_retries",

8299

"proxy.config.http.connect_attempts_timeout",

8300

"proxy.config.http.post_connect_attempts_timeout",

8301

"proxy.config.http.down_server.cache_time",

8302

"proxy.config.http.down_server.abort_threshold",

8303

"proxy.config.http.cache.fuzz.time",

8304

"proxy.config.http.cache.fuzz.min_time",

8305

8306

// These are "special", since they are not MgmtInt's

8307

"proxy.config.http.response_server_str",

8308

"proxy.config.http.cache.heuristic_lm_factor",

8309

"proxy.config.http.cache.fuzz.probability",

8310

8311

NULL

8312

};

8313

8314

REGRESSION_TEST(SDK_API_OVERRIDABLE_CONFIGS) (RegressionTest * test, int atype, int *pstatus)

8315

{

8316

NOWARN_UNUSED(atype);

8317

const char* conf;

8318

TSOverridableConfigKey key;

8319

TSRecordDataType type;

8320

HttpSM* s = HttpSM::allocate();

8321

bool success = true;

8322

TSHttpTxn txnp = static_cast<TSHttpTxn>(s); // Convenience ...

8323

TSMgmtInt ival;

8324

TSMgmtFloat fval;

8325

const char* sval;

8326

const char* test_string = "The Apache Traffic Server";

8327

8328

s->init();

8329

8330

*pstatus = REGRESSION_TEST_INPROGRESS;

8331

for (int i=TS_CONFIG_NULL + 1; i < TS_CONFIG_LAST_ENTRY; ++i) {

8332

conf = SDK_Overridable_Configs[i];

8333

if (TS_SUCCESS == TSHttpTxnConfigFind(conf, -1, &key, &type)) {

8334

if (key != i) {

8335

SDK_RPRINT(test, "TSHttpTxnConfigFind", "TestCase1", TC_FAIL, "Failed on %s, expected %d, got %d", conf, i, key);

8336

success = false;

8337

continue;

8338

}

8339

} else {

8340

SDK_RPRINT(test, "TSHttpTxnConfigFind", "TestCase1", TC_FAIL, "Called returned unexpected TS_ERROR");

8341

success = false;

8342

continue;

8343

}

8344

// Now check the getters / setters

8345

switch (type) {

8346

case TS_RECORDDATATYPE_INT:

8347

TSHttpTxnConfigIntSet(txnp, key, 17);

8348

TSHttpTxnConfigIntGet(txnp, key, &ival);

8349

if (17 != ival) {

8350

SDK_RPRINT(test, "TSHttpTxnConfigIntSet", "TestCase1", TC_FAIL, "Failed on %s, expected 17, got %d", conf, ival);

8351

success = false;

8352

continue;

8353

}

8354

break;

8355

8356

case TS_RECORDDATATYPE_FLOAT:

8357

TSHttpTxnConfigFloatSet(txnp, key, 17.17);

8358

TSHttpTxnConfigFloatGet(txnp, key, &fval);

8359

if (17.17 != fval) {

8360

SDK_RPRINT(test, "TSHttpTxnConfigFloatSet", "TestCase1", TC_FAIL, "Failed on %s, expected 17, got %d", conf, ival);

8361

success = false;

8362

continue;

8363

}

8364

break;

8365

8366

case TS_RECORDDATATYPE_STRING:

8367

TSHttpTxnConfigStringSet(txnp, key, test_string, -1);

8368

TSHttpTxnConfigStringGet(txnp, key, &sval, NULL);

8369

if (test_string != sval) {

8370

SDK_RPRINT(test, "TSHttpTxnConfigStringSet", "TestCase1", TC_FAIL, "Failed on %s, expected 17, got %s", conf, sval);

8371

success = false;

8372

continue;

8373

}

8374

break;

8375

8376

default:

8377

break;

8378

}

8379

}

8380

8381

s->destroy();

8382

if (success) {

8383

*pstatus = REGRESSION_TEST_PASSED;

8384

SDK_RPRINT(test, "TSHttpTxnConfigFind", "TestCase1", TC_PASS, "ok");

8385

SDK_RPRINT(test, "TSHttpTxnConfigIntSet", "TestCase1", TC_PASS, "ok");

8386

SDK_RPRINT(test, "TSHttpTxnConfigFloatSet", "TestCase1", TC_PASS, "ok");

8387

SDK_RPRINT(test, "TSHttpTxnConfigStringSet", "TestCase1", TC_PASS, "ok");

8388

} else {

8389

*pstatus = REGRESSION_TEST_FAILED;

8390

}

8391

8392

return;

8393

}

Older »