The Tor Browser / file comparison
comparison: nsprpub/pr/src/cplus/tests/tpd.cpp
nsprpub/pr/src/cplus/tests/tpd.cpp
- branch
- TOR_BUG_9701
- changeset 13
- 44a2da4a2ab2
equal
deleted
inserted
replaced
| -1:000000000000 | 0:dd2f26259e8e |
|---|---|
| 1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ | |
| 2 /* This Source Code Form is subject to the terms of the Mozilla Public | |
| 3 * License, v. 2.0. If a copy of the MPL was not distributed with this | |
| 4 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ | |
| 5 | |
| 6 /* | |
| 7 ** File: tpd.cpp | |
| 8 ** Description: Exercising the thread private data bailywick. | |
| 9 */ | |
| 10 | |
| 11 #include "prlog.h" | |
| 12 #include "prprf.h" | |
| 13 #include "rcthread.h" | |
| 14 | |
| 15 #include <string.h> | |
| 16 | |
| 17 #include "plgetopt.h" | |
| 18 | |
| 19 /* | |
| 20 ** class MyThread | |
| 21 */ | |
| 22 class MyThread: public RCThread | |
| 23 { | |
| 24 public: | |
| 25 MyThread(); | |
| 26 | |
| 27 private: | |
| 28 ~MyThread(); | |
| 29 void RootFunction(); | |
| 30 }; /* MyThread */ | |
| 31 | |
| 32 /* | |
| 33 ** class MyPrivateData | |
| 34 */ | |
| 35 class MyPrivateData: public RCThreadPrivateData | |
| 36 { | |
| 37 public: | |
| 38 virtual ~MyPrivateData(); | |
| 39 | |
| 40 MyPrivateData(); | |
| 41 MyPrivateData(char*); | |
| 42 MyPrivateData(const MyPrivateData&); | |
| 43 | |
| 44 void Release(); | |
| 45 | |
| 46 private: | |
| 47 char *string; | |
| 48 }; /* MyPrivateData */ | |
| 49 | |
| 50 static PRUintn key[128]; | |
| 51 static PRIntn debug = 0; | |
| 52 static PRBool failed = PR_FALSE; | |
| 53 static PRBool should = PR_TRUE; | |
| 54 static PRBool did = PR_TRUE; | |
| 55 static PRFileDesc *fout = NULL; | |
| 56 | |
| 57 static void PrintProgress(PRIntn line) | |
| 58 { | |
| 59 failed = failed || (should && !did); | |
| 60 failed = failed || (!should && did); | |
| 61 if (debug > 0) | |
| 62 { | |
| 63 PR_fprintf( | |
| 64 fout, "@ line %d destructor should %shave been called and was%s\n", | |
| 65 line, ((should) ? "" : "NOT "), ((did) ? "" : " NOT")); | |
| 66 } | |
| 67 } /* PrintProgress */ | |
| 68 | |
| 69 static void MyAssert(const char *expr, const char *file, PRIntn line) | |
| 70 { | |
| 71 if (debug > 0) | |
| 72 (void)PR_fprintf(fout, "'%s' in file: %s: %d\n", expr, file, line); | |
| 73 } /* MyAssert */ | |
| 74 | |
| 75 #define MY_ASSERT(_expr) \ | |
| 76 ((_expr)?((void)0):MyAssert(# _expr,__FILE__,__LINE__)) | |
| 77 | |
| 78 int main(PRIntn argc, char *argv[]) | |
| 79 { | |
| 80 PRStatus rv; | |
| 81 PRUintn keys; | |
| 82 MyThread *thread; | |
| 83 const RCThreadPrivateData *pd; | |
| 84 PLOptStatus os; | |
| 85 PLOptState *opt = PL_CreateOptState(argc, argv, "d"); | |
| 86 RCThread *primordial = RCThread::WrapPrimordialThread(); | |
| 87 while (PL_OPT_EOL != (os = PL_GetNextOpt(opt))) | |
| 88 { | |
| 89 if (PL_OPT_BAD == os) continue; | |
| 90 switch (opt->option) | |
| 91 { | |
| 92 case 'd': /* debug mode */ | |
| 93 debug = PR_TRUE; | |
| 94 break; | |
| 95 default: | |
| 96 break; | |
| 97 } | |
| 98 } | |
| 99 PL_DestroyOptState(opt); | |
| 100 | |
| 101 fout = PR_STDOUT; | |
| 102 | |
| 103 MyPrivateData extension = MyPrivateData("EXTENSION"); | |
| 104 MyPrivateData key_string[] = { | |
| 105 "Key #0", "Key #1", "Key #2", "Key #3", | |
| 106 "Bogus #5", "Bogus #6", "Bogus #7", "Bogus #8"}; | |
| 107 | |
| 108 | |
| 109 did = should = PR_FALSE; | |
| 110 for (keys = 0; keys < 4; ++keys) | |
| 111 { | |
| 112 rv = RCThread::NewPrivateIndex(&key[keys]); | |
| 113 key[keys + 4] = key[keys] + 4; | |
| 114 MY_ASSERT(PR_SUCCESS == rv); | |
| 115 } | |
| 116 PrintProgress(__LINE__); | |
| 117 | |
| 118 /* the first four should be bu null, the last four undefined and null */ | |
| 119 did = should = PR_FALSE; | |
| 120 for (keys = 0; keys < 8; ++keys) | |
| 121 { | |
| 122 pd = RCThread::GetPrivateData(key[keys]); | |
| 123 MY_ASSERT(NULL == pd); | |
| 124 } | |
| 125 PrintProgress(__LINE__); | |
| 126 | |
| 127 /* initially set private data for new keys */ | |
| 128 did = should = PR_FALSE; | |
| 129 for (keys = 0; keys < 4; ++keys) | |
| 130 { | |
| 131 rv = RCThread::SetPrivateData(key[keys], &key_string[keys]); | |
| 132 MY_ASSERT(PR_SUCCESS == rv); | |
| 133 } | |
| 134 PrintProgress(__LINE__); | |
| 135 | |
| 136 /* re-assign the private data, albeit the same content */ | |
| 137 did = PR_FALSE; should = PR_TRUE; | |
| 138 for (keys = 0; keys < 4; ++keys) | |
| 139 { | |
| 140 pd = RCThread::GetPrivateData(key[keys]); | |
| 141 PR_ASSERT(NULL != pd); | |
| 142 rv = RCThread::SetPrivateData(key[keys], &key_string[keys]); | |
| 143 MY_ASSERT(PR_SUCCESS == rv); | |
| 144 } | |
| 145 PrintProgress(__LINE__); | |
| 146 | |
| 147 /* set private to <empty> */ | |
| 148 did = PR_FALSE; should = PR_TRUE; | |
| 149 for (keys = 0; keys < 4; ++keys) | |
| 150 { | |
| 151 rv = RCThread::SetPrivateData(key[keys]); | |
| 152 MY_ASSERT(PR_SUCCESS == rv); | |
| 153 } | |
| 154 PrintProgress(__LINE__); | |
| 155 | |
| 156 /* should all be null now */ | |
| 157 did = should = PR_FALSE; | |
| 158 for (keys = 0; keys < 4; ++keys) | |
| 159 { | |
| 160 pd = RCThread::GetPrivateData(key[keys]); | |
| 161 PR_ASSERT(NULL == pd); | |
| 162 } | |
| 163 PrintProgress(__LINE__); | |
| 164 | |
| 165 /* allocate another batch of keys and assign data to them */ | |
| 166 did = should = PR_FALSE; | |
| 167 for (keys = 8; keys < 127; ++keys) | |
| 168 { | |
| 169 rv = RCThread::NewPrivateIndex(&key[keys]); | |
| 170 MY_ASSERT(PR_SUCCESS == rv); | |
| 171 rv = RCThread::SetPrivateData(key[keys], &extension); | |
| 172 MY_ASSERT(PR_SUCCESS == rv); | |
| 173 } | |
| 174 PrintProgress(__LINE__); | |
| 175 | |
| 176 /* set all the extended slots to <empty> */ | |
| 177 did = PR_FALSE; should = PR_TRUE; | |
| 178 for (keys = 8; keys < 127; ++keys) | |
| 179 { | |
| 180 rv = RCThread::SetPrivateData(key[keys]); | |
| 181 MY_ASSERT(PR_SUCCESS == rv); | |
| 182 } | |
| 183 PrintProgress(__LINE__); | |
| 184 | |
| 185 /* set all the extended slots to <empty> again (noop) */ | |
| 186 did = should = PR_FALSE; | |
| 187 for (keys = 8; keys < 127; ++keys) | |
| 188 { | |
| 189 rv = RCThread::SetPrivateData(key[keys]); | |
| 190 MY_ASSERT(PR_SUCCESS == rv); | |
| 191 } | |
| 192 | |
| 193 if (debug) PR_fprintf(fout, "Creating thread\n"); | |
| 194 thread = new MyThread(); | |
| 195 if (debug) PR_fprintf(fout, "Starting thread\n"); | |
| 196 thread->Start(); | |
| 197 if (debug) PR_fprintf(fout, "Joining thread\n"); | |
| 198 (void)thread->Join(); | |
| 199 if (debug) PR_fprintf(fout, "Joined thread\n"); | |
| 200 | |
| 201 failed |= (PR_FAILURE == RCPrimordialThread::Cleanup()); | |
| 202 | |
| 203 (void)PR_fprintf( | |
| 204 fout, "%s\n",((PR_TRUE == failed) ? "FAILED" : "PASSED")); | |
| 205 | |
| 206 return (failed) ? 1 : 0; | |
| 207 | |
| 208 } /* main */ | |
| 209 | |
| 210 /* | |
| 211 ** class MyPrivateData | |
| 212 */ | |
| 213 MyPrivateData::~MyPrivateData() | |
| 214 { | |
| 215 PR_fprintf( | |
| 216 fout, "MyPrivateData::~MyPrivateData[%s]\n", | |
| 217 (NULL != string) ? string : "NULL"); | |
| 218 } /* MyPrivateData::~MyPrivateData */ | |
| 219 | |
| 220 MyPrivateData::MyPrivateData(): RCThreadPrivateData() | |
| 221 { | |
| 222 PR_fprintf(fout, "MyPrivateData::MyPrivateData()\n"); | |
| 223 string = NULL; | |
| 224 } /* MyPrivateData::MyPrivateData */ | |
| 225 | |
| 226 MyPrivateData::MyPrivateData(char* data): RCThreadPrivateData() | |
| 227 { | |
| 228 PR_fprintf(fout, "MyPrivateData::MyPrivateData(char* data)\n"); | |
| 229 string = data; | |
| 230 } /* MyPrivateData:: MyPrivateData */ | |
| 231 | |
| 232 MyPrivateData::MyPrivateData(const MyPrivateData& him): RCThreadPrivateData(him) | |
| 233 { | |
| 234 PR_fprintf(fout, "MyPrivateData::MyPrivateData(const MyPrivateData& him)\n"); | |
| 235 string = him.string; | |
| 236 } /* MyPrivateData:: MyPrivateData */ | |
| 237 | |
| 238 void MyPrivateData::Release() | |
| 239 { | |
| 240 if (should) did = PR_TRUE; | |
| 241 else failed = PR_TRUE; | |
| 242 } /* MyPrivateData::operator= */ | |
| 243 | |
| 244 /* | |
| 245 ** class MyThread | |
| 246 */ | |
| 247 MyThread::~MyThread() { } | |
| 248 MyThread::MyThread(): RCThread(RCThread::global, RCThread::joinable) { } | |
| 249 | |
| 250 | |
| 251 void MyThread::RootFunction() | |
| 252 { | |
| 253 PRStatus rv; | |
| 254 PRUintn keys; | |
| 255 const RCThreadPrivateData *pd; | |
| 256 | |
| 257 MyPrivateData extension = MyPrivateData("EXTENSION"); | |
| 258 MyPrivateData key_string[] = { | |
| 259 "Key #0", "Key #1", "Key #2", "Key #3", | |
| 260 "Bogus #5", "Bogus #6", "Bogus #7", "Bogus #8"}; | |
| 261 | |
| 262 did = should = PR_FALSE; | |
| 263 for (keys = 0; keys < 8; ++keys) | |
| 264 { | |
| 265 pd = GetPrivateData(key[keys]); | |
| 266 MY_ASSERT(NULL == pd); | |
| 267 } | |
| 268 PrintProgress(__LINE__); | |
| 269 | |
| 270 did = should = PR_FALSE; | |
| 271 for (keys = 0; keys < 4; ++keys) | |
| 272 { | |
| 273 rv = SetPrivateData(keys, &key_string[keys]); | |
| 274 MY_ASSERT(PR_SUCCESS == rv); | |
| 275 } | |
| 276 PrintProgress(__LINE__); | |
| 277 | |
| 278 #if !defined(DEBUG) | |
| 279 did = should = PR_FALSE; | |
| 280 for (keys = 4; keys < 8; ++keys) | |
| 281 { | |
| 282 rv = SetPrivateData(keys, &key_string[keys]); | |
| 283 MY_ASSERT(PR_FAILURE == rv); | |
| 284 } | |
| 285 PrintProgress(__LINE__); | |
| 286 #endif | |
| 287 | |
| 288 did = PR_FALSE; should = PR_TRUE; | |
| 289 for (keys = 0; keys < 4; ++keys) | |
| 290 { | |
| 291 rv = SetPrivateData(key[keys], &key_string[keys]); | |
| 292 MY_ASSERT(PR_SUCCESS == rv); | |
| 293 } | |
| 294 PrintProgress(__LINE__); | |
| 295 | |
| 296 did = PR_FALSE; should = PR_TRUE; | |
| 297 for (keys = 0; keys < 4; ++keys) | |
| 298 { | |
| 299 rv = SetPrivateData(key[keys]); | |
| 300 MY_ASSERT(PR_SUCCESS == rv); | |
| 301 } | |
| 302 PrintProgress(__LINE__); | |
| 303 | |
| 304 did = should = PR_FALSE; | |
| 305 for (keys = 0; keys < 4; ++keys) | |
| 306 { | |
| 307 rv = SetPrivateData(key[keys]); | |
| 308 MY_ASSERT(PR_SUCCESS == rv); | |
| 309 } | |
| 310 PrintProgress(__LINE__); | |
| 311 | |
| 312 did = should = PR_FALSE; | |
| 313 for (keys = 8; keys < 127; ++keys) | |
| 314 { | |
| 315 rv = SetPrivateData(key[keys], &extension); | |
| 316 MY_ASSERT(PR_SUCCESS == rv); | |
| 317 } | |
| 318 PrintProgress(__LINE__); | |
| 319 | |
| 320 did = PR_FALSE; should = PR_TRUE; | |
| 321 for (keys = 8; keys < 127; ++keys) | |
| 322 { | |
| 323 rv = SetPrivateData(key[keys]); | |
| 324 MY_ASSERT(PR_SUCCESS == rv); | |
| 325 } | |
| 326 PrintProgress(__LINE__); | |
| 327 | |
| 328 did = should = PR_FALSE; | |
| 329 for (keys = 8; keys < 127; ++keys) | |
| 330 { | |
| 331 rv = SetPrivateData(key[keys]); | |
| 332 MY_ASSERT(PR_SUCCESS == rv); | |
| 333 } | |
| 334 } /* MyThread::RootFunction */ | |
| 335 | |
| 336 /* tpd.c */ |
