1//===- implTest.cpp -------------------------------------------------------===// 2// 3// The MCLinker Project 4// 5// This file is distributed under the University of Illinois Open Source 6// License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9#include <mcld/LD/StaticResolver.h> 10#include <mcld/LD/ResolveInfo.h> 11#include <mcld/LD/ResolveInfoFactory.h> 12#include "StaticResolverTest.h" 13 14#include <iostream> 15 16using namespace std; 17using namespace mcld; 18using namespace mcldtest; 19 20// Constructor can do set-up work for all test here. 21StaticResolverTest::StaticResolverTest() 22{ 23 // create testee. modify it if need 24 m_pResolver = new StaticResolver(); 25 m_pFactory = new ResolveInfoFactory(); 26} 27 28// Destructor can do clean-up work that doesn't throw exceptions here. 29StaticResolverTest::~StaticResolverTest() 30{ 31 delete m_pResolver; 32 delete m_pFactory; 33} 34 35// SetUp() will be called immediately before each test. 36void StaticResolverTest::SetUp() 37{ 38} 39 40// TearDown() will be called immediately after each test. 41void StaticResolverTest::TearDown() 42{ 43} 44 45//==========================================================================// 46// Testcases 47// 48TEST_F( StaticResolverTest, MDEF ) { 49 ResolveInfo* old_sym = m_pFactory->produce("abc"); 50 ResolveInfo* new_sym = m_pFactory->produce("abc"); 51 new_sym->setDesc(ResolveInfo::Define); 52 old_sym->setDesc(ResolveInfo::Define); 53 ASSERT_EQ( mcld::ResolveInfo::Define, new_sym->desc()); 54 ASSERT_EQ( mcld::ResolveInfo::Define, old_sym->desc()); 55 ASSERT_TRUE( mcld::ResolveInfo::define_flag == new_sym->info()); 56 ASSERT_TRUE( mcld::ResolveInfo::define_flag == old_sym->info()); 57 bool override = true; 58 unsigned int result = m_pResolver->resolve(*old_sym, *new_sym, override); 59 ASSERT_EQ( Resolver::Abort, result); 60 ASSERT_FALSE( override ); 61 ASSERT_STREQ( "multiple definitions of `abc'.", m_pResolver->mesg().c_str() ); 62} 63 64TEST_F( StaticResolverTest, DynDefAfterDynUndef ) { 65 ResolveInfo* old_sym = m_pFactory->produce("abc"); 66 ResolveInfo* new_sym = m_pFactory->produce("abc"); 67 68 new_sym->setBinding(ResolveInfo::Global); 69 old_sym->setBinding(ResolveInfo::Global); 70 new_sym->setDesc(ResolveInfo::Undefined); 71 old_sym->setDesc(ResolveInfo::Define); 72 new_sym->setSource(true); 73 old_sym->setSource(true); 74 75 new_sym->setSize(0); 76 77 old_sym->setSize(1); 78 79 ASSERT_EQ( mcld::ResolveInfo::Global, new_sym->binding()); 80 ASSERT_EQ( mcld::ResolveInfo::Global, old_sym->binding()); 81 ASSERT_EQ( mcld::ResolveInfo::Undefined, new_sym->desc()); 82 ASSERT_EQ( mcld::ResolveInfo::Define, old_sym->desc()); 83 84 bool override = false; 85 unsigned int result = m_pResolver->resolve(*old_sym, *new_sym, override); 86 ASSERT_EQ( Resolver::Success, result); 87 ASSERT_FALSE( override ); 88 ASSERT_EQ(1, old_sym->size()); 89} 90 91TEST_F( StaticResolverTest, DynDefAfterDynDef ) { 92 ResolveInfo* old_sym = m_pFactory->produce("abc"); 93 ResolveInfo* new_sym = m_pFactory->produce("abc"); 94 95 new_sym->setBinding(ResolveInfo::Global); 96 old_sym->setBinding(ResolveInfo::Global); 97 new_sym->setDesc(ResolveInfo::Define); 98 old_sym->setDesc(ResolveInfo::Define); 99 new_sym->setSource(true); 100 old_sym->setSource(true); 101 102 new_sym->setSize(0); 103 104 old_sym->setSize(1); 105 106 ASSERT_EQ( mcld::ResolveInfo::Global, new_sym->binding()); 107 ASSERT_EQ( mcld::ResolveInfo::Global, old_sym->binding()); 108 ASSERT_EQ( mcld::ResolveInfo::Define, new_sym->desc()); 109 ASSERT_EQ( mcld::ResolveInfo::Define, old_sym->desc()); 110 111 bool override = false; 112 unsigned int result = m_pResolver->resolve(*old_sym, *new_sym, override); 113 ASSERT_EQ( Resolver::Success, result); 114 ASSERT_FALSE( override ); 115 ASSERT_EQ(1, old_sym->size()); 116} 117 118TEST_F( StaticResolverTest, DynUndefAfterDynUndef ) { 119 ResolveInfo* old_sym = m_pFactory->produce("abc"); 120 ResolveInfo* new_sym = m_pFactory->produce("abc"); 121 122 new_sym->setBinding(ResolveInfo::Global); 123 old_sym->setBinding(ResolveInfo::Global); 124 new_sym->setDesc(ResolveInfo::Undefined); 125 old_sym->setDesc(ResolveInfo::Undefined); 126 new_sym->setSource(true); 127 old_sym->setSource(true); 128 129 new_sym->setSize(0); 130 131 old_sym->setSize(1); 132 133 ASSERT_EQ( mcld::ResolveInfo::Global, new_sym->binding()); 134 ASSERT_EQ( mcld::ResolveInfo::Global, old_sym->binding()); 135 ASSERT_EQ( mcld::ResolveInfo::Undefined, new_sym->desc()); 136 ASSERT_EQ( mcld::ResolveInfo::Undefined, old_sym->desc()); 137 138 bool override = false; 139 unsigned int result = m_pResolver->resolve(*old_sym, *new_sym, override); 140 ASSERT_EQ( Resolver::Success, result); 141 ASSERT_FALSE( override ); 142 ASSERT_EQ(1, old_sym->size()); 143} 144 145TEST_F( StaticResolverTest, OverrideWeakByGlobal ) 146{ 147 ResolveInfo* old_sym = m_pFactory->produce("abc"); 148 ResolveInfo* new_sym = m_pFactory->produce("abc"); 149 150 new_sym->setBinding(ResolveInfo::Global); 151 old_sym->setBinding(ResolveInfo::Weak); 152 new_sym->setSize(0); 153 old_sym->setSize(1); 154 155 ASSERT_EQ( mcld::ResolveInfo::Global, new_sym->binding()); 156 ASSERT_EQ( mcld::ResolveInfo::Weak, old_sym->binding()); 157 158 ASSERT_TRUE( mcld::ResolveInfo::global_flag == new_sym->info()); 159 ASSERT_TRUE( mcld::ResolveInfo::weak_flag == old_sym->info()); 160 bool override = false; 161 unsigned int result = m_pResolver->resolve(*old_sym, *new_sym, override); 162 ASSERT_EQ( Resolver::Success, result); 163 ASSERT_TRUE( override ); 164 ASSERT_EQ(0, old_sym->size()); 165} 166 167TEST_F( StaticResolverTest, DynWeakAfterDynDef ) { 168 ResolveInfo* old_sym = m_pFactory->produce("abc"); 169 ResolveInfo* new_sym = m_pFactory->produce("abc"); 170 171 old_sym->setBinding(ResolveInfo::Weak); 172 new_sym->setBinding(ResolveInfo::Global); 173 174 new_sym->setSource(true); 175 old_sym->setSource(true); 176 177 old_sym->setDesc(ResolveInfo::Define); 178 new_sym->setDesc(ResolveInfo::Define); 179 180 new_sym->setSize(0); 181 182 old_sym->setSize(1); 183 184 ASSERT_EQ( mcld::ResolveInfo::Weak, old_sym->binding()); 185 ASSERT_EQ( mcld::ResolveInfo::Global, new_sym->binding()); 186 ASSERT_EQ( mcld::ResolveInfo::Define, old_sym->desc()); 187 ASSERT_EQ( mcld::ResolveInfo::Define, new_sym->desc()); 188 189 bool override = false; 190 unsigned int result = m_pResolver->resolve(*old_sym, *new_sym, override); 191 ASSERT_EQ( Resolver::Success, result); 192 ASSERT_FALSE( override ); 193 ASSERT_EQ(1, old_sym->size()); 194} 195 196TEST_F( StaticResolverTest, MarkByBiggerCommon ) 197{ 198 ResolveInfo* old_sym = m_pFactory->produce("abc"); 199 ResolveInfo* new_sym = m_pFactory->produce("abc"); 200 201 new_sym->setDesc(ResolveInfo::Common); 202 old_sym->setDesc(ResolveInfo::Common); 203 new_sym->setSize(999); 204 old_sym->setSize(0); 205 206 ASSERT_EQ( mcld::ResolveInfo::Common, new_sym->desc()); 207 ASSERT_EQ( mcld::ResolveInfo::Common, old_sym->desc()); 208 209 ASSERT_TRUE( mcld::ResolveInfo::common_flag == new_sym->info()); 210 ASSERT_TRUE( mcld::ResolveInfo::common_flag == old_sym->info()); 211 bool override = true; 212 unsigned int result = m_pResolver->resolve(*old_sym, *new_sym, override); 213 ASSERT_EQ( Resolver::Success, result); 214 ASSERT_FALSE( override ); 215 ASSERT_EQ(999, old_sym->size()); 216} 217 218TEST_F( StaticResolverTest, OverrideByBiggerCommon ) 219{ 220 ResolveInfo* old_sym = m_pFactory->produce("abc"); 221 ResolveInfo* new_sym = m_pFactory->produce("abc"); 222 223 new_sym->setDesc(ResolveInfo::Common); 224 old_sym->setDesc(ResolveInfo::Common); 225 old_sym->setBinding(ResolveInfo::Weak); 226 new_sym->setSize(999); 227 old_sym->setSize(0); 228 229 ASSERT_EQ( ResolveInfo::Common, new_sym->desc()); 230 ASSERT_EQ( ResolveInfo::Common, old_sym->desc()); 231 ASSERT_EQ( ResolveInfo::Weak, old_sym->binding()); 232 233 ASSERT_TRUE( ResolveInfo::common_flag == new_sym->info()); 234 ASSERT_TRUE( (ResolveInfo::weak_flag | ResolveInfo::common_flag) == old_sym->info()); 235 236 bool override = false; 237 unsigned int result = m_pResolver->resolve(*old_sym, *new_sym, override); 238 ASSERT_EQ( Resolver::Success, result); 239 ASSERT_TRUE( override ); 240 ASSERT_EQ(999, old_sym->size()); 241} 242 243TEST_F( StaticResolverTest, OverrideCommonByDefine) 244{ 245 ResolveInfo* old_sym = m_pFactory->produce("abc"); 246 ResolveInfo* new_sym = m_pFactory->produce("abc"); 247 248 old_sym->setDesc(ResolveInfo::Common); 249 old_sym->setSize(0); 250 251 new_sym->setDesc(ResolveInfo::Define); 252 new_sym->setSize(999); 253 254 ASSERT_EQ( ResolveInfo::Define, new_sym->desc()); 255 ASSERT_EQ( ResolveInfo::Common, old_sym->desc()); 256 257 ASSERT_TRUE( ResolveInfo::define_flag == new_sym->info()); 258 ASSERT_TRUE( ResolveInfo::common_flag == old_sym->info()); 259 260 bool override = false; 261 unsigned int result = m_pResolver->resolve(*old_sym, *new_sym, override); 262 ASSERT_EQ(Resolver::Warning, result); 263 ASSERT_TRUE( override ); 264 ASSERT_EQ(999, old_sym->size()); 265 266 ASSERT_STREQ("definition of 'abc' is overriding common.", m_pResolver->mesg().c_str() ); 267 268} 269 270TEST_F( StaticResolverTest, SetUpDesc) 271{ 272 ResolveInfo* sym = m_pFactory->produce("abc"); 273 274 sym->setIsSymbol(true); 275 276// ASSERT_FALSE( sym->isSymbol() ); 277 ASSERT_TRUE( sym->isSymbol() ); 278 ASSERT_TRUE( sym->isGlobal() ); 279 ASSERT_FALSE( sym->isWeak() ); 280 ASSERT_FALSE( sym->isLocal() ); 281 ASSERT_FALSE( sym->isDefine() ); 282 ASSERT_TRUE( sym->isUndef() ); 283 ASSERT_FALSE( sym->isDyn() ); 284 ASSERT_FALSE( sym->isCommon() ); 285 ASSERT_FALSE( sym->isIndirect() ); 286 ASSERT_EQ( ResolveInfo::NoType, sym->type()); 287 ASSERT_EQ( 0, sym->desc() ); 288 ASSERT_EQ( 0, sym->binding() ); 289 ASSERT_EQ( 0, sym->other() ); 290 291 sym->setIsSymbol(false); 292 ASSERT_FALSE( sym->isSymbol() ); 293// ASSERT_TRUE( sym->isSymbol() ); 294 ASSERT_TRUE( sym->isGlobal() ); 295 ASSERT_FALSE( sym->isWeak() ); 296 ASSERT_FALSE( sym->isLocal() ); 297 ASSERT_FALSE( sym->isDefine() ); 298 ASSERT_TRUE( sym->isUndef() ); 299 ASSERT_FALSE( sym->isDyn() ); 300 ASSERT_FALSE( sym->isCommon() ); 301 ASSERT_FALSE( sym->isIndirect() ); 302 ASSERT_EQ( ResolveInfo::NoType, sym->type()); 303 ASSERT_EQ( 0, sym->desc() ); 304 ASSERT_EQ( 0, sym->binding() ); 305 ASSERT_EQ( 0, sym->other() ); 306 307 sym->setDesc(ResolveInfo::Define); 308 ASSERT_FALSE( sym->isSymbol() ); 309// ASSERT_TRUE( sym->isSymbol() ); 310 ASSERT_TRUE( sym->isGlobal() ); 311 ASSERT_FALSE( sym->isWeak() ); 312 ASSERT_FALSE( sym->isLocal() ); 313 ASSERT_TRUE( sym->isDefine() ); 314 ASSERT_FALSE( sym->isUndef() ); 315 ASSERT_FALSE( sym->isDyn() ); 316 ASSERT_FALSE( sym->isCommon() ); 317 ASSERT_FALSE( sym->isIndirect() ); 318 ASSERT_EQ( ResolveInfo::NoType, sym->type()); 319 ASSERT_EQ( ResolveInfo::Define, sym->desc() ); 320 ASSERT_EQ( 0, sym->binding() ); 321 ASSERT_EQ( 0, sym->other() ); 322 323 sym->setDesc(ResolveInfo::Common); 324 ASSERT_FALSE( sym->isSymbol() ); 325// ASSERT_TRUE( sym->isSymbol() ); 326 ASSERT_TRUE( sym->isGlobal() ); 327 ASSERT_FALSE( sym->isWeak() ); 328 ASSERT_FALSE( sym->isLocal() ); 329 ASSERT_FALSE( sym->isDyn() ); 330 ASSERT_FALSE( sym->isDefine() ); 331 ASSERT_FALSE( sym->isUndef() ); 332 ASSERT_TRUE( sym->isCommon() ); 333 ASSERT_FALSE( sym->isIndirect() ); 334 ASSERT_EQ( ResolveInfo::NoType, sym->type()); 335 ASSERT_EQ( ResolveInfo::Common, sym->desc() ); 336 ASSERT_EQ( 0, sym->binding() ); 337 ASSERT_EQ( 0, sym->other() ); 338 339 sym->setDesc(ResolveInfo::Indirect); 340 ASSERT_FALSE( sym->isSymbol() ); 341 ASSERT_TRUE( sym->isGlobal() ); 342 ASSERT_FALSE( sym->isWeak() ); 343 ASSERT_FALSE( sym->isLocal() ); 344 ASSERT_FALSE( sym->isDyn() ); 345 ASSERT_FALSE( sym->isDefine() ); 346 ASSERT_FALSE( sym->isUndef() ); 347 ASSERT_FALSE( sym->isCommon() ); 348 ASSERT_TRUE( sym->isIndirect() ); 349 ASSERT_EQ( ResolveInfo::NoType, sym->type()); 350 ASSERT_EQ( ResolveInfo::Indirect, sym->desc() ); 351 ASSERT_EQ( 0, sym->binding() ); 352 ASSERT_EQ( 0, sym->other() ); 353 354 sym->setDesc(ResolveInfo::Undefined); 355 ASSERT_FALSE( sym->isSymbol() ); 356 ASSERT_TRUE( sym->isGlobal() ); 357 ASSERT_FALSE( sym->isWeak() ); 358 ASSERT_FALSE( sym->isLocal() ); 359 ASSERT_FALSE( sym->isDyn() ); 360 ASSERT_TRUE( sym->isUndef() ); 361 ASSERT_FALSE( sym->isDefine() ); 362 ASSERT_FALSE( sym->isCommon() ); 363 ASSERT_FALSE( sym->isIndirect() ); 364 ASSERT_EQ( ResolveInfo::NoType, sym->type()); 365 ASSERT_EQ( 0, sym->desc() ); 366 ASSERT_EQ( 0, sym->binding() ); 367 ASSERT_EQ( 0, sym->other() ); 368} 369 370TEST_F( StaticResolverTest, SetUpBinding) 371{ 372 ResolveInfo* sym = m_pFactory->produce("abc"); 373 374 sym->setIsSymbol(true); 375 376// ASSERT_FALSE( sym->isSymbol() ); 377 ASSERT_TRUE( sym->isSymbol() ); 378 ASSERT_TRUE( sym->isGlobal() ); 379 ASSERT_FALSE( sym->isWeak() ); 380 ASSERT_FALSE( sym->isLocal() ); 381 ASSERT_FALSE( sym->isDefine() ); 382 ASSERT_TRUE( sym->isUndef() ); 383 ASSERT_FALSE( sym->isDyn() ); 384 ASSERT_FALSE( sym->isCommon() ); 385 ASSERT_FALSE( sym->isIndirect() ); 386 ASSERT_EQ( ResolveInfo::NoType, sym->type()); 387 ASSERT_EQ( 0, sym->desc() ); 388 ASSERT_EQ( 0, sym->binding() ); 389 ASSERT_EQ( 0, sym->other() ); 390 391 sym->setBinding(ResolveInfo::Global); 392 ASSERT_TRUE( sym->isSymbol() ); 393 ASSERT_TRUE( sym->isGlobal() ); 394 ASSERT_FALSE( sym->isWeak() ); 395 ASSERT_FALSE( sym->isLocal() ); 396 ASSERT_FALSE( sym->isDefine() ); 397 ASSERT_TRUE( sym->isUndef() ); 398 ASSERT_FALSE( sym->isDyn() ); 399 ASSERT_FALSE( sym->isCommon() ); 400 ASSERT_FALSE( sym->isIndirect() ); 401 ASSERT_EQ( ResolveInfo::NoType, sym->type()); 402 ASSERT_EQ( 0, sym->desc() ); 403 ASSERT_EQ( ResolveInfo::Global, sym->binding() ); 404 ASSERT_EQ( 0, sym->other() ); 405 406 sym->setBinding(ResolveInfo::Weak); 407 ASSERT_TRUE( sym->isSymbol() ); 408 ASSERT_FALSE( sym->isGlobal() ); 409 ASSERT_TRUE( sym->isWeak() ); 410 ASSERT_FALSE( sym->isLocal() ); 411 ASSERT_FALSE( sym->isDyn() ); 412 ASSERT_FALSE( sym->isDefine() ); 413 ASSERT_TRUE( sym->isUndef() ); 414 ASSERT_FALSE( sym->isCommon() ); 415 ASSERT_FALSE( sym->isIndirect() ); 416 ASSERT_EQ( ResolveInfo::NoType, sym->type()); 417 ASSERT_EQ( 0, sym->desc() ); 418 ASSERT_EQ( ResolveInfo::Weak, sym->binding() ); 419 ASSERT_EQ( 0, sym->other() ); 420 421 sym->setBinding(ResolveInfo::Local); 422 ASSERT_TRUE( sym->isSymbol() ); 423 ASSERT_FALSE( sym->isGlobal() ); 424 ASSERT_FALSE( sym->isWeak() ); 425 ASSERT_TRUE( sym->isLocal() ); 426 ASSERT_FALSE( sym->isDyn() ); 427 ASSERT_FALSE( sym->isDefine() ); 428 ASSERT_TRUE( sym->isUndef() ); 429 ASSERT_FALSE( sym->isCommon() ); 430 ASSERT_FALSE( sym->isIndirect() ); 431 ASSERT_EQ( ResolveInfo::NoType, sym->type()); 432 ASSERT_EQ( 0, sym->desc() ); 433 ASSERT_EQ( ResolveInfo::Local, sym->binding() ); 434 ASSERT_EQ( 0, sym->other() ); 435} 436 437