You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@trafficserver.apache.org by zw...@apache.org on 2010/11/16 21:22:08 UTC
svn commit: r1035782 [9/29] - in /trafficserver/traffic/trunk:
example/add-header/ example/append-transform/ example/basic-auth/
example/blacklist-0/ example/blacklist-1/ example/bnull-transform/
example/cache_plugin/ example/cache_scan/ example/file-1...
Modified: trafficserver/traffic/trunk/proxy/InkAPITest.cc
URL: http://svn.apache.org/viewvc/trafficserver/traffic/trunk/proxy/InkAPITest.cc?rev=1035782&r1=1035781&r2=1035782&view=diff
==============================================================================
--- trafficserver/traffic/trunk/proxy/InkAPITest.cc (original)
+++ trafficserver/traffic/trunk/proxy/InkAPITest.cc Tue Nov 16 20:22:02 2010
@@ -93,19 +93,19 @@ SDK_RPRINT(RegressionTest * t, const cha
/* Misc */
////////////////////////////////////////////////
-// SDK_API_INKTrafficServerVersionGet
+// SDK_API_TSTrafficServerVersionGet
//
-// Unit Test for API: INKTrafficServerVersionGet
+// Unit Test for API: TSTrafficServerVersionGet
////////////////////////////////////////////////
-REGRESSION_TEST(SDK_API_INKTrafficServerVersionGet) (RegressionTest * test, int atype, int *pstatus)
+REGRESSION_TEST(SDK_API_TSTrafficServerVersionGet) (RegressionTest * test, int atype, int *pstatus)
{
NOWARN_UNUSED(atype);
*pstatus = REGRESSION_TEST_INPROGRESS;
/* Assume the UT runs on TS5.0 and higher */
- const char *ts_version = INKTrafficServerVersionGet();
+ const char *ts_version = TSTrafficServerVersionGet();
if (!ts_version) {
- SDK_RPRINT(test, "INKTrafficServerVersionGet", "TestCase1", TC_FAIL, "can't get traffic server version");
+ SDK_RPRINT(test, "TSTrafficServerVersionGet", "TestCase1", TC_FAIL, "can't get traffic server version");
*pstatus = REGRESSION_TEST_FAILED;
return;
}
@@ -115,45 +115,45 @@ REGRESSION_TEST(SDK_API_INKTrafficServer
int patch_ts_version = 0;
// coverity[secure_coding]
if (sscanf(ts_version, "%d.%d.%d", &major_ts_version, &minor_ts_version, &patch_ts_version) != 3) {
- SDK_RPRINT(test, "INKTrafficServerVersionGet", "TestCase2", TC_FAIL, "traffic server version format is incorrect");
+ SDK_RPRINT(test, "TSTrafficServerVersionGet", "TestCase2", TC_FAIL, "traffic server version format is incorrect");
*pstatus = REGRESSION_TEST_FAILED;
return;
}
if (major_ts_version < 2) {
- SDK_RPRINT(test, "INKTrafficServerVersionGet", "TestCase3", TC_FAIL, "traffic server major version is incorrect");
+ SDK_RPRINT(test, "TSTrafficServerVersionGet", "TestCase3", TC_FAIL, "traffic server major version is incorrect");
*pstatus = REGRESSION_TEST_FAILED;
return;
}
- SDK_RPRINT(test, "INKTrafficServerVersionGet", "TestCase1", TC_PASS, "ok");
+ SDK_RPRINT(test, "TSTrafficServerVersionGet", "TestCase1", TC_PASS, "ok");
*pstatus = REGRESSION_TEST_PASSED;
return;
}
////////////////////////////////////////////////
-// SDK_API_INKPluginDirGet
+// SDK_API_TSPluginDirGet
//
-// Unit Test for API: INKPluginDirGet
-// INKInstallDirGet
+// Unit Test for API: TSPluginDirGet
+// TSInstallDirGet
////////////////////////////////////////////////
-REGRESSION_TEST(SDK_API_INKPluginDirGet) (RegressionTest * test, int atype, int *pstatus)
+REGRESSION_TEST(SDK_API_TSPluginDirGet) (RegressionTest * test, int atype, int *pstatus)
{
NOWARN_UNUSED(atype);
*pstatus = REGRESSION_TEST_INPROGRESS;
- const char *plugin_dir = INKPluginDirGet();
- const char *install_dir = INKInstallDirGet();
+ const char *plugin_dir = TSPluginDirGet();
+ const char *install_dir = TSInstallDirGet();
if (!plugin_dir) {
- SDK_RPRINT(test, "INKPluginDirGet", "TestCase1", TC_FAIL, "can't get plugin dir");
+ SDK_RPRINT(test, "TSPluginDirGet", "TestCase1", TC_FAIL, "can't get plugin dir");
*pstatus = REGRESSION_TEST_FAILED;
return;
}
if (!install_dir) {
- SDK_RPRINT(test, "INKInstallDirGet", "TestCase1", TC_FAIL, "can't get installation dir");
+ SDK_RPRINT(test, "TSInstallDirGet", "TestCase1", TC_FAIL, "can't get installation dir");
*pstatus = REGRESSION_TEST_FAILED;
return;
}
@@ -162,32 +162,32 @@ REGRESSION_TEST(SDK_API_INKPluginDirGet)
// since the location can be anywhere
//
if (strstr(plugin_dir, "libexec/trafficserver") == NULL) {
- SDK_RPRINT(test, "INKPluginDirGet", "TestCase2", TC_FAIL, "plugin dir(%s) is incorrect, expected (%s) in path",plugin_dir,"libexec/trafficserver");
+ SDK_RPRINT(test, "TSPluginDirGet", "TestCase2", TC_FAIL, "plugin dir(%s) is incorrect, expected (%s) in path",plugin_dir,"libexec/trafficserver");
*pstatus = REGRESSION_TEST_FAILED;
return;
}
if (strstr(plugin_dir, install_dir) == NULL) {
- SDK_RPRINT(test, "INKInstallDirGet", "TestCase2", TC_FAIL, "install dir is incorrect");
+ SDK_RPRINT(test, "TSInstallDirGet", "TestCase2", TC_FAIL, "install dir is incorrect");
*pstatus = REGRESSION_TEST_FAILED;
return;
}
- SDK_RPRINT(test, "INKPluginDirGet", "TestCase1", TC_PASS, "ok");
- SDK_RPRINT(test, "INKInstallDirGet", "TestCase1", TC_PASS, "ok");
+ SDK_RPRINT(test, "TSPluginDirGet", "TestCase1", TC_PASS, "ok");
+ SDK_RPRINT(test, "TSInstallDirGet", "TestCase1", TC_PASS, "ok");
*pstatus = REGRESSION_TEST_PASSED;
return;
}
-/* INKConfig */
+/* TSConfig */
////////////////////////////////////////////////
-// SDK_API_INKConfig
+// SDK_API_TSConfig
//
-// Unit Test for API: INKConfigSet
-// INKConfigGet
-// INKConfigRelease
-// INKConfigDataGet
+// Unit Test for API: TSConfigSet
+// TSConfigGet
+// TSConfigRelease
+// TSConfigDataGet
////////////////////////////////////////////////
static int my_config_id = -1;
typedef struct
@@ -200,55 +200,55 @@ static void
config_destroy_func(void *data)
{
ConfigData *config = (ConfigData *) data;
- INKfree(config);
+ TSfree(config);
return;
}
-REGRESSION_TEST(SDK_API_INKConfig) (RegressionTest * test, int atype, int *pstatus)
+REGRESSION_TEST(SDK_API_TSConfig) (RegressionTest * test, int atype, int *pstatus)
{
NOWARN_UNUSED(atype);
*pstatus = REGRESSION_TEST_INPROGRESS;
- ConfigData *config = (ConfigData *) INKmalloc(sizeof(ConfigData));
+ ConfigData *config = (ConfigData *) TSmalloc(sizeof(ConfigData));
config->a = "unit";
config->b = "test";
- my_config_id = INKConfigSet(0, config, config_destroy_func);
+ my_config_id = TSConfigSet(0, config, config_destroy_func);
- INKConfig test_config = NULL;
- test_config = INKConfigGet(my_config_id);
+ TSConfig test_config = NULL;
+ test_config = TSConfigGet(my_config_id);
if (!test_config) {
- SDK_RPRINT(test, "INKConfigSet", "TestCase1", TC_FAIL, "can't correctly set global config structure");
- SDK_RPRINT(test, "INKConfigGet", "TestCase1", TC_FAIL, "can't correctly get global config structure");
- INKConfigRelease(my_config_id, config);
+ SDK_RPRINT(test, "TSConfigSet", "TestCase1", TC_FAIL, "can't correctly set global config structure");
+ SDK_RPRINT(test, "TSConfigGet", "TestCase1", TC_FAIL, "can't correctly get global config structure");
+ TSConfigRelease(my_config_id, config);
*pstatus = REGRESSION_TEST_FAILED;
return;
}
- if (INKConfigDataGet(test_config) != config) {
- SDK_RPRINT(test, "INKConfigDataGet", "TestCase1", TC_FAIL, "failed to get config data");
- INKConfigRelease(my_config_id, config);
+ if (TSConfigDataGet(test_config) != config) {
+ SDK_RPRINT(test, "TSConfigDataGet", "TestCase1", TC_FAIL, "failed to get config data");
+ TSConfigRelease(my_config_id, config);
*pstatus = REGRESSION_TEST_FAILED;
return;
}
- SDK_RPRINT(test, "INKConfigGet", "TestCase1", TC_PASS, "ok");
- SDK_RPRINT(test, "INKConfigSet", "TestCase1", TC_PASS, "ok");
- SDK_RPRINT(test, "INKConfigDataGet", "TestCase1", TC_PASS, "ok");
+ SDK_RPRINT(test, "TSConfigGet", "TestCase1", TC_PASS, "ok");
+ SDK_RPRINT(test, "TSConfigSet", "TestCase1", TC_PASS, "ok");
+ SDK_RPRINT(test, "TSConfigDataGet", "TestCase1", TC_PASS, "ok");
- INKConfigRelease(my_config_id, config);
+ TSConfigRelease(my_config_id, config);
*pstatus = REGRESSION_TEST_PASSED;
return;
}
-/* INKNetVConn */
+/* TSNetVConn */
//////////////////////////////////////////////
-// SDK_API_INKNetVConn
+// SDK_API_TSNetVConn
//
-// Unit Test for API: INKNetVConnRemoteIPGet
-// INKNetVConnRemotePortGet
-// INKNetAccept
-// INKNetConnect
+// Unit Test for API: TSNetVConnRemoteIPGet
+// TSNetVConnRemotePortGet
+// TSNetAccept
+// TSNetConnect
//////////////////////////////////////////////
#define IP(a,b,c,d) htonl((a) << 24 | (b) << 16 | (c) << 8 | (d))
const unsigned short server_port = 12345;
@@ -256,117 +256,117 @@ RegressionTest *SDK_NetVConn_test;
int *SDK_NetVConn_pstatus;
int
-server_handler(INKCont contp, INKEvent event, void *data)
+server_handler(TSCont contp, TSEvent event, void *data)
{
NOWARN_UNUSED(data);
- if (event == INK_EVENT_VCONN_EOS)
- INKContDestroy(contp);
+ if (event == TS_EVENT_VCONN_EOS)
+ TSContDestroy(contp);
return 1;
}
int
-client_handler(INKCont contp, INKEvent event, void *data)
+client_handler(TSCont contp, TSEvent event, void *data)
{
- if (event == INK_EVENT_NET_CONNECT_FAILED) {
- SDK_RPRINT(SDK_NetVConn_test, "INKNetAccept", "TestCase1", TC_FAIL, "can't connect to server");
- SDK_RPRINT(SDK_NetVConn_test, "INKNetConnect", "TestCase1", TC_FAIL, "can't connect to server");
+ if (event == TS_EVENT_NET_CONNECT_FAILED) {
+ SDK_RPRINT(SDK_NetVConn_test, "TSNetAccept", "TestCase1", TC_FAIL, "can't connect to server");
+ SDK_RPRINT(SDK_NetVConn_test, "TSNetConnect", "TestCase1", TC_FAIL, "can't connect to server");
// no need to continue, return
- INKContDestroy(contp);
+ TSContDestroy(contp);
// Fix me: how to deal with server side cont?
*SDK_NetVConn_pstatus = REGRESSION_TEST_FAILED;
return 1;
} else {
- SDK_RPRINT(SDK_NetVConn_test, "INKNetAccept", "TestCase1", TC_PASS, "ok");
- SDK_RPRINT(SDK_NetVConn_test, "INKNetConnect", "TestCase1", TC_PASS, "ok");
+ SDK_RPRINT(SDK_NetVConn_test, "TSNetAccept", "TestCase1", TC_PASS, "ok");
+ SDK_RPRINT(SDK_NetVConn_test, "TSNetConnect", "TestCase1", TC_PASS, "ok");
unsigned int input_server_ip = 0;
int input_server_port = 0;
- INKNetVConnRemoteIPGet((INKVConn) data, &input_server_ip);
- INKNetVConnRemotePortGet((INKVConn) data, &input_server_port);
+ TSNetVConnRemoteIPGet((TSVConn) data, &input_server_ip);
+ TSNetVConnRemotePortGet((TSVConn) data, &input_server_port);
if (input_server_ip != htonl(LOCAL_IP)) {
- SDK_RPRINT(SDK_NetVConn_test, "INKNetVConnRemoteIPGet", "TestCase1", TC_FAIL, "server ip is incorrect");
+ SDK_RPRINT(SDK_NetVConn_test, "TSNetVConnRemoteIPGet", "TestCase1", TC_FAIL, "server ip is incorrect");
- INKContDestroy(contp);
+ TSContDestroy(contp);
// Fix me: how to deal with server side cont?
*SDK_NetVConn_pstatus = REGRESSION_TEST_FAILED;
return 1;
} else
- SDK_RPRINT(SDK_NetVConn_test, "INKNetVConnRemoteIPGet", "TestCase1", TC_PASS, "ok");
+ SDK_RPRINT(SDK_NetVConn_test, "TSNetVConnRemoteIPGet", "TestCase1", TC_PASS, "ok");
if (input_server_port != server_port) {
- SDK_RPRINT(SDK_NetVConn_test, "INKNetVConnRemotePortGet", "TestCase1", TC_FAIL, "server port is incorrect");
+ SDK_RPRINT(SDK_NetVConn_test, "TSNetVConnRemotePortGet", "TestCase1", TC_FAIL, "server port is incorrect");
- INKContDestroy(contp);
+ TSContDestroy(contp);
// Fix me: how to deal with server side cont?
*SDK_NetVConn_pstatus = REGRESSION_TEST_FAILED;
return 1;
} else
- SDK_RPRINT(SDK_NetVConn_test, "INKNetVConnRemotePortGet", "TestCase1", TC_PASS, "ok");
+ SDK_RPRINT(SDK_NetVConn_test, "TSNetVConnRemotePortGet", "TestCase1", TC_PASS, "ok");
- INKVConnClose((INKVConn) data);
+ TSVConnClose((TSVConn) data);
}
- INKContDestroy(contp);
+ TSContDestroy(contp);
*SDK_NetVConn_pstatus = REGRESSION_TEST_PASSED;
return 1;
}
-REGRESSION_TEST(SDK_API_INKNetVConn) (RegressionTest * test, int atype, int *pstatus)
+REGRESSION_TEST(SDK_API_TSNetVConn) (RegressionTest * test, int atype, int *pstatus)
{
NOWARN_UNUSED(atype);
*pstatus = REGRESSION_TEST_INPROGRESS;
SDK_NetVConn_test = test;
SDK_NetVConn_pstatus = pstatus;
- INKMutex server_mutex = INKMutexCreate();
- INKMutex client_mutex = INKMutexCreate();
+ TSMutex server_mutex = TSMutexCreate();
+ TSMutex client_mutex = TSMutexCreate();
- INKCont server_cont = INKContCreate(server_handler, server_mutex);
- INKCont client_cont = INKContCreate(client_handler, client_mutex);
+ TSCont server_cont = TSContCreate(server_handler, server_mutex);
+ TSCont client_cont = TSContCreate(client_handler, client_mutex);
- INKNetAccept(server_cont, server_port);
+ TSNetAccept(server_cont, server_port);
unsigned int server_ip = IP(127, 0, 0, 1);
- INKNetConnect(client_cont, server_ip, server_port);
+ TSNetConnect(client_cont, server_ip, server_port);
}
-/* INKCache, INKVConn, INKVIO */
+/* TSCache, TSVConn, TSVIO */
//////////////////////////////////////////////
-// SDK_API_INKCache
+// SDK_API_TSCache
//
-// Unit Test for API: INKCacheReady
-// INKCacheWrite
-// INKCacheRead
-// INKCacheKeyCreate
-// INKCacheKeyDigestSet
-// INKVConnCacheObjectSizeGet
-// INKVConnClose
-// INKVConnClosedGet
-// INKVConnRead
-// INKVConnReadVIOGet
-// INKVConnWrite
-// INKVConnWriteVIOGet
-// INKVIOBufferGet
-// INKVIOContGet
-// INKVIOMutexGet
-// INKVIONBytesGet
-// INKVIONBytesSet
-// INKVIONDoneGet
-// INKVIONDoneSet
-// INKVIONTodoGet
-// INKVIOReaderGet
-// INKVIOReenable
-// INKVIOVConnGet
-//////////////////////////////////////////////
-
-// INKVConnAbort can't be tested
-// Fix me: test INKVConnShutdown, INKCacheKeyDataTypeSet,
-// INKCacheKeyHostNameSet, INKCacheKeyPinnedSet
+// Unit Test for API: TSCacheReady
+// TSCacheWrite
+// TSCacheRead
+// TSCacheKeyCreate
+// TSCacheKeyDigestSet
+// TSVConnCacheObjectSizeGet
+// TSVConnClose
+// TSVConnClosedGet
+// TSVConnRead
+// TSVConnReadVIOGet
+// TSVConnWrite
+// TSVConnWriteVIOGet
+// TSVIOBufferGet
+// TSVIOContGet
+// TSVIOMutexGet
+// TSVIONBytesGet
+// TSVIONBytesSet
+// TSVIONDoneGet
+// TSVIONDoneSet
+// TSVIONTodoGet
+// TSVIOReaderGet
+// TSVIOReenable
+// TSVIOVConnGet
+//////////////////////////////////////////////
+
+// TSVConnAbort can't be tested
+// Fix me: test TSVConnShutdown, TSCacheKeyDataTypeSet,
+// TSCacheKeyHostNameSet, TSCacheKeyPinnedSet
// Logic of the test:
// - write OBJECT_SIZE bytes in the cache in 3 shots
@@ -386,162 +386,162 @@ static int read_counter = 0;
typedef struct
{
- INKIOBuffer bufp;
- INKIOBuffer out_bufp;
- INKIOBufferReader readerp;
- INKIOBufferReader out_readerp;
-
- INKVConn write_vconnp;
- INKVConn read_vconnp;
- INKVIO read_vio;
- INKVIO write_vio;
+ TSIOBuffer bufp;
+ TSIOBuffer out_bufp;
+ TSIOBufferReader readerp;
+ TSIOBufferReader out_readerp;
+
+ TSVConn write_vconnp;
+ TSVConn read_vconnp;
+ TSVIO read_vio;
+ TSVIO write_vio;
- INKCacheKey key;
+ TSCacheKey key;
} CacheVConnStruct;
int
-cache_handler(INKCont contp, INKEvent event, void *data)
+cache_handler(TSCont contp, TSEvent event, void *data)
{
Debug("sdk_ut_cache_write", "Event %d data %p", event, data);
- CacheVConnStruct *cache_vconn = (CacheVConnStruct *) INKContDataGet(contp);
+ CacheVConnStruct *cache_vconn = (CacheVConnStruct *) TSContDataGet(contp);
- INKIOBufferBlock blockp;
+ TSIOBufferBlock blockp;
char *ptr_block;
int64 ntodo, ndone, nbytes, towrite, avail, content_length;
switch (event) {
- case INK_EVENT_CACHE_OPEN_WRITE:
- Debug(UTDBG_TAG "_cache_event", "INK_EVENT_CACHE_OPEN_WRITE %d %p", event, data);
- SDK_RPRINT(SDK_Cache_test, "INKCacheWrite", "TestCase1", TC_PASS, "ok");
+ case TS_EVENT_CACHE_OPEN_WRITE:
+ Debug(UTDBG_TAG "_cache_event", "TS_EVENT_CACHE_OPEN_WRITE %d %p", event, data);
+ SDK_RPRINT(SDK_Cache_test, "TSCacheWrite", "TestCase1", TC_PASS, "ok");
// data is write_vc
- cache_vconn->write_vconnp = (INKVConn) data;
+ cache_vconn->write_vconnp = (TSVConn) data;
// Create buffers/readers to write and read data into the cache
- cache_vconn->bufp = INKIOBufferCreate();
- cache_vconn->readerp = INKIOBufferReaderAlloc(cache_vconn->bufp);
- cache_vconn->out_bufp = INKIOBufferCreate();
- cache_vconn->out_readerp = INKIOBufferReaderAlloc(cache_vconn->out_bufp);
+ cache_vconn->bufp = TSIOBufferCreate();
+ cache_vconn->readerp = TSIOBufferReaderAlloc(cache_vconn->bufp);
+ cache_vconn->out_bufp = TSIOBufferCreate();
+ cache_vconn->out_readerp = TSIOBufferReaderAlloc(cache_vconn->out_bufp);
// Write content into upstream IOBuffer
ntodo = OBJECT_SIZE;
ndone = 0;
while (ntodo > 0) {
- blockp = INKIOBufferStart(cache_vconn->bufp);
- ptr_block = INKIOBufferBlockWriteStart(blockp, &avail);
+ blockp = TSIOBufferStart(cache_vconn->bufp);
+ ptr_block = TSIOBufferBlockWriteStart(blockp, &avail);
towrite = ((ntodo < avail) ? ntodo : avail);
memcpy(ptr_block, content + ndone, towrite);
- INKIOBufferProduce(cache_vconn->bufp, towrite);
+ TSIOBufferProduce(cache_vconn->bufp, towrite);
ntodo -= towrite;
ndone += towrite;
}
- // first write half of the data. To test INKVIOReenable
- cache_vconn->write_vio = INKVConnWrite((INKVConn) data, contp, cache_vconn->readerp, OBJECT_SIZE / 2);
+ // first write half of the data. To test TSVIOReenable
+ cache_vconn->write_vio = TSVConnWrite((TSVConn) data, contp, cache_vconn->readerp, OBJECT_SIZE / 2);
return 1;
- case INK_EVENT_CACHE_OPEN_WRITE_FAILED:
- Debug(UTDBG_TAG "_cache_event", "INK_EVENT_CACHE_OPEN_WRITE_FAILED %d %p", event, data);
- SDK_RPRINT(SDK_Cache_test, "INKCacheWrite", "TestCase1", TC_FAIL, "can't open cache vc, edtata = %p", data);
- INKReleaseAssert(!"cache");
+ case TS_EVENT_CACHE_OPEN_WRITE_FAILED:
+ Debug(UTDBG_TAG "_cache_event", "TS_EVENT_CACHE_OPEN_WRITE_FAILED %d %p", event, data);
+ SDK_RPRINT(SDK_Cache_test, "TSCacheWrite", "TestCase1", TC_FAIL, "can't open cache vc, edtata = %p", data);
+ TSReleaseAssert(!"cache");
// no need to continue, return
*SDK_Cache_pstatus = REGRESSION_TEST_FAILED;
return 1;
- case INK_EVENT_CACHE_OPEN_READ:
- Debug(UTDBG_TAG "_cache_event", "INK_EVENT_CACHE_OPEN_READ %d %p", event, data);
+ case TS_EVENT_CACHE_OPEN_READ:
+ Debug(UTDBG_TAG "_cache_event", "TS_EVENT_CACHE_OPEN_READ %d %p", event, data);
if (read_counter == 2) {
- SDK_RPRINT(SDK_Cache_test, "INKCacheRead", "TestCase2", TC_FAIL, "shouldn't open cache vc");
+ SDK_RPRINT(SDK_Cache_test, "TSCacheRead", "TestCase2", TC_FAIL, "shouldn't open cache vc");
// no need to continue, return
*SDK_Cache_pstatus = REGRESSION_TEST_FAILED;
return 1;
}
- SDK_RPRINT(SDK_Cache_test, "INKCacheRead", "TestCase1", TC_PASS, "ok");
+ SDK_RPRINT(SDK_Cache_test, "TSCacheRead", "TestCase1", TC_PASS, "ok");
- cache_vconn->read_vconnp = (INKVConn) data;
- INKVConnCacheObjectSizeGet(cache_vconn->read_vconnp, &content_length);
+ cache_vconn->read_vconnp = (TSVConn) data;
+ TSVConnCacheObjectSizeGet(cache_vconn->read_vconnp, &content_length);
Debug(UTDBG_TAG "_cache_read", "In cache open read [Content-Length: %d]", content_length);
if (content_length != OBJECT_SIZE) {
- SDK_RPRINT(SDK_Cache_test, "INKVConnCacheObjectSizeGet", "TestCase1", TC_FAIL, "cached data size is incorrect");
+ SDK_RPRINT(SDK_Cache_test, "TSVConnCacheObjectSizeGet", "TestCase1", TC_FAIL, "cached data size is incorrect");
// no need to continue, return
*SDK_Cache_pstatus = REGRESSION_TEST_FAILED;
return 1;
} else {
- SDK_RPRINT(SDK_Cache_test, "INKVConnCacheObjectSizeGet", "TestCase1", TC_PASS, "ok");
- cache_vconn->read_vio = INKVConnRead((INKVConn) data, contp, cache_vconn->out_bufp, content_length);
+ SDK_RPRINT(SDK_Cache_test, "TSVConnCacheObjectSizeGet", "TestCase1", TC_PASS, "ok");
+ cache_vconn->read_vio = TSVConnRead((TSVConn) data, contp, cache_vconn->out_bufp, content_length);
}
return 1;
- case INK_EVENT_CACHE_OPEN_READ_FAILED:
- Debug(UTDBG_TAG "_cache_event", "INK_EVENT_CACHE_OPEN_READ_FAILED %d %p", event, data);
+ case TS_EVENT_CACHE_OPEN_READ_FAILED:
+ Debug(UTDBG_TAG "_cache_event", "TS_EVENT_CACHE_OPEN_READ_FAILED %d %p", event, data);
if (read_counter == 1) {
- SDK_RPRINT(SDK_Cache_test, "INKCacheRead", "TestCase1", TC_FAIL, "can't open cache vc");
+ SDK_RPRINT(SDK_Cache_test, "TSCacheRead", "TestCase1", TC_FAIL, "can't open cache vc");
// no need to continue, return
*SDK_Cache_pstatus = REGRESSION_TEST_FAILED;
return 1;
}
- SDK_RPRINT(SDK_Cache_test, "INKCacheRead", "TestCase2", TC_PASS, "ok");
+ SDK_RPRINT(SDK_Cache_test, "TSCacheRead", "TestCase2", TC_PASS, "ok");
// ok, all tests passed!
break;
- case INK_EVENT_CACHE_REMOVE:
- Debug(UTDBG_TAG "_cache_event", "INK_EVENT_CACHE_REMOVE %d %p", event, data);
- SDK_RPRINT(SDK_Cache_test, "INKCacheRemove", "TestCase1", TC_PASS, "ok");
+ case TS_EVENT_CACHE_REMOVE:
+ Debug(UTDBG_TAG "_cache_event", "TS_EVENT_CACHE_REMOVE %d %p", event, data);
+ SDK_RPRINT(SDK_Cache_test, "TSCacheRemove", "TestCase1", TC_PASS, "ok");
// read the data which has been removed
read_counter++;
- INKCacheRead(contp, cache_vconn->key);
+ TSCacheRead(contp, cache_vconn->key);
return 1;
- case INK_EVENT_CACHE_REMOVE_FAILED:
- Debug(UTDBG_TAG "_cache_event", "INK_EVENT_CACHE_REMOVE_FAILED %d %p", event, data);
- SDK_RPRINT(SDK_Cache_test, "INKCacheRemove", "TestCase1", TC_FAIL, "can't remove cached item");
+ case TS_EVENT_CACHE_REMOVE_FAILED:
+ Debug(UTDBG_TAG "_cache_event", "TS_EVENT_CACHE_REMOVE_FAILED %d %p", event, data);
+ SDK_RPRINT(SDK_Cache_test, "TSCacheRemove", "TestCase1", TC_FAIL, "can't remove cached item");
// no need to continue, return
*SDK_Cache_pstatus = REGRESSION_TEST_FAILED;
return 1;
- case INK_EVENT_VCONN_WRITE_COMPLETE:
- Debug(UTDBG_TAG "_cache_event", "INK_EVENT_VCONN_WRITE_COMPLETE %d %p", event, data);
+ case TS_EVENT_VCONN_WRITE_COMPLETE:
+ Debug(UTDBG_TAG "_cache_event", "TS_EVENT_VCONN_WRITE_COMPLETE %d %p", event, data);
// VConn/VIO APIs
- nbytes = INKVIONBytesGet(cache_vconn->write_vio);
- ndone = INKVIONDoneGet(cache_vconn->write_vio);
- ntodo = INKVIONTodoGet(cache_vconn->write_vio);
+ nbytes = TSVIONBytesGet(cache_vconn->write_vio);
+ ndone = TSVIONDoneGet(cache_vconn->write_vio);
+ ntodo = TSVIONTodoGet(cache_vconn->write_vio);
Debug(UTDBG_TAG "_cache_write", "Nbytes=%d Ndone=%d Ntodo=%d", nbytes, ndone, ntodo);
if (ndone == (OBJECT_SIZE / 2)) {
- INKVIONBytesSet(cache_vconn->write_vio, (OBJECT_SIZE - 100));
- INKVIOReenable(cache_vconn->write_vio);
+ TSVIONBytesSet(cache_vconn->write_vio, (OBJECT_SIZE - 100));
+ TSVIOReenable(cache_vconn->write_vio);
Debug(UTDBG_TAG "_cache_write", "Increment write_counter in write_complete [a]");
return 1;
} else if (ndone == (OBJECT_SIZE - 100)) {
- INKVIONBytesSet(cache_vconn->write_vio, OBJECT_SIZE);
- INKVIOReenable(cache_vconn->write_vio);
+ TSVIONBytesSet(cache_vconn->write_vio, OBJECT_SIZE);
+ TSVIOReenable(cache_vconn->write_vio);
Debug(UTDBG_TAG "_cache_write", "Increment write_counter in write_complete [b]");
return 1;
} else if (ndone == OBJECT_SIZE) {
Debug(UTDBG_TAG "_cache_write", "finishing up [c]");
- SDK_RPRINT(SDK_Cache_test, "INKVIOReenable", "TestCase2", TC_PASS, "ok");
- SDK_RPRINT(SDK_Cache_test, "INKVIONBytesSet", "TestCase1", TC_PASS, "ok");
- SDK_RPRINT(SDK_Cache_test, "INKVConnWrite", "TestCase1", TC_PASS, "ok");
+ SDK_RPRINT(SDK_Cache_test, "TSVIOReenable", "TestCase2", TC_PASS, "ok");
+ SDK_RPRINT(SDK_Cache_test, "TSVIONBytesSet", "TestCase1", TC_PASS, "ok");
+ SDK_RPRINT(SDK_Cache_test, "TSVConnWrite", "TestCase1", TC_PASS, "ok");
} else {
- SDK_RPRINT(SDK_Cache_test, "INKCacheWrite", "TestCase1", TC_FAIL, "Did not write expected # of bytes");
+ SDK_RPRINT(SDK_Cache_test, "TSCacheWrite", "TestCase1", TC_FAIL, "Did not write expected # of bytes");
// no need to continue, return
*SDK_Cache_pstatus = REGRESSION_TEST_FAILED;
return 1;
}
- if ((INKVIO) data != cache_vconn->write_vio) {
- SDK_RPRINT(SDK_Cache_test, "INKVConnWrite", "TestCase1", TC_FAIL, "write_vio corrupted");
+ if ((TSVIO) data != cache_vconn->write_vio) {
+ SDK_RPRINT(SDK_Cache_test, "TSVConnWrite", "TestCase1", TC_FAIL, "write_vio corrupted");
// no need to continue, return
*SDK_Cache_pstatus = REGRESSION_TEST_FAILED;
return 1;
@@ -549,52 +549,52 @@ cache_handler(INKCont contp, INKEvent ev
Debug(UTDBG_TAG "_cache_write", "finishing up [d]");
- if (INKVIOBufferGet(cache_vconn->write_vio) != cache_vconn->bufp) {
- SDK_RPRINT(SDK_Cache_test, "INKVIOBufferGet", "TestCase1", TC_FAIL, "write_vio corrupted");
+ if (TSVIOBufferGet(cache_vconn->write_vio) != cache_vconn->bufp) {
+ SDK_RPRINT(SDK_Cache_test, "TSVIOBufferGet", "TestCase1", TC_FAIL, "write_vio corrupted");
*SDK_Cache_pstatus = REGRESSION_TEST_FAILED;
return 1;
} else {
- SDK_RPRINT(SDK_Cache_test, "INKVIOBufferGet", "TestCase1", TC_PASS, "ok");
+ SDK_RPRINT(SDK_Cache_test, "TSVIOBufferGet", "TestCase1", TC_PASS, "ok");
}
- if (INKVIOContGet(cache_vconn->write_vio) != contp) {
- SDK_RPRINT(SDK_Cache_test, "INKVIOContGet", "TestCase1", TC_FAIL, "write_vio corrupted");
+ if (TSVIOContGet(cache_vconn->write_vio) != contp) {
+ SDK_RPRINT(SDK_Cache_test, "TSVIOContGet", "TestCase1", TC_FAIL, "write_vio corrupted");
*SDK_Cache_pstatus = REGRESSION_TEST_FAILED;
return 1;
} else {
- SDK_RPRINT(SDK_Cache_test, "INKVIOContGet", "TestCase1", TC_PASS, "ok");
+ SDK_RPRINT(SDK_Cache_test, "TSVIOContGet", "TestCase1", TC_PASS, "ok");
}
Debug(UTDBG_TAG "_cache_write", "finishing up [f]");
- if (INKVIOMutexGet(cache_vconn->write_vio) != INKContMutexGet(contp)) {
- SDK_RPRINT(SDK_Cache_test, "INKVIOMutexGet", "TestCase1", TC_FAIL, "write_vio corrupted");
+ if (TSVIOMutexGet(cache_vconn->write_vio) != TSContMutexGet(contp)) {
+ SDK_RPRINT(SDK_Cache_test, "TSVIOMutexGet", "TestCase1", TC_FAIL, "write_vio corrupted");
*SDK_Cache_pstatus = REGRESSION_TEST_FAILED;
return 1;
} else {
- SDK_RPRINT(SDK_Cache_test, "INKVIOMutexGet", "TestCase1", TC_PASS, "ok");
+ SDK_RPRINT(SDK_Cache_test, "TSVIOMutexGet", "TestCase1", TC_PASS, "ok");
}
- if (INKVIOVConnGet(cache_vconn->write_vio) != cache_vconn->write_vconnp) {
- SDK_RPRINT(SDK_Cache_test, "INKVIOVConnGet", "TestCase1", TC_FAIL, "write_vio corrupted");
+ if (TSVIOVConnGet(cache_vconn->write_vio) != cache_vconn->write_vconnp) {
+ SDK_RPRINT(SDK_Cache_test, "TSVIOVConnGet", "TestCase1", TC_FAIL, "write_vio corrupted");
*SDK_Cache_pstatus = REGRESSION_TEST_FAILED;
return 1;
} else {
- SDK_RPRINT(SDK_Cache_test, "INKVIOVConnGet", "TestCase1", TC_PASS, "ok");
+ SDK_RPRINT(SDK_Cache_test, "TSVIOVConnGet", "TestCase1", TC_PASS, "ok");
}
Debug(UTDBG_TAG "_cache_write", "finishing up [g]");
- if (INKVIOReaderGet(cache_vconn->write_vio) != cache_vconn->readerp) {
- SDK_RPRINT(SDK_Cache_test, "INKVIOReaderGet", "TestCase1", TC_FAIL, "write_vio corrupted");
+ if (TSVIOReaderGet(cache_vconn->write_vio) != cache_vconn->readerp) {
+ SDK_RPRINT(SDK_Cache_test, "TSVIOReaderGet", "TestCase1", TC_FAIL, "write_vio corrupted");
*SDK_Cache_pstatus = REGRESSION_TEST_FAILED;
return 1;
} else {
- SDK_RPRINT(SDK_Cache_test, "INKVIOReaderGet", "TestCase1", TC_PASS, "ok");
+ SDK_RPRINT(SDK_Cache_test, "TSVIOReaderGet", "TestCase1", TC_PASS, "ok");
}
// tests for write is done, close write_vconnp
- INKVConnClose(cache_vconn->write_vconnp);
+ TSVConnClose(cache_vconn->write_vconnp);
cache_vconn->write_vconnp = NULL;
Debug(UTDBG_TAG "_cache_write", "finishing up [h]");
@@ -602,136 +602,136 @@ cache_handler(INKCont contp, INKEvent ev
// start to read data out of cache
read_counter++;
- INKCacheRead(contp, cache_vconn->key);
+ TSCacheRead(contp, cache_vconn->key);
Debug(UTDBG_TAG "_cache_read", "starting read [i]");
return 1;
- case INK_EVENT_VCONN_WRITE_READY:
- Debug(UTDBG_TAG "_cache_event", "INK_EVENT_VCONN_WRITE_READY %d %p", event, data);
- if ((INKVIO) data != cache_vconn->write_vio) {
- SDK_RPRINT(SDK_Cache_test, "INKVConnWrite", "TestCase1", TC_FAIL, "write_vio corrupted");
+ case TS_EVENT_VCONN_WRITE_READY:
+ Debug(UTDBG_TAG "_cache_event", "TS_EVENT_VCONN_WRITE_READY %d %p", event, data);
+ if ((TSVIO) data != cache_vconn->write_vio) {
+ SDK_RPRINT(SDK_Cache_test, "TSVConnWrite", "TestCase1", TC_FAIL, "write_vio corrupted");
*SDK_Cache_pstatus = REGRESSION_TEST_FAILED;
return 1;
}
- nbytes = INKVIONBytesGet(cache_vconn->write_vio);
- ndone = INKVIONDoneGet(cache_vconn->write_vio);
- ntodo = INKVIONTodoGet(cache_vconn->write_vio);
+ nbytes = TSVIONBytesGet(cache_vconn->write_vio);
+ ndone = TSVIONDoneGet(cache_vconn->write_vio);
+ ntodo = TSVIONTodoGet(cache_vconn->write_vio);
Debug(UTDBG_TAG "_cache_write", "Nbytes=%d Ndone=%d Ntodo=%d", nbytes, ndone, ntodo);
- INKVIOReenable(cache_vconn->write_vio);
+ TSVIOReenable(cache_vconn->write_vio);
return 1;
- case INK_EVENT_VCONN_READ_COMPLETE:
- Debug(UTDBG_TAG "_cache_event", "INK_EVENT_VCONN_READ_COMPLETE %d %p", event, data);
- if ((INKVIO) data != cache_vconn->read_vio) {
- SDK_RPRINT(SDK_Cache_test, "INKVConnRead", "TestCase1", TC_FAIL, "read_vio corrupted");
+ case TS_EVENT_VCONN_READ_COMPLETE:
+ Debug(UTDBG_TAG "_cache_event", "TS_EVENT_VCONN_READ_COMPLETE %d %p", event, data);
+ if ((TSVIO) data != cache_vconn->read_vio) {
+ SDK_RPRINT(SDK_Cache_test, "TSVConnRead", "TestCase1", TC_FAIL, "read_vio corrupted");
// no need to continue, return
*SDK_Cache_pstatus = REGRESSION_TEST_FAILED;
return 1;
}
- nbytes = INKVIONBytesGet(cache_vconn->read_vio);
- ntodo = INKVIONTodoGet(cache_vconn->read_vio);
- ndone = INKVIONDoneGet(cache_vconn->read_vio);
+ nbytes = TSVIONBytesGet(cache_vconn->read_vio);
+ ntodo = TSVIONTodoGet(cache_vconn->read_vio);
+ ndone = TSVIONDoneGet(cache_vconn->read_vio);
Debug(UTDBG_TAG "_cache_read", "Nbytes=%d Ndone=%d Ntodo=%d", nbytes, ndone, ntodo);
if (nbytes != (ndone + ntodo)) {
- SDK_RPRINT(SDK_Cache_test, "INKVIONBytesGet", "TestCase1", TC_FAIL, "read_vio corrupted");
- SDK_RPRINT(SDK_Cache_test, "INKVIONTodoGet", "TestCase1", TC_FAIL, "read_vio corrupted");
- SDK_RPRINT(SDK_Cache_test, "INKVIONDoneGet", "TestCase1", TC_FAIL, "read_vio corrupted");
+ SDK_RPRINT(SDK_Cache_test, "TSVIONBytesGet", "TestCase1", TC_FAIL, "read_vio corrupted");
+ SDK_RPRINT(SDK_Cache_test, "TSVIONTodoGet", "TestCase1", TC_FAIL, "read_vio corrupted");
+ SDK_RPRINT(SDK_Cache_test, "TSVIONDoneGet", "TestCase1", TC_FAIL, "read_vio corrupted");
// no need to continue, return
*SDK_Cache_pstatus = REGRESSION_TEST_FAILED;
return 1;
} else {
- SDK_RPRINT(SDK_Cache_test, "INKVIONBytesGet", "TestCase1", TC_PASS, "ok");
- SDK_RPRINT(SDK_Cache_test, "INKVIONTodoGet", "TestCase1", TC_PASS, "ok");
- SDK_RPRINT(SDK_Cache_test, "INKVIONDoneGet", "TestCase1", TC_PASS, "ok");
-
- INKVIONDoneSet(cache_vconn->read_vio, 0);
- if (INKVIONDoneGet(cache_vconn->read_vio) != 0) {
- SDK_RPRINT(SDK_Cache_test, "INKVIONDoneSet", "TestCase1", TC_FAIL, "fail to set");
+ SDK_RPRINT(SDK_Cache_test, "TSVIONBytesGet", "TestCase1", TC_PASS, "ok");
+ SDK_RPRINT(SDK_Cache_test, "TSVIONTodoGet", "TestCase1", TC_PASS, "ok");
+ SDK_RPRINT(SDK_Cache_test, "TSVIONDoneGet", "TestCase1", TC_PASS, "ok");
+
+ TSVIONDoneSet(cache_vconn->read_vio, 0);
+ if (TSVIONDoneGet(cache_vconn->read_vio) != 0) {
+ SDK_RPRINT(SDK_Cache_test, "TSVIONDoneSet", "TestCase1", TC_FAIL, "fail to set");
// no need to continue, return
*SDK_Cache_pstatus = REGRESSION_TEST_FAILED;
return 1;
} else
- SDK_RPRINT(SDK_Cache_test, "INKVIONDoneSet", "TestCase1", TC_PASS, "ok");
+ SDK_RPRINT(SDK_Cache_test, "TSVIONDoneSet", "TestCase1", TC_PASS, "ok");
Debug(UTDBG_TAG "_cache_write", "finishing up [i]");
// now waiting for 100ms to make sure the key is
// written in directory remove the content
- INKContSchedule(contp, 100);
+ TSContSchedule(contp, 100);
}
return 1;
- case INK_EVENT_VCONN_READ_READY:
- Debug(UTDBG_TAG "_cache_event", "INK_EVENT_VCONN_READ_READY %d %p", event, data);
- if ((INKVIO) data != cache_vconn->read_vio) {
- SDK_RPRINT(SDK_Cache_test, "INKVConnRead", "TestCase1", TC_FAIL, "read_vio corrupted");
+ case TS_EVENT_VCONN_READ_READY:
+ Debug(UTDBG_TAG "_cache_event", "TS_EVENT_VCONN_READ_READY %d %p", event, data);
+ if ((TSVIO) data != cache_vconn->read_vio) {
+ SDK_RPRINT(SDK_Cache_test, "TSVConnRead", "TestCase1", TC_FAIL, "read_vio corrupted");
// no need to continue, return
*SDK_Cache_pstatus = REGRESSION_TEST_FAILED;
return 1;
}
- nbytes = INKVIONBytesGet(cache_vconn->read_vio);
- ntodo = INKVIONTodoGet(cache_vconn->read_vio);
- ndone = INKVIONDoneGet(cache_vconn->read_vio);
+ nbytes = TSVIONBytesGet(cache_vconn->read_vio);
+ ntodo = TSVIONTodoGet(cache_vconn->read_vio);
+ ndone = TSVIONDoneGet(cache_vconn->read_vio);
Debug(UTDBG_TAG "_cache_read", "Nbytes=%d Ndone=%d Ntodo=%d", nbytes, ndone, ntodo);
if (nbytes != (ndone + ntodo)) {
- SDK_RPRINT(SDK_Cache_test, "INKVIONBytesGet", "TestCase1", TC_FAIL, "read_vio corrupted");
- SDK_RPRINT(SDK_Cache_test, "INKVIONTodoGet", "TestCase1", TC_FAIL, "read_vio corrupted");
- SDK_RPRINT(SDK_Cache_test, "INKVIONDoneGet", "TestCase1", TC_FAIL, "read_vio corrupted");
+ SDK_RPRINT(SDK_Cache_test, "TSVIONBytesGet", "TestCase1", TC_FAIL, "read_vio corrupted");
+ SDK_RPRINT(SDK_Cache_test, "TSVIONTodoGet", "TestCase1", TC_FAIL, "read_vio corrupted");
+ SDK_RPRINT(SDK_Cache_test, "TSVIONDoneGet", "TestCase1", TC_FAIL, "read_vio corrupted");
// no need to continue, return
*SDK_Cache_pstatus = REGRESSION_TEST_FAILED;
return 1;
} else {
- SDK_RPRINT(SDK_Cache_test, "INKVIONBytesGet", "TestCase1", TC_PASS, "ok");
- SDK_RPRINT(SDK_Cache_test, "INKVIONTodoGet", "TestCase1", TC_PASS, "ok");
- SDK_RPRINT(SDK_Cache_test, "INKVIONDoneGet", "TestCase1", TC_PASS, "ok");
+ SDK_RPRINT(SDK_Cache_test, "TSVIONBytesGet", "TestCase1", TC_PASS, "ok");
+ SDK_RPRINT(SDK_Cache_test, "TSVIONTodoGet", "TestCase1", TC_PASS, "ok");
+ SDK_RPRINT(SDK_Cache_test, "TSVIONDoneGet", "TestCase1", TC_PASS, "ok");
}
// Fix for bug INKqa12276: Must consume data from iobuffer
- nbytes = INKIOBufferReaderAvail(cache_vconn->out_readerp);
- INKIOBufferReaderConsume(cache_vconn->out_readerp, nbytes);
- INKDebug(UTDBG_TAG "_cache_read", "Consuming %d bytes from cache read VC", nbytes);
+ nbytes = TSIOBufferReaderAvail(cache_vconn->out_readerp);
+ TSIOBufferReaderConsume(cache_vconn->out_readerp, nbytes);
+ TSDebug(UTDBG_TAG "_cache_read", "Consuming %d bytes from cache read VC", nbytes);
- INKVIOReenable(cache_vconn->read_vio);
+ TSVIOReenable(cache_vconn->read_vio);
Debug(UTDBG_TAG "_cache_read", "finishing up [j]");
return 1;
- case INK_EVENT_TIMEOUT:
- Debug(UTDBG_TAG "_cache_event", "INK_EVENT_TIMEOUT %d %p", event, data);
+ case TS_EVENT_TIMEOUT:
+ Debug(UTDBG_TAG "_cache_event", "TS_EVENT_TIMEOUT %d %p", event, data);
// do remove cached doc
- INKCacheRemove(contp, cache_vconn->key);
+ TSCacheRemove(contp, cache_vconn->key);
return 1;
default:
- INKReleaseAssert(!"Test SDK_API_INKCache: unexpected event");
+ TSReleaseAssert(!"Test SDK_API_TSCache: unexpected event");
}
Debug(UTDBG_TAG "_cache_event", "DONE DONE DONE");
// destroy the data structure
Debug(UTDBG_TAG "_cache_write", "all tests passed [z]");
- INKIOBufferDestroy(cache_vconn->bufp);
- INKIOBufferDestroy(cache_vconn->out_bufp);
- INKCacheKeyDestroy(cache_vconn->key);
- INKfree(cache_vconn);
+ TSIOBufferDestroy(cache_vconn->bufp);
+ TSIOBufferDestroy(cache_vconn->out_bufp);
+ TSCacheKeyDestroy(cache_vconn->key);
+ TSfree(cache_vconn);
*SDK_Cache_pstatus = REGRESSION_TEST_PASSED;
return 1;
}
-REGRESSION_TEST(SDK_API_INKCache) (RegressionTest * test, int atype, int *pstatus)
+REGRESSION_TEST(SDK_API_TSCache) (RegressionTest * test, int atype, int *pstatus)
{
NOWARN_UNUSED(atype);
*pstatus = REGRESSION_TEST_INPROGRESS;
@@ -740,47 +740,47 @@ REGRESSION_TEST(SDK_API_INKCache) (Regre
int is_ready = 0;
// Check if Cache is ready
- INKCacheReady(&is_ready);
+ TSCacheReady(&is_ready);
if (!is_ready) {
- SDK_RPRINT(test, "INKCacheReady", "TestCase1", TC_FAIL, "cache is not ready");
+ SDK_RPRINT(test, "TSCacheReady", "TestCase1", TC_FAIL, "cache is not ready");
// no need to continue, return
*pstatus = REGRESSION_TEST_FAILED;
return;
} else {
- SDK_RPRINT(test, "INKCacheReady", "TestCase1", TC_PASS, "ok");
+ SDK_RPRINT(test, "TSCacheReady", "TestCase1", TC_PASS, "ok");
}
// Create CacheKey
char key_name[] = "key_for_regression_test";
- INKCacheKey key, key_cmp;
- INKCacheKeyCreate(&key);
- INKCacheKeyCreate(&key_cmp);
+ TSCacheKey key, key_cmp;
+ TSCacheKeyCreate(&key);
+ TSCacheKeyCreate(&key_cmp);
if (key == NULL) {
- SDK_RPRINT(test, "INKCacheKeyCreate", "TestCase1", TC_FAIL, "can't malloc memory for key");
+ SDK_RPRINT(test, "TSCacheKeyCreate", "TestCase1", TC_FAIL, "can't malloc memory for key");
// no need to continue, return
*pstatus = REGRESSION_TEST_FAILED;
if (key_cmp != NULL)
- INKCacheKeyDestroy(key_cmp);
+ TSCacheKeyDestroy(key_cmp);
return;
} else {
- SDK_RPRINT(test, "INKCacheKeyCreate", "TestCase1", TC_PASS, "ok");
+ SDK_RPRINT(test, "TSCacheKeyCreate", "TestCase1", TC_PASS, "ok");
}
- INKCacheKeyDigestSet(key, (unsigned char *) key_name, strlen(key_name));
- INKCacheKeyDigestSet(key_cmp, (unsigned char *) key_name, strlen(key_name));
+ TSCacheKeyDigestSet(key, (unsigned char *) key_name, strlen(key_name));
+ TSCacheKeyDigestSet(key_cmp, (unsigned char *) key_name, strlen(key_name));
- if (memcmp(key, key_cmp, sizeof(INKCacheKey)) != 0) {
- SDK_RPRINT(test, "INKCacheKeySetDigest", "TestCase1", TC_FAIL, "digest is wrong");
+ if (memcmp(key, key_cmp, sizeof(TSCacheKey)) != 0) {
+ SDK_RPRINT(test, "TSCacheKeySetDigest", "TestCase1", TC_FAIL, "digest is wrong");
// no need to continue, return
*pstatus = REGRESSION_TEST_FAILED;
- INKCacheKeyDestroy(key);
- INKCacheKeyDestroy(key_cmp);
+ TSCacheKeyDestroy(key);
+ TSCacheKeyDestroy(key_cmp);
return;
} else {
- SDK_RPRINT(test, "INKCacheKeySetDigest", "TestCase1", TC_PASS, "ok");
- INKCacheKeyDestroy(key_cmp);
+ SDK_RPRINT(test, "TSCacheKeySetDigest", "TestCase1", TC_PASS, "ok");
+ TSCacheKeyDestroy(key_cmp);
}
// prepare caching content
@@ -791,41 +791,41 @@ REGRESSION_TEST(SDK_API_INKCache) (Regre
content[OBJECT_SIZE - 1] = '\0';
//Write data to cache.
- INKCont contp = INKContCreate(cache_handler, INKMutexCreate());
- CacheVConnStruct *cache_vconn = (CacheVConnStruct *) INKmalloc(sizeof(CacheVConnStruct));
+ TSCont contp = TSContCreate(cache_handler, TSMutexCreate());
+ CacheVConnStruct *cache_vconn = (CacheVConnStruct *) TSmalloc(sizeof(CacheVConnStruct));
cache_vconn->key = key;
- INKContDataSet(contp, cache_vconn);
+ TSContDataSet(contp, cache_vconn);
- INKCacheWrite(contp, key);
+ TSCacheWrite(contp, key);
}
-/* INKfopen */
+/* TSfopen */
//////////////////////////////////////////////
-// SDK_API_INKfopen
+// SDK_API_TSfopen
//
-// Unit Test for API: INKfopen
-// INKclose
-// INKfflush
-// INKfgets
-// INKfread
-// INKfwrite
+// Unit Test for API: TSfopen
+// TSclose
+// TSfflush
+// TSfgets
+// TSfread
+// TSfwrite
//////////////////////////////////////////////
// Used to create tmp file
//#define TMP_DIR "/var/tmp"
#define PFX "plugin.config"
-REGRESSION_TEST(SDK_API_INKfopen) (RegressionTest * test, int atype, int *pstatus)
+REGRESSION_TEST(SDK_API_TSfopen) (RegressionTest * test, int atype, int *pstatus)
{
NOWARN_UNUSED(atype);
*pstatus = REGRESSION_TEST_INPROGRESS;
char write_file_name[PATH_NAME_MAX + 1];
- INKFile source_read_file; // existing file
- INKFile write_file; // to be created
- INKFile cmp_read_file; // read & compare
+ TSFile source_read_file; // existing file
+ TSFile write_file; // to be created
+ TSFile cmp_read_file; // read & compare
char input_buffer[BUFSIZ];
char cmp_buffer[BUFSIZ];
@@ -843,25 +843,24 @@ REGRESSION_TEST(SDK_API_INKfopen) (Regre
// returning the char[]
// Better check the dir itself.
//
- if (INKInstallDirGet() == NULL) {
+ if (TSInstallDirGet() == NULL) {
error_counter++;
*pstatus = REGRESSION_TEST_FAILED;
return;
}
// Add "etc/trafficserver" to point to config directory
- ink_filepath_make(input_file_full_path, sizeof(input_file_full_path),
- INKConfigDirGet(), INPUT_TEXT_FILE);
+ ink_filepath_make(input_file_full_path, sizeof(input_file_full_path), TSConfigDirGet(), INPUT_TEXT_FILE);
// open existing file for reading
- if (!(source_read_file = INKfopen(input_file_full_path, "r"))) {
- SDK_RPRINT(test, "INKfopen", "TestCase1", TC_FAIL, "can't open file for reading");
+ if (!(source_read_file = TSfopen(input_file_full_path, "r"))) {
+ SDK_RPRINT(test, "TSfopen", "TestCase1", TC_FAIL, "can't open file for reading");
error_counter++;
// no need to continue, return
*pstatus = REGRESSION_TEST_FAILED;
return;
} else
- SDK_RPRINT(test, "INKfopen", "TestCase1", TC_PASS, "ok");
+ SDK_RPRINT(test, "TSfopen", "TestCase1", TC_PASS, "ok");
// Create unique tmp _file_name_, do not use any TS file_name
snprintf(write_file_name, PATH_NAME_MAX, "/tmp/%sXXXXXX", PFX);
@@ -873,23 +872,23 @@ REGRESSION_TEST(SDK_API_INKfopen) (Regre
// no need to continue, return
*pstatus = REGRESSION_TEST_FAILED;
if (source_read_file != NULL)
- INKfclose(source_read_file);
+ TSfclose(source_read_file);
return;
}
close(write_file_fd);
// open file for writing, the file doesn't have to exist.
- if (!(write_file = INKfopen(write_file_name, "w"))) {
- SDK_RPRINT(test, "INKfopen", "TestCase2", TC_FAIL, "can't open file for writing");
+ if (!(write_file = TSfopen(write_file_name, "w"))) {
+ SDK_RPRINT(test, "TSfopen", "TestCase2", TC_FAIL, "can't open file for writing");
error_counter++;
// no need to continue, return
*pstatus = REGRESSION_TEST_FAILED;
if (source_read_file != NULL)
- INKfclose(source_read_file);
+ TSfclose(source_read_file);
return;
}
- SDK_RPRINT(test, "INKfopen", "TestCase2", TC_PASS, "ok");
+ SDK_RPRINT(test, "TSfopen", "TestCase2", TC_PASS, "ok");
memset(input_buffer, '\0', BUFSIZ);
@@ -901,169 +900,169 @@ REGRESSION_TEST(SDK_API_INKfopen) (Regre
// no need to continue, return
*pstatus = REGRESSION_TEST_FAILED;
if (source_read_file != NULL)
- INKfclose(source_read_file);
+ TSfclose(source_read_file);
if (write_file != NULL)
- INKfclose(write_file);
+ TSfclose(write_file);
return;
}
read_amount = (stat_buffer_input.st_size <= (off_t)sizeof(input_buffer)) ?
(stat_buffer_input.st_size) : (sizeof(input_buffer));
- // INKfgets
- if ((ret_val = INKfgets(source_read_file, input_buffer, read_amount))
+ // TSfgets
+ if ((ret_val = TSfgets(source_read_file, input_buffer, read_amount))
== NULL) {
- SDK_RPRINT(test, "INKfgets", "TestCase1", TC_FAIL, "can't read from file");
+ SDK_RPRINT(test, "TSfgets", "TestCase1", TC_FAIL, "can't read from file");
error_counter++;
// no need to continue, return
*pstatus = REGRESSION_TEST_FAILED;
if (source_read_file != NULL)
- INKfclose(source_read_file);
+ TSfclose(source_read_file);
if (write_file != NULL)
- INKfclose(write_file);
+ TSfclose(write_file);
return;
} else {
if (ret_val != input_buffer) {
- SDK_RPRINT(test, "INKfgets", "TestCase2", TC_FAIL, "reading error");
+ SDK_RPRINT(test, "TSfgets", "TestCase2", TC_FAIL, "reading error");
error_counter++;
// no need to continue, return
*pstatus = REGRESSION_TEST_FAILED;
if (source_read_file != NULL)
- INKfclose(source_read_file);
+ TSfclose(source_read_file);
if (write_file != NULL)
- INKfclose(write_file);
+ TSfclose(write_file);
return;
} else
- SDK_RPRINT(test, "INKfgets", "TestCase1", TC_PASS, "ok");
+ SDK_RPRINT(test, "TSfgets", "TestCase1", TC_PASS, "ok");
}
- // INKfwrite
- wrote = INKfwrite(write_file, input_buffer, read_amount);
+ // TSfwrite
+ wrote = TSfwrite(write_file, input_buffer, read_amount);
if (wrote != read_amount) {
- SDK_RPRINT(test, "INKfwrite", "TestCase1", TC_FAIL, "writing error");
+ SDK_RPRINT(test, "TSfwrite", "TestCase1", TC_FAIL, "writing error");
error_counter++;
// no need to continue, return
*pstatus = REGRESSION_TEST_FAILED;
if (source_read_file != NULL)
- INKfclose(source_read_file);
+ TSfclose(source_read_file);
if (write_file != NULL)
- INKfclose(write_file);
+ TSfclose(write_file);
return;
}
- SDK_RPRINT(test, "INKfwrite", "TestCase1", TC_PASS, "ok");
+ SDK_RPRINT(test, "TSfwrite", "TestCase1", TC_PASS, "ok");
- // INKfflush
+ // TSfflush
if (stat(write_file_name, &stat_buffer_pre) != 0) {
- SDK_RPRINT(test, "stat", "std func", TC_FAIL, "INKfwrite error");
+ SDK_RPRINT(test, "stat", "std func", TC_FAIL, "TSfwrite error");
error_counter++;
// no need to continue, return
*pstatus = REGRESSION_TEST_FAILED;
if (source_read_file != NULL)
- INKfclose(source_read_file);
+ TSfclose(source_read_file);
if (write_file != NULL)
- INKfclose(write_file);
+ TSfclose(write_file);
return;
}
- INKfflush(write_file); // write_file should point to write_file_name
+ TSfflush(write_file); // write_file should point to write_file_name
if (stat(write_file_name, &stat_buffer_post) != 0) {
- SDK_RPRINT(test, "stat", "std func", TC_FAIL, "INKfflush error");
+ SDK_RPRINT(test, "stat", "std func", TC_FAIL, "TSfflush error");
error_counter++;
// no need to continue, return
*pstatus = REGRESSION_TEST_FAILED;
if (source_read_file != NULL)
- INKfclose(source_read_file);
+ TSfclose(source_read_file);
if (write_file != NULL)
- INKfclose(write_file);
+ TSfclose(write_file);
return;
}
if ((stat_buffer_pre.st_size == 0) && (stat_buffer_post.st_size == read_amount)) {
- SDK_RPRINT(test, "INKfflush", "TestCase1", TC_PASS, "ok");
+ SDK_RPRINT(test, "TSfflush", "TestCase1", TC_PASS, "ok");
} else {
- SDK_RPRINT(test, "INKfflush", "TestCase1", TC_FAIL, "INKfflush error");
+ SDK_RPRINT(test, "TSfflush", "TestCase1", TC_FAIL, "TSfflush error");
error_counter++;
// no need to continue, return
*pstatus = REGRESSION_TEST_FAILED;
if (source_read_file != NULL)
- INKfclose(source_read_file);
+ TSfclose(source_read_file);
if (write_file != NULL)
- INKfclose(write_file);
+ TSfclose(write_file);
return;
}
- // INKfread
+ // TSfread
// open again for reading
- cmp_read_file = INKfopen(write_file_name, "r");
+ cmp_read_file = TSfopen(write_file_name, "r");
if (cmp_read_file == NULL) {
- SDK_RPRINT(test, "INKfopen", "TestCase3", TC_FAIL, "can't open file for reading");
+ SDK_RPRINT(test, "TSfopen", "TestCase3", TC_FAIL, "can't open file for reading");
error_counter++;
// no need to continue, return
*pstatus = REGRESSION_TEST_FAILED;
if (source_read_file != NULL)
- INKfclose(source_read_file);
+ TSfclose(source_read_file);
if (write_file != NULL)
- INKfclose(write_file);
+ TSfclose(write_file);
return;
}
read_amount = (stat_buffer_input.st_size <= (off_t)sizeof(cmp_buffer)) ? (stat_buffer_input.st_size) : (sizeof(cmp_buffer));
- // INKfread on read file
- read = INKfread(cmp_read_file, cmp_buffer, read_amount);
+ // TSfread on read file
+ read = TSfread(cmp_read_file, cmp_buffer, read_amount);
if (read != read_amount) {
- SDK_RPRINT(test, "INKfread", "TestCase1", TC_FAIL, "can't reading");
+ SDK_RPRINT(test, "TSfread", "TestCase1", TC_FAIL, "can't reading");
error_counter++;
// no need to continue, return
*pstatus = REGRESSION_TEST_FAILED;
if (source_read_file != NULL)
- INKfclose(source_read_file);
+ TSfclose(source_read_file);
if (write_file != NULL)
- INKfclose(write_file);
+ TSfclose(write_file);
if (cmp_read_file != NULL)
- INKfclose(cmp_read_file);
+ TSfclose(cmp_read_file);
return;
} else
- SDK_RPRINT(test, "INKfread", "TestCase1", TC_PASS, "ok");
+ SDK_RPRINT(test, "TSfread", "TestCase1", TC_PASS, "ok");
// compare input_buffer and cmp_buffer buffers
if (memcmp(input_buffer, cmp_buffer, read_amount) != 0) {
- SDK_RPRINT(test, "INKfread", "TestCase2", TC_FAIL, "reading error");
+ SDK_RPRINT(test, "TSfread", "TestCase2", TC_FAIL, "reading error");
error_counter++;
// no need to continue, return
*pstatus = REGRESSION_TEST_FAILED;
if (source_read_file != NULL)
- INKfclose(source_read_file);
+ TSfclose(source_read_file);
if (write_file != NULL)
- INKfclose(write_file);
+ TSfclose(write_file);
if (cmp_read_file != NULL)
- INKfclose(cmp_read_file);
+ TSfclose(cmp_read_file);
return;
} else
- SDK_RPRINT(test, "INKfread", "TestCase2", TC_PASS, "ok");
+ SDK_RPRINT(test, "TSfread", "TestCase2", TC_PASS, "ok");
// remove the tmp file
if (unlink(write_file_name) != 0) {
SDK_RPRINT(test, "unlink", "std func", TC_FAIL, "can't remove temp file");
}
- // INKfclose on read file
- INKfclose(source_read_file);
- SDK_RPRINT(test, "INKfclose", "TestCase1", TC_PASS, "ok");
-
- // INKfclose on write file
- INKfclose(write_file);
- SDK_RPRINT(test, "INKfclose", "TestCase2", TC_PASS, "ok");
+ // TSfclose on read file
+ TSfclose(source_read_file);
+ SDK_RPRINT(test, "TSfclose", "TestCase1", TC_PASS, "ok");
+
+ // TSfclose on write file
+ TSfclose(write_file);
+ SDK_RPRINT(test, "TSfclose", "TestCase2", TC_PASS, "ok");
if (error_counter == 0) {
*pstatus = REGRESSION_TEST_PASSED;
@@ -1071,17 +1070,17 @@ REGRESSION_TEST(SDK_API_INKfopen) (Regre
*pstatus = REGRESSION_TEST_FAILED;
}
if (cmp_read_file != NULL)
- INKfclose(cmp_read_file);
+ TSfclose(cmp_read_file);
}
-/* INKThread */
+/* TSThread */
//////////////////////////////////////////////
-// SDK_API_INKThread
+// SDK_API_TSThread
//
-// Unit Test for API: INKThread
-// INKThreadCreate
-// INKThreadSelf
+// Unit Test for API: TSThread
+// TSThreadCreate
+// TSThreadSelf
//////////////////////////////////////////////
static int thread_err_count = 0;
static RegressionTest *SDK_Thread_test;
@@ -1092,16 +1091,16 @@ static void *
thread_create_handler(void *arg)
{
NOWARN_UNUSED(arg);
- INKThread INKthread;
+ TSThread athread;
//Fix me: do more useful work
sleep(10);
- INKthread = INKThreadSelf();
- if (INKthread == 0) {
+ athread = TSThreadSelf();
+ if (athread == 0) {
thread_err_count++;
- SDK_RPRINT(SDK_Thread_test, "INKThreadCreate", "TestCase2", TC_FAIL, "can't get thread");
+ SDK_RPRINT(SDK_Thread_test, "TSThreadCreate", "TestCase2", TC_FAIL, "can't get thread");
} else {
- SDK_RPRINT(SDK_Thread_test, "INKThreadCreate", "TestCase2", TC_PASS, "ok");
+ SDK_RPRINT(SDK_Thread_test, "TSThreadCreate", "TestCase2", TC_PASS, "ok");
}
if (thread_err_count > 0)
@@ -1117,44 +1116,44 @@ thread_create_handler(void *arg)
// Argument data passed to thread init functions
// cannot be allocated on the stack.
-REGRESSION_TEST(SDK_API_INKThread) (RegressionTest * test, int atype, int *pstatus)
+REGRESSION_TEST(SDK_API_TSThread) (RegressionTest * test, int atype, int *pstatus)
{
NOWARN_UNUSED(atype);
*pstatus = REGRESSION_TEST_INPROGRESS;
SDK_Thread_test = test;
SDK_Thread_pstatus = pstatus;
- INKThread curr_thread = 0;
-// INKThread created_thread = 0;
+ TSThread curr_thread = 0;
+// TSThread created_thread = 0;
pthread_t curr_tid;
curr_tid = pthread_self();
- // INKThreadSelf
- curr_thread = INKThreadSelf();
+ // TSThreadSelf
+ curr_thread = TSThreadSelf();
if (curr_thread == 0) {
- SDK_RPRINT(test, "INKThreadSelf", "TestCase1", TC_FAIL, "can't get the current thread");
+ SDK_RPRINT(test, "TSThreadSelf", "TestCase1", TC_FAIL, "can't get the current thread");
thread_err_count++;
} else {
- SDK_RPRINT(test, "INKThreadSelf", "TestCase1", TC_PASS, "ok");
+ SDK_RPRINT(test, "TSThreadSelf", "TestCase1", TC_PASS, "ok");
}
- // INKThreadCreate
- INKThread created_thread = INKThreadCreate(thread_create_handler, (void *) curr_tid);
+ // TSThreadCreate
+ TSThread created_thread = TSThreadCreate(thread_create_handler, (void *) curr_tid);
if (created_thread == NULL) {
thread_err_count++;
- SDK_RPRINT(test, "INKThreadCreate", "TestCase1", TC_FAIL, "can't create thread");
+ SDK_RPRINT(test, "TSThreadCreate", "TestCase1", TC_FAIL, "can't create thread");
} else {
- SDK_RPRINT(test, "INKThreadCreate", "TestCase1", TC_PASS, "ok");
+ SDK_RPRINT(test, "TSThreadCreate", "TestCase1", TC_PASS, "ok");
}
}
//////////////////////////////////////////////
-// SDK_API_INKThread
+// SDK_API_TSThread
//
-// Unit Test for API: INKThreadInit
-// INKThreadDestroy
+// Unit Test for API: TSThreadInit
+// TSThreadDestroy
//////////////////////////////////////////////
static int thread_init_err_count = 0;
static RegressionTest *SDK_ThreadInit_test;
@@ -1165,20 +1164,20 @@ static void *
pthread_start_func(void *arg)
{
NOWARN_UNUSED(arg);
- INKThread temp_thread = 0;
+ TSThread temp_thread = 0;
- // INKThreadInit
- temp_thread = INKThreadInit();
+ // TSThreadInit
+ temp_thread = TSThreadInit();
if (!temp_thread) {
- SDK_RPRINT(SDK_ThreadInit_test, "INKThreadInit", "TestCase2", TC_FAIL, "can't init thread");
+ SDK_RPRINT(SDK_ThreadInit_test, "TSThreadInit", "TestCase2", TC_FAIL, "can't init thread");
thread_init_err_count++;
} else
- SDK_RPRINT(SDK_ThreadInit_test, "INKThreadInit", "TestCase2", TC_PASS, "ok");
+ SDK_RPRINT(SDK_ThreadInit_test, "TSThreadInit", "TestCase2", TC_PASS, "ok");
// Clean up this thread
if (temp_thread)
- INKThreadDestroy(temp_thread);
+ TSThreadDestroy(temp_thread);
if (thread_init_err_count > 0)
*SDK_ThreadInit_pstatus = REGRESSION_TEST_FAILED;
@@ -1188,7 +1187,7 @@ pthread_start_func(void *arg)
return NULL;
}
-REGRESSION_TEST(SDK_API_INKThreadInit) (RegressionTest * test, int atype, int *pstatus)
+REGRESSION_TEST(SDK_API_TSThreadInit) (RegressionTest * test, int atype, int *pstatus)
{
NOWARN_UNUSED(atype);
*pstatus = REGRESSION_TEST_INPROGRESS;
@@ -1204,46 +1203,46 @@ REGRESSION_TEST(SDK_API_INKThreadInit) (
ret = pthread_create(&new_tid, NULL, pthread_start_func, (void *) curr_tid);
if (ret != 0) {
thread_init_err_count++;
- SDK_RPRINT(test, "INKThreadInit", "TestCase1", TC_FAIL, "can't create pthread");
+ SDK_RPRINT(test, "TSThreadInit", "TestCase1", TC_FAIL, "can't create pthread");
} else
- SDK_RPRINT(test, "INKThreadInit", "TestCase1", TC_PASS, "ok");
+ SDK_RPRINT(test, "TSThreadInit", "TestCase1", TC_PASS, "ok");
}
/* Action */
//////////////////////////////////////////////
-// SDK_API_INKAction
+// SDK_API_TSAction
//
-// Unit Test for API: INKActionCancel
+// Unit Test for API: TSActionCancel
//////////////////////////////////////////////
static RegressionTest *SDK_ActionCancel_test;
static int *SDK_ActionCancel_pstatus;
int
-action_cancel_handler(INKCont contp, INKEvent event, void *edata)
+action_cancel_handler(TSCont contp, TSEvent event, void *edata)
{
NOWARN_UNUSED(edata);
- if (event == INK_EVENT_IMMEDIATE) // called from schedule_imm OK
+ if (event == TS_EVENT_IMMEDIATE) // called from schedule_imm OK
{
- SDK_RPRINT(SDK_ActionCancel_test, "INKActionCancel", "TestCase1", TC_PASS, "ok");
+ SDK_RPRINT(SDK_ActionCancel_test, "TSActionCancel", "TestCase1", TC_PASS, "ok");
*SDK_ActionCancel_pstatus = REGRESSION_TEST_PASSED;
- } else if (event == INK_EVENT_TIMEOUT) //called from schedule_in Not OK.
+ } else if (event == TS_EVENT_TIMEOUT) //called from schedule_in Not OK.
{
- SDK_RPRINT(SDK_ActionCancel_test, "INKActionCancel", "TestCase1", TC_FAIL, "bad action");
+ SDK_RPRINT(SDK_ActionCancel_test, "TSActionCancel", "TestCase1", TC_FAIL, "bad action");
*SDK_ActionCancel_pstatus = REGRESSION_TEST_FAILED;
} else // there is sth wrong
{
- SDK_RPRINT(SDK_ActionCancel_test, "INKActionCancel", "TestCase1", TC_FAIL, "bad event");
+ SDK_RPRINT(SDK_ActionCancel_test, "TSActionCancel", "TestCase1", TC_FAIL, "bad event");
*SDK_ActionCancel_pstatus = REGRESSION_TEST_FAILED;
}
- INKContDestroy(contp);
+ TSContDestroy(contp);
return 0;
}
-REGRESSION_TEST(SDK_API_INKActionCancel) (RegressionTest * test, int atype, int *pstatus)
+REGRESSION_TEST(SDK_API_TSActionCancel) (RegressionTest * test, int atype, int *pstatus)
{
NOWARN_UNUSED(atype);
*pstatus = REGRESSION_TEST_INPROGRESS;
@@ -1251,29 +1250,29 @@ REGRESSION_TEST(SDK_API_INKActionCancel)
SDK_ActionCancel_test = test;
SDK_ActionCancel_pstatus = pstatus;
- INKMutex cont_mutex = INKMutexCreate();
- INKCont contp = INKContCreate(action_cancel_handler, cont_mutex);
- INKAction actionp = INKContSchedule(contp, 10000);
+ TSMutex cont_mutex = TSMutexCreate();
+ TSCont contp = TSContCreate(action_cancel_handler, cont_mutex);
+ TSAction actionp = TSContSchedule(contp, 10000);
- INKMutexLock(cont_mutex);
- if (INKActionDone(actionp)) {
+ TSMutexLock(cont_mutex);
+ if (TSActionDone(actionp)) {
*pstatus = REGRESSION_TEST_FAILED;
- INKMutexUnlock(cont_mutex);
+ TSMutexUnlock(cont_mutex);
return;
} else {
- INKActionCancel(actionp);
+ TSActionCancel(actionp);
}
- INKMutexUnlock(cont_mutex);
+ TSMutexUnlock(cont_mutex);
- INKContSchedule(contp, 0);
+ TSContSchedule(contp, 0);
}
//////////////////////////////////////////////
-// SDK_API_INKAction
+// SDK_API_TSAction
//
-// Unit Test for API: INKActionDone
+// Unit Test for API: TSActionDone
//////////////////////////////////////////////
-/* Currently, don't know how to test it because INKAction
+/* Currently, don't know how to test it because TSAction
is at "done" status only "shortly" after finish
executing action_done_handler. Another possibility is
to use reentrant call. But in both cases it's not
@@ -1283,10 +1282,10 @@ REGRESSION_TEST(SDK_API_INKActionCancel)
/* Continuations */
//////////////////////////////////////////////
-// SDK_API_INKCont
+// SDK_API_TSCont
//
-// Unit Test for API: INKContCreate
-// INKContCall
+// Unit Test for API: TSContCreate
+// TSContCall
//////////////////////////////////////////////
// this is needed for asynchronous APIs
@@ -1294,13 +1293,13 @@ static RegressionTest *SDK_ContCreate_te
static int *SDK_ContCreate_pstatus;
int
-cont_handler(INKCont contp, INKEvent event, void *edata)
+cont_handler(TSCont contp, TSEvent event, void *edata)
{
NOWARN_UNUSED(contp);
NOWARN_UNUSED(event);
NOWARN_UNUSED(edata);
- SDK_RPRINT(SDK_ContCreate_test, "INKContCreate", "TestCase1", TC_PASS, "ok");
- SDK_RPRINT(SDK_ContCreate_test, "INKContCall", "TestCase1", TC_PASS, "ok");
+ SDK_RPRINT(SDK_ContCreate_test, "TSContCreate", "TestCase1", TC_PASS, "ok");
+ SDK_RPRINT(SDK_ContCreate_test, "TSContCall", "TestCase1", TC_PASS, "ok");
*SDK_ContCreate_pstatus = REGRESSION_TEST_PASSED;
@@ -1308,7 +1307,7 @@ cont_handler(INKCont contp, INKEvent eve
}
-REGRESSION_TEST(SDK_API_INKContCreate) (RegressionTest * test, int atype, int *pstatus)
+REGRESSION_TEST(SDK_API_TSContCreate) (RegressionTest * test, int atype, int *pstatus)
{
NOWARN_UNUSED(atype);
*pstatus = REGRESSION_TEST_INPROGRESS;
@@ -1317,33 +1316,33 @@ REGRESSION_TEST(SDK_API_INKContCreate) (
SDK_ContCreate_test = test;
SDK_ContCreate_pstatus = pstatus;
- INKMutex mutexp = INKMutexCreate();
- INKCont contp = INKContCreate(cont_handler, mutexp);
+ TSMutex mutexp = TSMutexCreate();
+ TSCont contp = TSContCreate(cont_handler, mutexp);
int lock = 0;
- INKMutexLockTry(mutexp, &lock);
+ TSMutexLockTry(mutexp, &lock);
if (lock) //mutex is grabbed
{
- INKContCall(contp, (INKEvent) 0, NULL);
- INKMutexUnlock(mutexp);
+ TSContCall(contp, (TSEvent) 0, NULL);
+ TSMutexUnlock(mutexp);
} else //mutex has problems
{
- SDK_RPRINT(SDK_ContCreate_test, "INKContCreate", "TestCase1", TC_FAIL, "continuation creation has problems");
- SDK_RPRINT(SDK_ContCreate_test, "INKContCall", "TestCase1", TC_FAIL, "continuation has problems");
+ SDK_RPRINT(SDK_ContCreate_test, "TSContCreate", "TestCase1", TC_FAIL, "continuation creation has problems");
+ SDK_RPRINT(SDK_ContCreate_test, "TSContCall", "TestCase1", TC_FAIL, "continuation has problems");
*pstatus = REGRESSION_TEST_FAILED;
}
- INKContDestroy(contp);
+ TSContDestroy(contp);
}
//////////////////////////////////////////////
-// SDK_API_INKCont
+// SDK_API_TSCont
//
-// Unit Test for API: INKContDataGet
-// INKContDataSet
+// Unit Test for API: TSContDataGet
+// TSContDataSet
//////////////////////////////////////////////
// this is needed for asynchronous APIs
@@ -1358,32 +1357,32 @@ typedef struct
} MyData;
int
-cont_data_handler(INKCont contp, INKEvent event, void *edata)
+cont_data_handler(TSCont contp, TSEvent event, void *edata)
{
NOWARN_UNUSED(event);
NOWARN_UNUSED(edata);
- MyData *my_data = (MyData *) INKContDataGet(contp);
+ MyData *my_data = (MyData *) TSContDataGet(contp);
if (my_data->data1 == 1 && my_data->data2 == 2) {
- SDK_RPRINT(SDK_ContData_test, "INKContDataSet", "TestCase1", TC_PASS, "ok");
- SDK_RPRINT(SDK_ContData_test, "INKContDataGet", "TestCase1", TC_PASS, "ok");
+ SDK_RPRINT(SDK_ContData_test, "TSContDataSet", "TestCase1", TC_PASS, "ok");
+ SDK_RPRINT(SDK_ContData_test, "TSContDataGet", "TestCase1", TC_PASS, "ok");
*SDK_ContData_pstatus = REGRESSION_TEST_PASSED;
} else {
// If we get bad data, it's a failure
- SDK_RPRINT(SDK_ContData_test, "INKContDataSet", "TestCase1", TC_FAIL, "bad data");
- SDK_RPRINT(SDK_ContData_test, "INKContDataGet", "TestCase1", TC_FAIL, "bad data");
+ SDK_RPRINT(SDK_ContData_test, "TSContDataSet", "TestCase1", TC_FAIL, "bad data");
+ SDK_RPRINT(SDK_ContData_test, "TSContDataGet", "TestCase1", TC_FAIL, "bad data");
*SDK_ContData_pstatus = REGRESSION_TEST_FAILED;
}
- INKfree(my_data);
- INKContDestroy(contp);
+ TSfree(my_data);
+ TSContDestroy(contp);
return 0;
}
-REGRESSION_TEST(SDK_API_INKContDataGet) (RegressionTest * test, int atype, int *pstatus)
+REGRESSION_TEST(SDK_API_TSContDataGet) (RegressionTest * test, int atype, int *pstatus)
{
NOWARN_UNUSED(atype);
*pstatus = REGRESSION_TEST_INPROGRESS;
@@ -1392,57 +1391,57 @@ REGRESSION_TEST(SDK_API_INKContDataGet)
SDK_ContData_test = test;
SDK_ContData_pstatus = pstatus;
- INKCont contp = INKContCreate(cont_data_handler, INKMutexCreate());
+ TSCont contp = TSContCreate(cont_data_handler, TSMutexCreate());
- MyData *my_data = (MyData *) INKmalloc(sizeof(MyData));
+ MyData *my_data = (MyData *) TSmalloc(sizeof(MyData));
my_data->data1 = 1;
my_data->data2 = 2;
- INKContDataSet(contp, (void *) my_data);
+ TSContDataSet(contp, (void *) my_data);
- INKContSchedule(contp, 0);
+ TSContSchedule(contp, 0);
}
//////////////////////////////////////////////
-// SDK_API_INKCont
+// SDK_API_TSCont
//
-// Unit Test for API: INKContMutexGet
+// Unit Test for API: TSContMutexGet
//////////////////////////////////////////////
-REGRESSION_TEST(SDK_API_INKContMutexGet) (RegressionTest * test, int atype, int *pstatus)
+REGRESSION_TEST(SDK_API_TSContMutexGet) (RegressionTest * test, int atype, int *pstatus)
{
NOWARN_UNUSED(atype);
bool test_passed = false;
*pstatus = REGRESSION_TEST_INPROGRESS;
- INKMutex mutexp_input;
- INKMutex mutexp_output;
- INKCont contp;
+ TSMutex mutexp_input;
+ TSMutex mutexp_output;
+ TSCont contp;
- mutexp_input = INKMutexCreate();
- contp = INKContCreate(cont_handler, mutexp_input);
+ mutexp_input = TSMutexCreate();
+ contp = TSContCreate(cont_handler, mutexp_input);
- mutexp_output = INKContMutexGet(contp);
+ mutexp_output = TSContMutexGet(contp);
if (mutexp_input == mutexp_output) {
- SDK_RPRINT(test, "INKContMutexGet", "TestCase1", TC_PASS, "ok");
+ SDK_RPRINT(test, "TSContMutexGet", "TestCase1", TC_PASS, "ok");
test_passed = true;
} else
- SDK_RPRINT(test, "INKContMutexGet", "TestCase1", TC_FAIL, "Continutation's mutex corrupted");
+ SDK_RPRINT(test, "TSContMutexGet", "TestCase1", TC_FAIL, "Continutation's mutex corrupted");
// Status of the whole test
*pstatus = ((test_passed == true) ? REGRESSION_TEST_PASSED : REGRESSION_TEST_FAILED);
- INKContDestroy(contp);
+ TSContDestroy(contp);
}
//////////////////////////////////////////////
-// SDK_API_INKCont
+// SDK_API_TSCont
//
-// Unit Test for API: INKContSchedule
+// Unit Test for API: TSContSchedule
//////////////////////////////////////////////
// this is needed for asynchronous APIs
@@ -1454,20 +1453,20 @@ static int tc1_count = 0;
static int tc2_count = 0;
int
-cont_schedule_handler(INKCont contp, INKEvent event, void *edata)
+cont_schedule_handler(TSCont contp, TSEvent event, void *edata)
{
NOWARN_UNUSED(edata);
- if (event == INK_EVENT_IMMEDIATE) {
+ if (event == TS_EVENT_IMMEDIATE) {
// Test Case 1
- SDK_RPRINT(SDK_ContSchedule_test, "INKContSchedule", "TestCase1", TC_PASS, "ok");
+ SDK_RPRINT(SDK_ContSchedule_test, "TSContSchedule", "TestCase1", TC_PASS, "ok");
tc1_count++;
- } else if (event == INK_EVENT_TIMEOUT) {
+ } else if (event == TS_EVENT_TIMEOUT) {
// Test Case 2
- SDK_RPRINT(SDK_ContSchedule_test, "INKContSchedule", "TestCase2", TC_PASS, "ok");
+ SDK_RPRINT(SDK_ContSchedule_test, "TSContSchedule", "TestCase2", TC_PASS, "ok");
tc2_count++;
} else {
// If we receive a bad event, it's a failure
- SDK_RPRINT(SDK_ContSchedule_test, "INKContSchedule", "TestCase1|2",
+ SDK_RPRINT(SDK_ContSchedule_test, "TSContSchedule", "TestCase1|2",
TC_FAIL, "received unexpected event number %d", event);
*SDK_ContSchedule_pstatus = REGRESSION_TEST_FAILED;
return 0;
@@ -1482,7 +1481,7 @@ cont_schedule_handler(INKCont contp, INK
*SDK_ContSchedule_pstatus = REGRESSION_TEST_FAILED;
}
- INKContDestroy(contp);
+ TSContDestroy(contp);
return 0;
}
@@ -1494,43 +1493,43 @@ cont_schedule_handler(INKCont contp, INK
*/
//////////////////////////////////////////////
-// SDK_API_INKMutex
+// SDK_API_TSMutex
//
-// Unit Test for API: INKMutexCreate
-// INKMutexLock
-// INKMutexUnLock
+// Unit Test for API: TSMutexCreate
+// TSMutexLock
+// TSMutexUnLock
//////////////////////////////////////////////
-REGRESSION_TEST(SDK_API_INKMutexCreate) (RegressionTest * test, int atype, int *pstatus)
+REGRESSION_TEST(SDK_API_TSMutexCreate) (RegressionTest * test, int atype, int *pstatus)
{
NOWARN_UNUSED(atype);
bool test_passed = false;
*pstatus = REGRESSION_TEST_INPROGRESS;
- INKMutex mutexp = INKMutexCreate();
+ TSMutex mutexp = TSMutexCreate();
- INKMutexLock(mutexp);
+ TSMutexLock(mutexp);
/* This is normal because all locking is from the same thread */
int lock = 0;
- INKMutexLockTry(mutexp, &lock);
- INKMutexLockTry(mutexp, &lock);
+ TSMutexLockTry(mutexp, &lock);
+ TSMutexLockTry(mutexp, &lock);
if (lock) {
- SDK_RPRINT(test, "INKMutexCreate", "TestCase1", TC_PASS, "ok");
- SDK_RPRINT(test, "INKMutexLock", "TestCase1", TC_PASS, "ok");
- SDK_RPRINT(test, "INKMutexLockTry", "TestCase1", TC_PASS, "ok");
+ SDK_RPRINT(test, "TSMutexCreate", "TestCase1", TC_PASS, "ok");
+ SDK_RPRINT(test, "TSMutexLock", "TestCase1", TC_PASS, "ok");
+ SDK_RPRINT(test, "TSMutexLockTry", "TestCase1", TC_PASS, "ok");
test_passed = true;
} else {
- SDK_RPRINT(test, "INKMutexCreate", "TestCase1", TC_FAIL, "mutex can't be grabbed twice from the same thread");
- SDK_RPRINT(test, "INKMutexLock", "TestCase1", TC_FAIL, "mutex can't be grabbed twice from the same thread");
- SDK_RPRINT(test, "INKMutexLockTry", "TestCase1", TC_FAIL, "mutex can't be grabbed twice from the same thread");
+ SDK_RPRINT(test, "TSMutexCreate", "TestCase1", TC_FAIL, "mutex can't be grabbed twice from the same thread");
+ SDK_RPRINT(test, "TSMutexLock", "TestCase1", TC_FAIL, "mutex can't be grabbed twice from the same thread");
+ SDK_RPRINT(test, "TSMutexLockTry", "TestCase1", TC_FAIL, "mutex can't be grabbed twice from the same thread");
}
- INKMutexUnlock(mutexp);
- SDK_RPRINT(test, "INKMutexUnLock", "TestCase1", TC_PASS, "ok");
+ TSMutexUnlock(mutexp);
+ SDK_RPRINT(test, "TSMutexUnLock", "TestCase1", TC_PASS, "ok");
if (test_passed) {
*pstatus = REGRESSION_TEST_PASSED;
@@ -1543,14 +1542,14 @@ REGRESSION_TEST(SDK_API_INKMutexCreate)
/* IOBuffer */
//////////////////////////////////////////////
-// SDK_API_INKIOBuffer
+// SDK_API_TSIOBuffer
//
-// Unit Test for API: INKIOBufferCreate
-// INKIOBufferWaterMarkGet
-// INKIOBufferWaterMarkSet
+// Unit Test for API: TSIOBufferCreate
+// TSIOBufferWaterMarkGet
+// TSIOBufferWaterMarkSet
//////////////////////////////////////////////
-REGRESSION_TEST(SDK_API_INKIOBufferCreate) (RegressionTest * test, int atype, int *pstatus)
+REGRESSION_TEST(SDK_API_TSIOBufferCreate) (RegressionTest * test, int atype, int *pstatus)
{
NOWARN_UNUSED(atype);
bool test_passed = false;
@@ -1558,25 +1557,25 @@ REGRESSION_TEST(SDK_API_INKIOBufferCreat
int64 watermark = 1000;
- INKIOBuffer bufp = INKIOBufferCreate();
+ TSIOBuffer bufp = TSIOBufferCreate();
- INKIOBufferWaterMarkSet(bufp, watermark);
+ TSIOBufferWaterMarkSet(bufp, watermark);
watermark = 0;
- INKIOBufferWaterMarkGet(bufp, &watermark);
+ TSIOBufferWaterMarkGet(bufp, &watermark);
if (watermark == 1000) {
- SDK_RPRINT(test, "INKIOBufferCreate", "TestCase1", TC_PASS, "ok");
- SDK_RPRINT(test, "INKIOBufferWaterMarkGet", "TestCase1", TC_PASS, "ok");
- SDK_RPRINT(test, "INKIOBufferWaterMarkSet", "TestCase1", TC_PASS, "ok");
+ SDK_RPRINT(test, "TSIOBufferCreate", "TestCase1", TC_PASS, "ok");
+ SDK_RPRINT(test, "TSIOBufferWaterMarkGet", "TestCase1", TC_PASS, "ok");
+ SDK_RPRINT(test, "TSIOBufferWaterMarkSet", "TestCase1", TC_PASS, "ok");
test_passed = true;
} else {
- SDK_RPRINT(test, "INKIOBufferCreate", "TestCase1", TC_FAIL, "watermark failed");
- SDK_RPRINT(test, "INKIOBufferWaterMarkGet", "TestCase1", TC_FAIL, "watermark failed");
- SDK_RPRINT(test, "INKIOBufferWaterMarkSet", "TestCase1", TC_FAIL, "watermark failed");
+ SDK_RPRINT(test, "TSIOBufferCreate", "TestCase1", TC_FAIL, "watermark failed");
+ SDK_RPRINT(test, "TSIOBufferWaterMarkGet", "TestCase1", TC_FAIL, "watermark failed");
+ SDK_RPRINT(test, "TSIOBufferWaterMarkSet", "TestCase1", TC_FAIL, "watermark failed");
}
- INKIOBufferDestroy(bufp);
+ TSIOBufferDestroy(bufp);
// Status of the whole test
*pstatus = ((test_passed == true) ? REGRESSION_TEST_PASSED : REGRESSION_TEST_FAILED);
@@ -1586,36 +1585,36 @@ REGRESSION_TEST(SDK_API_INKIOBufferCreat
//////////////////////////////////////////////
-// SDK_API_INKIOBuffer
+// SDK_API_TSIOBuffer
//
-// Unit Test for API: INKIOBufferSizedCreate
-// INKIOBufferProduce
-// INKIOBufferReaderAlloc
-// INKIOBufferReaderAvail
+// Unit Test for API: TSIOBufferSizedCreate
+// TSIOBufferProduce
+// TSIOBufferReaderAlloc
+// TSIOBufferReaderAvail
//////////////////////////////////////////////
-REGRESSION_TEST(SDK_API_INKIOBufferProduce) (RegressionTest * test, int atype, int *pstatus)
+REGRESSION_TEST(SDK_API_TSIOBufferProduce) (RegressionTest * test, int atype, int *pstatus)
{
NOWARN_UNUSED(atype);
bool test_passed = false;
*pstatus = REGRESSION_TEST_INPROGRESS;
- INKIOBuffer bufp = INKIOBufferSizedCreate(INK_IOBUFFER_SIZE_INDEX_4K); //size is 4096
+ TSIOBuffer bufp = TSIOBufferSizedCreate(TS_IOBUFFER_SIZE_INDEX_4K); //size is 4096
- INKIOBufferReader readerp = INKIOBufferReaderAlloc(bufp);
+ TSIOBufferReader readerp = TSIOBufferReaderAlloc(bufp);
- INKIOBufferProduce(bufp, 10);
+ TSIOBufferProduce(bufp, 10);
- int reader_avail = INKIOBufferReaderAvail(readerp);
+ int reader_avail = TSIOBufferReaderAvail(readerp);
if (reader_avail == 10) {
- SDK_RPRINT(test, "INKIOBufferProduce", "TestCase1", TC_PASS, "ok");
- SDK_RPRINT(test, "INKIOBufferReaderAlloc", "TestCase1", TC_PASS, "ok");
- SDK_RPRINT(test, "INKIOBufferReaderAvail", "TestCase1", TC_PASS, "ok");
+ SDK_RPRINT(test, "TSIOBufferProduce", "TestCase1", TC_PASS, "ok");
+ SDK_RPRINT(test, "TSIOBufferReaderAlloc", "TestCase1", TC_PASS, "ok");
+ SDK_RPRINT(test, "TSIOBufferReaderAvail", "TestCase1", TC_PASS, "ok");
test_passed = true;
} else {
- SDK_RPRINT(test, "INKIOBufferProduce", "TestCase1", TC_FAIL, "failed");
- SDK_RPRINT(test, "INKIOBufferReaderAlloc", "TestCase1", TC_FAIL, "failed");
- SDK_RPRINT(test, "INKIOBufferReaderAvail", "TestCase1", TC_FAIL, "failed");
+ SDK_RPRINT(test, "TSIOBufferProduce", "TestCase1", TC_FAIL, "failed");
+ SDK_RPRINT(test, "TSIOBufferReaderAlloc", "TestCase1", TC_FAIL, "failed");
+ SDK_RPRINT(test, "TSIOBufferReaderAvail", "TestCase1", TC_FAIL, "failed");
}
// Status of the whole test
@@ -1625,30 +1624,30 @@ REGRESSION_TEST(SDK_API_INKIOBufferProdu
//////////////////////////////////////////////
-// SDK_API_INKIOBuffer
+// SDK_API_TSIOBuffer
//
-// Unit Test for API: INKIOBufferReaderConsume
+// Unit Test for API: TSIOBufferReaderConsume
//////////////////////////////////////////////
-REGRESSION_TEST(SDK_API_INKIOBufferReaderConsume) (RegressionTest * test, int atype, int *pstatus)
+REGRESSION_TEST(SDK_API_TSIOBufferReaderConsume) (RegressionTest * test, int atype, int *pstatus)
{
NOWARN_UNUSED(atype);
bool test_passed = false;
*pstatus = REGRESSION_TEST_INPROGRESS;
- INKIOBuffer bufp = INKIOBufferSizedCreate(INK_IOBUFFER_SIZE_INDEX_4K);
+ TSIOBuffer bufp = TSIOBufferSizedCreate(TS_IOBUFFER_SIZE_INDEX_4K);
- INKIOBufferReader readerp = INKIOBufferReaderAlloc(bufp);
+ TSIOBufferReader readerp = TSIOBufferReaderAlloc(bufp);
- INKIOBufferProduce(bufp, 10);
- INKIOBufferReaderConsume(readerp, 10);
+ TSIOBufferProduce(bufp, 10);
+ TSIOBufferReaderConsume(readerp, 10);
- int reader_avail = INKIOBufferReaderAvail(readerp);
+ int reader_avail = TSIOBufferReaderAvail(readerp);
if (reader_avail == 0) {
- SDK_RPRINT(test, "INKIOBufferReaderConsume", "TestCase1", TC_PASS, "ok");
+ SDK_RPRINT(test, "TSIOBufferReaderConsume", "TestCase1", TC_PASS, "ok");
test_passed = true;
} else {
- SDK_RPRINT(test, "INKIOBufferReaderConsume", "TestCase1", TC_FAIL, "failed");
+ SDK_RPRINT(test, "TSIOBufferReaderConsume", "TestCase1", TC_FAIL, "failed");
}
// Status of the whole test
@@ -1657,32 +1656,32 @@ REGRESSION_TEST(SDK_API_INKIOBufferReade
}
//////////////////////////////////////////////
-// SDK_API_INKIOBuffer
+// SDK_API_TSIOBuffer
//
-// Unit Test for API: INKIOBufferReaderClone
+// Unit Test for API: TSIOBufferReaderClone
//////////////////////////////////////////////
-REGRESSION_TEST(SDK_API_INKIOBufferReaderClone) (RegressionTest * test, int atype, int *pstatus)
+REGRESSION_TEST(SDK_API_TSIOBufferReaderClone) (RegressionTest * test, int atype, int *pstatus)
{
NOWARN_UNUSED(atype);
bool test_passed = false;
*pstatus = REGRESSION_TEST_INPROGRESS;
- INKIOBuffer bufp = INKIOBufferSizedCreate(INK_IOBUFFER_SIZE_INDEX_4K);
+ TSIOBuffer bufp = TSIOBufferSizedCreate(TS_IOBUFFER_SIZE_INDEX_4K);
- INKIOBufferReader readerp = INKIOBufferReaderAlloc(bufp);
+ TSIOBufferReader readerp = TSIOBufferReaderAlloc(bufp);
- INKIOBufferProduce(bufp, 10);
- INKIOBufferReaderConsume(readerp, 5);
+ TSIOBufferProduce(bufp, 10);
+ TSIOBufferReaderConsume(readerp, 5);
- INKIOBufferReader readerp2 = INKIOBufferReaderClone(readerp);
+ TSIOBufferReader readerp2 = TSIOBufferReaderClone(readerp);
- int reader_avail = INKIOBufferReaderAvail(readerp2);
+ int reader_avail = TSIOBufferReaderAvail(readerp2);
if (reader_avail == 5) {
- SDK_RPRINT(test, "INKIOBufferReaderClone", "TestCase1", TC_PASS, "ok");
+ SDK_RPRINT(test, "TSIOBufferReaderClone", "TestCase1", TC_PASS, "ok");
test_passed = true;
} else {
- SDK_RPRINT(test, "INKIOBufferReaderClone", "TestCase1", TC_FAIL, "failed");
+ SDK_RPRINT(test, "TSIOBufferReaderClone", "TestCase1", TC_FAIL, "failed");
}
// Status of the whole test
@@ -1691,29 +1690,29 @@ REGRESSION_TEST(SDK_API_INKIOBufferReade
}
//////////////////////////////////////////////
-// SDK_API_INKIOBuffer
+// SDK_API_TSIOBuffer
//
-// Unit Test for API: INKIOBufferStart
-// INKIOBufferReaderStart
+// Unit Test for API: TSIOBufferStart
+// TSIOBufferReaderStart
//////////////////////////////////////////////
-REGRESSION_TEST(SDK_API_INKIOBufferStart) (RegressionTest * test, int atype, int *pstatus)
+REGRESSION_TEST(SDK_API_TSIOBufferStart) (RegressionTest * test, int atype, int *pstatus)
{
NOWARN_UNUSED(atype);
bool test_passed = false;
*pstatus = REGRESSION_TEST_INPROGRESS;
- INKIOBuffer bufp = INKIOBufferSizedCreate(INK_IOBUFFER_SIZE_INDEX_4K);
+ TSIOBuffer bufp = TSIOBufferSizedCreate(TS_IOBUFFER_SIZE_INDEX_4K);
- INKIOBufferReader readerp = INKIOBufferReaderAlloc(bufp);
+ TSIOBufferReader readerp = TSIOBufferReaderAlloc(bufp);
- if (INKIOBufferStart(bufp) == INKIOBufferReaderStart(readerp)) {
- SDK_RPRINT(test, "INKIOBufferStart", "TestCase1", TC_PASS, "ok");
- SDK_RPRINT(test, "INKIOBufferReaderStart", "TestCase1", TC_PASS, "ok");
+ if (TSIOBufferStart(bufp) == TSIOBufferReaderStart(readerp)) {
+ SDK_RPRINT(test, "TSIOBufferStart", "TestCase1", TC_PASS, "ok");
+ SDK_RPRINT(test, "TSIOBufferReaderStart", "TestCase1", TC_PASS, "ok");
test_passed = true;
} else {
- SDK_RPRINT(test, "INKIOBufferStart", "TestCase1", TC_FAIL, "failed");
- SDK_RPRINT(test, "INKIOBufferReaderStart", "TestCase1", TC_FAIL, "failed");
+ SDK_RPRINT(test, "TSIOBufferStart", "TestCase1", TC_FAIL, "failed");
+ SDK_RPRINT(test, "TSIOBufferReaderStart", "TestCase1", TC_FAIL, "failed");
}
// Status of the whole test
@@ -1723,38 +1722,38 @@ REGRESSION_TEST(SDK_API_INKIOBufferStart
//////////////////////////////////////////////
-// SDK_API_INKIOBuffer
+// SDK_API_TSIOBuffer
//
-// Unit Test for API: INKIOBufferCopy
-// INKIOBufferWrite
-// INKIOBufferReaderCopy
+// Unit Test for API: TSIOBufferCopy
+// TSIOBufferWrite
+// TSIOBufferReaderCopy
//////////////////////////////////////////////
-REGRESSION_TEST(SDK_API_INKIOBufferCopy) (RegressionTest * test, int atype, int *pstatus)
+REGRESSION_TEST(SDK_API_TSIOBufferCopy) (RegressionTest * test, int atype, int *pstatus)
{
NOWARN_UNUSED(atype);
bool test_passed = false;
*pstatus = REGRESSION_TEST_INPROGRESS;
- char input_buf[] = "This is the test for INKIOBufferCopy, INKIOBufferWrite, INKIOBufferReaderCopy";
+ char input_buf[] = "This is the test for TSIOBufferCopy, TSIOBufferWrite, TSIOBufferReaderCopy";
char output_buf[1024];
- INKIOBuffer bufp = INKIOBufferSizedCreate(INK_IOBUFFER_SIZE_INDEX_4K);
- INKIOBuffer bufp2 = INKIOBufferSizedCreate(INK_IOBUFFER_SIZE_INDEX_4K);
+ TSIOBuffer bufp = TSIOBufferSizedCreate(TS_IOBUFFER_SIZE_INDEX_4K);
+ TSIOBuffer bufp2 = TSIOBufferSizedCreate(TS_IOBUFFER_SIZE_INDEX_4K);
- INKIOBufferReader readerp = INKIOBufferReaderAlloc(bufp);
- INKIOBufferWrite(bufp, input_buf, (strlen(input_buf) + 1));
- INKIOBufferCopy(bufp2, readerp, (strlen(input_buf) + 1), 0);
- INKIOBufferReaderCopy(readerp, output_buf, (strlen(input_buf) + 1));
+ TSIOBufferReader readerp = TSIOBufferReaderAlloc(bufp);
+ TSIOBufferWrite(bufp, input_buf, (strlen(input_buf) + 1));
+ TSIOBufferCopy(bufp2, readerp, (strlen(input_buf) + 1), 0);
+ TSIOBufferReaderCopy(readerp, output_buf, (strlen(input_buf) + 1));
if (strcmp(input_buf, output_buf) == 0) {
- SDK_RPRINT(test, "INKIOBufferWrite", "TestCase1", TC_PASS, "ok");
- SDK_RPRINT(test, "INKIOBufferCopy", "TestCase1", TC_PASS, "ok");
- SDK_RPRINT(test, "INKIOBufferReaderCopy", "TestCase1", TC_PASS, "ok");
+ SDK_RPRINT(test, "TSIOBufferWrite", "TestCase1", TC_PASS, "ok");
+ SDK_RPRINT(test, "TSIOBufferCopy", "TestCase1", TC_PASS, "ok");
+ SDK_RPRINT(test, "TSIOBufferReaderCopy", "TestCase1", TC_PASS, "ok");
test_passed = true;
} else {
- SDK_RPRINT(test, "INKIOBufferWrite", "TestCase1", TC_FAIL, "failed");
- SDK_RPRINT(test, "INKIOBufferCopy", "TestCase1", TC_FAIL, "failed");
- SDK_RPRINT(test, "INKIOBufferReaderCopy", "TestCase1", TC_FAIL, "failed");
+ SDK_RPRINT(test, "TSIOBufferWrite", "TestCase1", TC_FAIL, "failed");
+ SDK_RPRINT(test, "TSIOBufferCopy", "TestCase1", TC_FAIL, "failed");
+ SDK_RPRINT(test, "TSIOBufferReaderCopy", "TestCase1", TC_FAIL, "failed");
}
// Status of the whole test
@@ -1763,14 +1762,14 @@ REGRESSION_TEST(SDK_API_INKIOBufferCopy)
}
//////////////////////////////////////////////
-// SDK_API_INKIOBuffer
+// SDK_API_TSIOBuffer
//
-// Unit Test for API: INKIOBuffer
-// INKIOBufferWrite
-// INKIOBufferReaderCopy
+// Unit Test for API: TSIOBuffer
+// TSIOBufferWrite
+// TSIOBufferReaderCopy
//////////////////////////////////////////////
-REGRESSION_TEST(SDK_API_INKIOBufferBlockReadAvail) (RegressionTest * test, int atype, int *pstatus)
+REGRESSION_TEST(SDK_API_TSIOBufferBlockReadAvail) (RegressionTest * test, int atype, int *pstatus)
{
NOWARN_UNUSED(atype);
bool test_passed_1 = false;
@@ -1778,32 +1777,32 @@ REGRESSION_TEST(SDK_API_INKIOBufferBlock
*pstatus = REGRESSION_TEST_INPROGRESS;
int i = 10000;
- INKIOBuffer bufp = INKIOBufferCreate();
- INKIOBufferWrite(bufp, (char*)&i, sizeof(int));
- INKIOBufferReader readerp = INKIOBufferReaderAlloc(bufp);
+ TSIOBuffer bufp = TSIOBufferCreate();
+ TSIOBufferWrite(bufp, (char*)&i, sizeof(int));
+ TSIOBufferReader readerp = TSIOBufferReaderAlloc(bufp);
int64 avail_write, avail_read;
// TODO: This is probably not correct any more.
- INKIOBufferBlock blockp = INKIOBufferStart(bufp);
+ TSIOBufferBlock blockp = TSIOBufferStart(bufp);
- if ((INKIOBufferBlockWriteStart(blockp, &avail_write) - INKIOBufferBlockReadStart(blockp, readerp, &avail_read)) ==
+ if ((TSIOBufferBlockWriteStart(blockp, &avail_write) - TSIOBufferBlockReadStart(blockp, readerp, &avail_read)) ==
sizeof(int)) {
- SDK_RPRINT(test, "INKIOBufferBlockReadStart", "TestCase1", TC_PASS, "ok");
- SDK_RPRINT(test, "INKIOBufferBlockWriteStart", "TestCase1", TC_PASS, "ok");
+ SDK_RPRINT(test, "TSIOBufferBlockReadStart", "TestCase1", TC_PASS, "ok");
+ SDK_RPRINT(test, "TSIOBufferBlockWriteStart", "TestCase1", TC_PASS, "ok");
test_passed_1 = true;
} else {
- SDK_RPRINT(test, "INKIOBufferBlockReadStart", "TestCase1", TC_FAIL, "failed");
- SDK_RPRINT(test, "INKIOBufferBlockWriteStart", "TestCase1", TC_FAIL, "failed");
+ SDK_RPRINT(test, "TSIOBufferBlockReadStart", "TestCase1", TC_FAIL, "failed");
+ SDK_RPRINT(test, "TSIOBufferBlockWriteStart", "TestCase1", TC_FAIL, "failed");
}
- if ((INKIOBufferBlockReadAvail(blockp, readerp) + INKIOBufferBlockWriteAvail(blockp)) == 4096) {
- SDK_RPRINT(test, "INKIOBufferBlockReadAvail", "TestCase1", TC_PASS, "ok");
- SDK_RPRINT(test, "INKIOBufferBlockWriteAvail", "TestCase1", TC_PASS, "ok");
+ if ((TSIOBufferBlockReadAvail(blockp, readerp) + TSIOBufferBlockWriteAvail(blockp)) == 4096) {
+ SDK_RPRINT(test, "TSIOBufferBlockReadAvail", "TestCase1", TC_PASS, "ok");
+ SDK_RPRINT(test, "TSIOBufferBlockWriteAvail", "TestCase1", TC_PASS, "ok");
test_passed_2 = true;
} else {
- SDK_RPRINT(test, "INKIOBufferBlockReadAvail", "TestCase1", TC_FAIL, "failed");
- SDK_RPRINT(test, "INKIOBufferBlockWriteAvail", "TestCase1", TC_FAIL, "failed");
+ SDK_RPRINT(test, "TSIOBufferBlockReadAvail", "TestCase1", TC_FAIL, "failed");
+ SDK_RPRINT(test, "TSIOBufferBlockWriteAvail", "TestCase1", TC_FAIL, "failed");
}
if (test_passed_1 && test_passed_2) {
@@ -1816,31 +1815,31 @@ REGRESSION_TEST(SDK_API_INKIOBufferBlock
}
//////////////////////////////////////////////////
-// SDK_API_INKIOBuffer
+// SDK_API_TSIOBuffer
//
-// Unit Test for API: INKIOBufferBlockNext
+// Unit Test for API: TSIOBufferBlockNext
//////////////////////////////////////////////////
-REGRESSION_TEST(SDK_API_INKIOBufferBlockNext) (RegressionTest * test, int atype, int *pstatus)
+REGRESSION_TEST(SDK_API_TSIOBufferBlockNext) (RegressionTest * test, int atype, int *pstatus)
{
NOWARN_UNUSED(atype);
bool test_passed = false;
*pstatus = REGRESSION_TEST_INPROGRESS;
int i = 10000;
- INKIOBuffer bufp = INKIOBufferCreate();
- INKIOBufferWrite(bufp, (char*)&i, sizeof(int));
+ TSIOBuffer bufp = TSIOBufferCreate();
+ TSIOBufferWrite(bufp, (char*)&i, sizeof(int));
- INKIOBufferReader readerp = INKIOBufferReaderAlloc(bufp);
- INKIOBufferBlock blockp = INKIOBufferReaderStart(readerp);
+ TSIOBufferReader readerp = TSIOBufferReaderAlloc(bufp);
+ TSIOBufferBlock blockp = TSIOBufferReaderStart(readerp);
// TODO: This is probaby not the best of regression tests right now ...
// Note that this assumes block size is > sizeof(int) bytes.
- if (INKIOBufferBlockNext(blockp) == NULL) {
- SDK_RPRINT(test, "INKIOBufferBlockNext", "TestCase1", TC_PASS, "ok");
+ if (TSIOBufferBlockNext(blockp) == NULL) {
+ SDK_RPRINT(test, "TSIOBufferBlockNext", "TestCase1", TC_PASS, "ok");
test_passed = true;
} else {
- SDK_RPRINT(test, "INKIOBufferBlockNext", "TestCase1", TC_FAIL, "fail");
+ SDK_RPRINT(test, "TSIOBufferBlockNext", "TestCase1", TC_FAIL, "fail");
}
if (test_passed) {
@@ -2145,7 +2144,7 @@ REGRESSION_TEST(SDK_API_INKStatCoupled)
}
-REGRESSION_TEST(SDK_API_INKContSchedule) (RegressionTest * test, int atype, int *pstatus)
+REGRESSION_TEST(SDK_API_TSContSchedule) (RegressionTest * test, int atype, int *pstatus)
{
NOWARN_UNUSED(atype);
[... 7890 lines stripped ...]