开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 中间件编程 > 查看源码
TestTPRealloc.cxx
资源名称：blacktie-2.0.0.M3-src.zip　[点击查看]
上传用户：xfwatch
上传日期：2020-12-14
资源大小：872k
文件大小：11k
源码类别：

中间件编程

开发平台：

Java

TestTPRealloc.cxx：源码内容
  1. /*
  2.  * JBoss, Home of Professional Open Source
  3.  * Copyright 2008, Red Hat, Inc., and others contributors as indicated
  4.  * by the @authors tag. All rights reserved.
  5.  * See the copyright.txt in the distribution for a
  6.  * full listing of individual contributors.
  7.  * This copyrighted material is made available to anyone wishing to use,
  8.  * modify, copy, or redistribute it subject to the terms and conditions
  9.  * of the GNU Lesser General Public License, v. 2.1.
  10.  * This program is distributed in the hope that it will be useful, but WITHOUT A
  11.  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
  12.  * PARTICULAR PURPOSE.  See the GNU Lesser General Public License for more details.
  13.  * You should have received a copy of the GNU Lesser General Public License,
  14.  * v.2.1 along with this distribution; if not, write to the Free Software
  15.  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
  16.  * MA  02110-1301, USA.
  17.  */
  18. #include "TestAssert.h"
  19. #include "BaseTest.h"
  21. #include "xatmi.h"
  22. #include "XATMITestSuite.h"
  24. #include "TestTPRealloc.h"
  25. #include "malloc.h"
  27. void TestTPRealloc::setUp() {
  28. userlogc((char*) "TestTPRealloc::setUp");
  29. m_allocated = NULL;
  30. m_nonallocated = NULL;
  31. BaseTest::setUp();
  33. // Do local work
  34. }
  36. void TestTPRealloc::tearDown() {
  37. userlogc((char*) "TestTPRealloc::tearDown");
  38. if (m_allocated) {
  39. // Do local work
  40. ::tpfree( m_allocated);
  41. m_allocated = NULL;
  42. }
  43. if (m_nonallocated != NULL) {
  45. free( m_nonallocated);
  46. m_nonallocated = NULL;
  47. }
  48. BaseTest::tearDown();
  49. }
  51. // X_OCTET
  52. void TestTPRealloc::test_tprealloc_negative_x_octet() {
  53. userlogc("test_tprealloc_negative_x_octet");
  54. m_allocated = tpalloc((char*) "X_OCTET", NULL, 10);
  55. BT_ASSERT(m_allocated != NULL);
  57. ::tprealloc(m_allocated, -1);
  58. BT_ASSERT(tperrno == TPEINVAL);
  59. }
  61. // THIS DOES NOT WORK AS YOU CANNOT REALLOC A ZERO BUFFER AS IT CANT BE FOUND
  62. void TestTPRealloc::test_tprealloc_zero_x_octet() {
  63. userlogc("test_tprealloc_zero_x_octet");
  64. m_allocated = tpalloc((char*) "X_OCTET", NULL, 10);
  65. BT_ASSERT(m_allocated != NULL);
  67. ::tprealloc(m_allocated, 0);
  68. BT_ASSERT(tperrno == TPEINVAL);
  70. char* type = (char*) malloc(8);
  71. char* subtype = (char*) malloc(16);
  72. int toTest = ::tptypes(m_allocated, type, subtype);
  73. BT_ASSERT(strncmp(type, "X_OCTET", 8) == 0);
  74. BT_ASSERT(strcmp(subtype, "") == 0);
  75. free(type);
  76. free(subtype);
  77. BT_ASSERT(tperrno == 0);
  78. BT_ASSERT(toTest == 10);
  79. }
  81. void TestTPRealloc::test_tprealloc_larger_x_octet() {
  82. userlogc("test_tprealloc_larger_x_octet");
  83. m_allocated = tpalloc((char*) "X_OCTET", NULL, 10);
  84. BT_ASSERT(m_allocated != NULL);
  86. m_allocated = ::tprealloc(m_allocated, 20);
  87. BT_ASSERT(tperrno == 0);
  89. char* type = (char*) malloc(8);
  90. char* subtype = (char*) malloc(16);
  91. int toTest = ::tptypes(m_allocated, type, subtype);
  92. BT_ASSERT(strncmp(type, "X_OCTET", 8) == 0);
  93. BT_ASSERT(strcmp(subtype, "") == 0);
  94. free(type);
  95. free(subtype);
  96. BT_ASSERT(tperrno == 0);
  97. BT_ASSERT(toTest == 20);
  98. }
  100. void TestTPRealloc::test_tprealloc_smaller_x_octet() {
  101. userlogc("test_tprealloc_smaller_x_octet");
  102. m_allocated = tpalloc((char*) "X_OCTET", NULL, 10);
  103. BT_ASSERT(m_allocated != NULL);
  105. m_allocated = ::tprealloc(m_allocated, 5);
  106. BT_ASSERT(tperrno == 0);
  108. char* type = (char*) malloc(8);
  109. char* subtype = (char*) malloc(16);
  110. int toTest = ::tptypes(m_allocated, type, subtype);
  111. BT_ASSERT(strncmp(type, "X_OCTET", 8) == 0);
  112. BT_ASSERT(strcmp(subtype, "") == 0);
  113. free(type);
  114. free(subtype);
  115. BT_ASSERT(tperrno == 0);
  116. BT_ASSERT(toTest == 5);
  117. }
  119. void TestTPRealloc::test_tprealloc_samesize_x_octet() {
  120. userlogc("test_tprealloc_samesize_x_octet");
  121. m_allocated = tpalloc((char*) "X_OCTET", NULL, 10);
  122. BT_ASSERT(m_allocated != NULL);
  124. m_allocated = ::tprealloc(m_allocated, 10);
  125. BT_ASSERT(tperrno == 0);
  127. char* type = (char*) malloc(8);
  128. char* subtype = (char*) malloc(16);
  129. int toTest = ::tptypes(m_allocated, type, subtype);
  130. BT_ASSERT(strncmp(type, "X_OCTET", 8) == 0);
  131. BT_ASSERT(strcmp(subtype, "") == 0);
  132. free(type);
  133. free(subtype);
  134. BT_ASSERT(tperrno == 0);
  135. BT_ASSERT(toTest == 10);
  136. }
  138. void TestTPRealloc::test_tprealloc_multi_x_octet() {
  139. userlogc("test_tprealloc_multi_x_octet");
  140. m_allocated = tpalloc((char*) "X_OCTET", NULL, 10);
  141. BT_ASSERT(m_allocated != NULL);
  143. for (int i = 32; i <= 128; i++) {
  144. m_allocated = ::tprealloc(m_allocated, i);
  145. BT_ASSERT(tperrno == 0);
  147. char* type = (char*) malloc(8);
  148. char* subtype = (char*) malloc(16);
  149. int toTest = ::tptypes(m_allocated, type, subtype);
  150. BT_ASSERT(strncmp(type, "X_OCTET", 8) == 0);
  151. BT_ASSERT(strcmp(subtype, "") == 0);
  152. free(type);
  153. free(subtype);
  154. BT_ASSERT(tperrno == 0);
  155. BT_ASSERT(toTest == i);
  156. }
  157. }
  159. // 8.2
  160. void TestTPRealloc::test_tprealloc_nonbuffer() {
  161. userlogc("test_tprealloc_nonbuffer");
  162. m_nonallocated = (char*) malloc(10);
  163. char* toFree = m_nonallocated;
  164. m_nonallocated = ::tprealloc(m_nonallocated, 10);
  165. BT_ASSERT(tperrno == TPEINVAL);
  166. free(toFree);
  167. }
  169. void TestTPRealloc::test_tprealloc_null() {
  170. userlogc("test_tprealloc_null");
  171. m_nonallocated = ::tprealloc(NULL, 10);
  172. BT_ASSERT(tperrno == TPEINVAL);
  173. }
  175. // X_COMMON
  176. void TestTPRealloc::test_tprealloc_negative_x_common() {
  177. userlogc("test_tprealloc_negative_x_common");
  178. m_allocated = tpalloc((char*) "X_COMMON", (char*) "deposit", 0);
  179. BT_ASSERT(m_allocated != NULL);
  181. ::tprealloc(m_allocated, -1);
  182. BT_ASSERT(tperrno == TPEINVAL);
  183. }
  185. void TestTPRealloc::test_tprealloc_zero_x_common() {
  186. userlogc("test_tprealloc_zero_x_common");
  187. m_allocated = tpalloc((char*) "X_COMMON", (char*) "deposit", 0);
  188. BT_ASSERT(m_allocated != NULL);
  190. ::tprealloc(m_allocated, 0);
  191. BT_ASSERT(tperrno == TPEINVAL);
  193. char* type = (char*) malloc(8);
  194. char* subtype = (char*) malloc(16);
  195. int toTest = ::tptypes(m_allocated, type, subtype);
  196. BT_ASSERT(strncmp(type, "X_COMMON", 8) == 0);
  197. BT_ASSERT(strcmp(subtype, "deposit") == 0);
  198. free(type);
  199. free(subtype);
  200. BT_ASSERT(tperrno == 0);
  201. BT_ASSERT(toTest == sizeof(DEPOSIT));
  202. }
  204. void TestTPRealloc::test_tprealloc_larger_x_common() {
  205. userlogc("test_tprealloc_larger_x_common");
  206. m_allocated = tpalloc((char*) "X_COMMON", (char*) "deposit", 0);
  207. BT_ASSERT(m_allocated != NULL);
  209. ::tprealloc(m_allocated, 3027);
  210. BT_ASSERT(tperrno == TPEINVAL);
  212. char* type = (char*) malloc(8);
  213. char* subtype = (char*) malloc(16);
  214. int toTest = ::tptypes(m_allocated, type, subtype);
  215. BT_ASSERT(strncmp(type, "X_COMMON", 8) == 0);
  216. BT_ASSERT(strcmp(subtype, "deposit") == 0);
  217. free(type);
  218. free(subtype);
  219. BT_ASSERT(tperrno == 0);
  220. BT_ASSERT(toTest == sizeof(DEPOSIT));
  221. }
  223. void TestTPRealloc::test_tprealloc_smaller_x_common() {
  224. userlogc("test_tprealloc_smaller_x_common");
  225. m_allocated = tpalloc((char*) "X_COMMON", (char*) "deposit", 0);
  226. BT_ASSERT(m_allocated != NULL);
  228. ::tprealloc(m_allocated, 512);
  229. BT_ASSERT(tperrno == TPEINVAL);
  231. char* type = (char*) malloc(8);
  232. char* subtype = (char*) malloc(16);
  233. int toTest = ::tptypes(m_allocated, type, subtype);
  234. BT_ASSERT(strncmp(type, "X_COMMON", 8) == 0);
  235. BT_ASSERT(strcmp(subtype, "deposit") == 0);
  236. free(type);
  237. free(subtype);
  238. BT_ASSERT(tperrno == 0);
  239. BT_ASSERT(toTest == sizeof(DEPOSIT));
  240. }
  242. void TestTPRealloc::test_tprealloc_samesize_x_common() {
  243. userlogc("test_tprealloc_samesize_x_common");
  244. m_allocated = tpalloc((char*) "X_COMMON", (char*) "deposit", 0);
  245. BT_ASSERT(m_allocated != NULL);
  247. ::tprealloc(m_allocated, 2048);
  248. BT_ASSERT(tperrno == TPEINVAL);
  250. char* type = (char*) malloc(8);
  251. char* subtype = (char*) malloc(16);
  252. int toTest = ::tptypes(m_allocated, type, subtype);
  253. BT_ASSERT(strncmp(type, "X_COMMON", 8) == 0);
  254. BT_ASSERT(strcmp(subtype, "deposit") == 0);
  255. free(type);
  256. free(subtype);
  257. BT_ASSERT(tperrno == 0);
  258. BT_ASSERT(toTest == sizeof(DEPOSIT));
  259. }
  261. void TestTPRealloc::test_tprealloc_multi_x_common() {
  262. userlogc("test_tprealloc_multi_x_common");
  263. m_allocated = tpalloc((char*) "X_COMMON", (char*) "deposit", 0);
  264. BT_ASSERT(m_allocated != NULL);
  266. for (int i = 1024; i <= 1124; i++) {
  267. ::tprealloc(m_allocated, i);
  268. BT_ASSERT(tperrno == TPEINVAL);
  270. char* type = (char*) malloc(8);
  271. char* subtype = (char*) malloc(16);
  272. int toTest = ::tptypes(m_allocated, type, subtype);
  273. BT_ASSERT(strncmp(type, "X_COMMON", 8) == 0);
  274. BT_ASSERT(strcmp(subtype, "deposit") == 0);
  275. free(type);
  276. free(subtype);
  277. BT_ASSERT(tperrno == 0);
  278. BT_ASSERT(toTest == sizeof(DEPOSIT));
  279. }
  280. }
  282. // X_C_TYPE
  283. void TestTPRealloc::test_tprealloc_negative_x_c_type() {
  284. userlogc("test_tprealloc_negative_x_c_type");
  285. m_allocated = tpalloc((char*) "X_C_TYPE", (char*) "acct_info", 0);
  286. BT_ASSERT(m_allocated != NULL);
  288. ::tprealloc(m_allocated, -1);
  289. BT_ASSERT(tperrno == TPEINVAL);
  290. }
  292. void TestTPRealloc::test_tprealloc_zero_x_c_type() {
  293. userlogc("test_tprealloc_zero_x_c_type");
  294. m_allocated = tpalloc((char*) "X_C_TYPE", (char*) "acct_info", 0);
  295. BT_ASSERT(m_allocated != NULL);
  297. ::tprealloc(m_allocated, 0);
  298. BT_ASSERT(tperrno == TPEINVAL);
  300. char* type = (char*) malloc(8);
  301. char* subtype = (char*) malloc(16);
  302. int toTest = ::tptypes(m_allocated, type, subtype);
  303. BT_ASSERT(strncmp(type, "X_C_TYPE", 8) == 0);
  304. BT_ASSERT(strcmp(subtype, "acct_info") == 0);
  305. free(type);
  306. free(subtype);
  307. BT_ASSERT(tperrno == 0);
  308. BT_ASSERT(toTest == sizeof(ACCT_INFO));
  309. }
  311. void TestTPRealloc::test_tprealloc_larger_x_c_type() {
  312. userlogc("test_tprealloc_larger_x_c_type");
  313. m_allocated = tpalloc((char*) "X_C_TYPE", (char*) "acct_info", 0);
  314. BT_ASSERT(m_allocated != NULL);
  316. ::tprealloc(m_allocated, 3072);
  317. BT_ASSERT(tperrno == TPEINVAL);
  319. char* type = (char*) malloc(8);
  320. char* subtype = (char*) malloc(16);
  321. int toTest = ::tptypes(m_allocated, type, subtype);
  322. BT_ASSERT(strncmp(type, "X_C_TYPE", 8) == 0);
  323. BT_ASSERT(strcmp(subtype, "acct_info") == 0);
  324. free(type);
  325. free(subtype);
  326. BT_ASSERT(tperrno == 0);
  327. BT_ASSERT(toTest == sizeof(ACCT_INFO));
  328. }
  330. void TestTPRealloc::test_tprealloc_smaller_x_c_type() {
  331. userlogc("test_tprealloc_smaller_x_c_type");
  332. m_allocated = tpalloc((char*) "X_C_TYPE", (char*) "acct_info", 0);
  333. BT_ASSERT(m_allocated != NULL);
  335. ::tprealloc(m_allocated, 512);
  336. BT_ASSERT(tperrno == TPEINVAL);
  338. char* type = (char*) malloc(8);
  339. char* subtype = (char*) malloc(16);
  340. int toTest = ::tptypes(m_allocated, type, subtype);
  341. BT_ASSERT(strncmp(type, "X_C_TYPE", 8) == 0);
  342. BT_ASSERT(strcmp(subtype, "acct_info") == 0);
  343. free(type);
  344. free(subtype);
  345. BT_ASSERT(tperrno == 0);
  346. BT_ASSERT(toTest == sizeof(ACCT_INFO));
  347. }
  349. void TestTPRealloc::test_tprealloc_samesize_x_c_type() {
  350. userlogc("test_tprealloc_samesize_x_c_type");
  351. m_allocated = tpalloc((char*) "X_C_TYPE", (char*) "acct_info", 0);
  352. BT_ASSERT(m_allocated != NULL);
  354. ::tprealloc(m_allocated, 2048);
  355. BT_ASSERT(tperrno == TPEINVAL);
  357. char* type = (char*) malloc(8);
  358. char* subtype = (char*) malloc(16);
  359. int toTest = ::tptypes(m_allocated, type, subtype);
  360. BT_ASSERT(strncmp(type, "X_C_TYPE", 8) == 0);
  361. BT_ASSERT(strcmp(subtype, "acct_info") == 0);
  362. free(type);
  363. free(subtype);
  364. BT_ASSERT(tperrno == 0);
  365. BT_ASSERT(toTest == sizeof(ACCT_INFO));
  366. }
  368. void TestTPRealloc::test_tprealloc_multi_x_c_type() {
  369. userlogc("test_tprealloc_multi_x_c_type");
  370. m_allocated = tpalloc((char*) "X_C_TYPE", (char*) "acct_info", 0);
  371. BT_ASSERT(m_allocated != NULL);
  373. for (int i = 1024; i <= 1124; i++) {
  374. ::tprealloc(m_allocated, i);
  375. BT_ASSERT(tperrno == TPEINVAL);
  377. char* type = (char*) malloc(8);
  378. char* subtype = (char*) malloc(16);
  379. int toTest = ::tptypes(m_allocated, type, subtype);
  380. BT_ASSERT(strncmp(type, "X_C_TYPE", 8) == 0);
  381. BT_ASSERT(strcmp(subtype, "acct_info") == 0);
  382. free(type);
  383. free(subtype);
  384. BT_ASSERT(tperrno == 0);
  385. BT_ASSERT(toTest == sizeof(ACCT_INFO));
  386. }
  387. }