test01.cpp revision 12855:588919e0e4aa
1/***************************************************************************** 2 3 Licensed to Accellera Systems Initiative Inc. (Accellera) under one or 4 more contributor license agreements. See the NOTICE file distributed 5 with this work for additional information regarding copyright ownership. 6 Accellera licenses this file to you under the Apache License, Version 2.0 7 (the "License"); you may not use this file except in compliance with the 8 License. You may obtain a copy of the License at 9 10 http://www.apache.org/licenses/LICENSE-2.0 11 12 Unless required by applicable law or agreed to in writing, software 13 distributed under the License is distributed on an "AS IS" BASIS, 14 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or 15 implied. See the License for the specific language governing 16 permissions and limitations under the License. 17 18 *****************************************************************************/ 19 20/***************************************************************************** 21 22 test01.cpp -- 23 24 Original Author: Martin Janssen, Synopsys, Inc., 2002-02-15 25 26 *****************************************************************************/ 27 28/***************************************************************************** 29 30 MODIFICATION LOG - modifiers, enter your name, affiliation, date and 31 changes you are making here. 32 33 Name, Affiliation, Date: 34 Description of Modification: 35 36 *****************************************************************************/ 37 38#include "systemc.h" 39 40#define WRITE(a) \ 41 cout << a.length() << endl; \ 42 cout << a << endl 43 44void 45test_ctors() 46{ 47 cout << "*** test_ctors" << endl; 48 { 49 cout << "sc_bv_base()" << endl; 50 51 sc_bv_base a; 52 WRITE( a ); 53 } 54 { 55 cout << "sc_bv_base( int )" << endl; 56 57 sc_bv_base a( 3 ); 58 WRITE( a ); 59 } 60 { 61 cout << "sc_bv_base( bool )" << endl; 62 63 sc_bv_base a( true ); 64 WRITE( a ); 65 } 66 { 67 cout << "sc_bv_base( bool, int )" << endl; 68 69 sc_bv_base a( true, 3 ); 70 WRITE( a ); 71 } 72 { 73 cout << "sc_bv_base( const char* )" << endl; 74 75 sc_bv_base a( "0101" ); 76 WRITE( a ); 77 sc_bv_base b( "1010" ); 78 WRITE( b ); 79 sc_bv_base c( "0b0101" ); 80 WRITE( c ); 81 sc_bv_base d( "0b1010" ); 82 WRITE( d ); 83 } 84 { 85 cout << "sc_bv_base( const char*, int )" << endl; 86 87 sc_bv_base a3( "0101", 3 ); 88 WRITE( a3 ); 89 sc_bv_base a4( "0101", 4 ); 90 WRITE( a4 ); 91 sc_bv_base a5( "0101", 5 ); 92 WRITE( a5 ); 93 94 sc_bv_base b3( "1010", 3 ); 95 WRITE( b3 ); 96 sc_bv_base b4( "1010", 4 ); 97 WRITE( b4 ); 98 sc_bv_base b5( "1010", 5 ); 99 WRITE( b5 ); 100 101 sc_bv_base c3( "0b0101", 3 ); 102 WRITE( c3 ); 103 sc_bv_base c4( "0b0101", 4 ); 104 WRITE( c4 ); 105 sc_bv_base c5( "0b0101", 5 ); 106 WRITE( c5 ); 107 108 sc_bv_base d3( "0b1010", 3 ); 109 WRITE( d3 ); 110 sc_bv_base d4( "0b1010", 4 ); 111 WRITE( d4 ); 112 sc_bv_base d5( "0b1010", 5 ); 113 WRITE( d5 ); 114 } 115 { 116 cout << "sc_bv_base( const sc_proxy<X>& )" << endl; 117 118 sc_lv<4> x( "01ZX" ); 119 sc_bv_base a( x ); 120 WRITE( a ); 121 } 122 { 123 cout << "sc_bv_base( const sc_bv_base& )" << endl; 124 125 sc_bv<4> x( "0110" ); 126 sc_bv_base a( x ); 127 WRITE( a ); 128 } 129} 130 131void 132test_bitwise_complement() 133{ 134 cout << "*** test_bitwise_complement" << endl; 135 { 136 cout << "sc_bv_base::b_not()" << endl; 137 138 sc_bv_base a( "0110", 4 ); 139 WRITE( a ); 140 a.b_not(); 141 WRITE( a ); 142 } 143 { 144 cout << "sc_bv_base::operator ~ () const" << endl; 145 146 sc_bv_base a( "0110", 4 ); 147 WRITE( a ); 148 sc_bv_base b( 4 ); 149 b = ~a; 150 WRITE( b ); 151 } 152 { 153 cout << "sc_lv_base::b_not()" << endl; 154 155 sc_lv_base a( "01ZX", 4 ); 156 WRITE( a ); 157 a.b_not(); 158 WRITE( a ); 159 } 160 { 161 cout << "sc_lv_base::operator ~ () const" << endl; 162 163 sc_lv_base a( "01ZX", 4 ); 164 WRITE( a ); 165 sc_lv_base b( 4 ); 166 b = ~a; 167 WRITE( b ); 168 } 169 { 170 cout << "sc_proxy<X>::b_not()" << endl; 171 172 sc_lv_base a( "01ZX", 4 ); 173 WRITE( a ); 174 (a( 3, 2 ), a( 1, 0 )).b_not(); 175 WRITE( a ); 176 } 177 { 178 cout << "sc_proxy<X>::operator ~ () const" << endl; 179 180 sc_lv_base a( "01ZX", 4 ); 181 WRITE( a ); 182 sc_lv_base b( 4 ); 183 b = ~(a( 3, 2 ), a( 1, 0 )); 184 WRITE( b ); 185 } 186} 187 188void 189test_bitwise_and() 190{ 191 cout << "*** test_bitwise_and" << endl; 192} 193 194void 195test_bitwise_or() 196{ 197 cout << "*** test_bitwise_or" << endl; 198} 199 200void 201test_bitwise_xor() 202{ 203 cout << "*** test_bitwise_xor" << endl; 204} 205 206void 207test_bitwise_left_shift() 208{ 209 cout << "*** test_bitwise_left_shift" << endl; 210 { 211 cout << "sc_bv_base::operator <<= ( int )" << endl; 212 213 sc_bv_base a( 1, 70 ); 214 a[0] = 0; 215 WRITE( a ); 216 try { 217 a <<= -1; 218 WRITE( a ); 219 } 220 catch( sc_report x ) { 221 cout << "\ncaught exception" << endl; 222 cout << x.what() << endl; 223 } 224 a <<= 3; 225 WRITE( a ); 226 a <<= 33; 227 WRITE( a ); 228 a <<= 72; 229 WRITE( a ); 230 } 231 { 232 cout << "sc_bv_base::operator << ( int ) const" << endl; 233 234 sc_bv_base a( 1, 70 ); 235 a[0] = 0; 236 WRITE( a ); 237 sc_bv_base b( 70 ); 238 try { 239 b = a << -1; 240 WRITE( b ); 241 } 242 catch( sc_report x ) { 243 cout << "\ncaught exception" << endl; 244 cout << x.what() << endl; 245 } 246 b = a << 3; 247 WRITE( b ); 248 b = a << 33; 249 WRITE( b ); 250 b = a << 72; 251 WRITE( b ); 252 } 253 { 254 cout << "sc_lv_base::operator <<= ( int )" << endl; 255 256 sc_lv_base a( SC_LOGIC_X, 70 ); 257 a[0] = SC_LOGIC_Z; 258 WRITE( a ); 259 try { 260 a <<= -1; 261 WRITE( a ); 262 } 263 catch( sc_report x ) { 264 cout << "\ncaught exception" << endl; 265 cout << x.what() << endl; 266 } 267 a <<= 3; 268 WRITE( a ); 269 a <<= 33; 270 WRITE( a ); 271 a <<= 72; 272 WRITE( a ); 273 } 274 { 275 cout << "sc_lv_base::operator << ( int ) const" << endl; 276 277 sc_lv_base a( SC_LOGIC_X, 70 ); 278 a[0] = SC_LOGIC_Z; 279 WRITE( a ); 280 sc_lv_base b( 70 ); 281 try { 282 b = a << -1; 283 WRITE( b ); 284 } 285 catch( sc_report x ) { 286 cout << "\ncaught exception" << endl; 287 cout << x.what() << endl; 288 } 289 b = a << 3; 290 WRITE( b ); 291 b = a << 33; 292 WRITE( b ); 293 b = a << 72; 294 WRITE( b ); 295 } 296 { 297 cout << "sc_proxy<X>::operator <<= ( int )" << endl; 298 299 sc_lv_base a( SC_LOGIC_X, 70 ); 300 a[0] = SC_LOGIC_Z; 301 WRITE( a ); 302 try { 303 (a( 69, 20 ), a( 19, 0 )) <<= -1; 304 WRITE( a ); 305 } 306 catch( sc_report x ) { 307 cout << "\ncaught exception" << endl; 308 cout << x.what() << endl; 309 } 310 // FIX ME: BUG, the following two operations result in 0XX.. 311 (a( 69, 20 ), a( 19, 0 )) <<= 3; 312 WRITE( a ); 313 (a( 69, 20 ), a( 19, 0 )) <<= 33; 314 WRITE( a ); 315 (a( 69, 20 ), a( 19, 0 )) <<= 72; 316 WRITE( a ); 317 } 318 { 319 cout << "sc_proxy<X>::operator << ( int ) const" << endl; 320 321 sc_lv_base a( SC_LOGIC_X, 70 ); 322 a[0] = SC_LOGIC_Z; 323 WRITE( a ); 324 sc_lv_base b( 70 ); 325 try { 326 b = (a( 69, 20 ), a( 19, 0 )) << -1; 327 WRITE( b ); 328 } 329 catch( sc_report x ) { 330 cout << "\ncaught exception" << endl; 331 cout << x.what() << endl; 332 } 333 b = (a( 69, 20 ), a( 19, 0 )) << 3; 334 WRITE( b ); 335 b = (a( 69, 20 ), a( 19, 0 )) << 33; 336 WRITE( b ); 337 b = (a( 69, 20 ), a( 19, 0 )) << 72; 338 WRITE( b ); 339 } 340} 341 342void 343test_bitwise_right_shift() 344{ 345 cout << "*** test_bitwise_right_shift" << endl; 346 { 347 cout << "sc_bv_base::operator >>= ( int )" << endl; 348 349 sc_bv_base a( 1, 70 ); 350 a[69] = 0; 351 WRITE( a ); 352 try { 353 a >>= -1; 354 WRITE( a ); 355 } 356 catch( sc_report x ) { 357 cout << "\ncaught exception" << endl; 358 cout << x.what() << endl; 359 } 360 a >>= 3; 361 WRITE( a ); 362 a >>= 33; 363 WRITE( a ); 364 a >>= 72; 365 WRITE( a ); 366 } 367 { 368 cout << "sc_bv_base::operator >> ( int ) const" << endl; 369 370 sc_bv_base a( 1, 70 ); 371 a[69] = 0; 372 WRITE( a ); 373 sc_bv_base b( 70 ); 374 try { 375 b = a >> -1; 376 WRITE( b ); 377 } 378 catch( sc_report x ) { 379 cout << "\ncaught exception" << endl; 380 cout << x.what() << endl; 381 } 382 b = a >> 3; 383 WRITE( b ); 384 b = a >> 33; 385 WRITE( b ); 386 b = a >> 72; 387 WRITE( b ); 388 } 389 { 390 cout << "sc_lv_base::operator >>= ( int )" << endl; 391 392 sc_lv_base a( SC_LOGIC_X, 70 ); 393 a[69] = SC_LOGIC_Z; 394 WRITE( a ); 395 try { 396 a >>= -1; 397 WRITE( a ); 398 } 399 catch( sc_report x ) { 400 cout << "\ncaught exception" << endl; 401 cout << x.what() << endl; 402 } 403 a >>= 3; 404 WRITE( a ); 405 a >>= 33; 406 WRITE( a ); 407 a >>= 72; 408 WRITE( a ); 409 } 410 { 411 cout << "sc_lv_base::operator >> ( int ) const" << endl; 412 413 sc_lv_base a( SC_LOGIC_X, 70 ); 414 a[69] = SC_LOGIC_Z; 415 WRITE( a ); 416 sc_lv_base b( 70 ); 417 try { 418 b = a >> -1; 419 WRITE( b ); 420 } 421 catch( sc_report x ) { 422 cout << "\ncaught exception" << endl; 423 cout << x.what() << endl; 424 } 425 b = a >> 3; 426 WRITE( b ); 427 b = a >> 33; 428 WRITE( b ); 429 b = a >> 72; 430 WRITE( b ); 431 } 432 { 433 cout << "sc_proxy<X>::operator >>= ( int )" << endl; 434 435 sc_lv_base a( SC_LOGIC_X, 70 ); 436 a[69] = SC_LOGIC_Z; 437 WRITE( a ); 438 try { 439 (a( 69, 20 ), a( 19, 0 )) >>= -1; 440 WRITE( a ); 441 } 442 catch( sc_report x ) { 443 cout << "\ncaught exception" << endl; 444 cout << x.what() << endl; 445 } 446 (a( 69, 20 ), a( 19, 0 )) >>= 3; 447 WRITE( a ); 448 (a( 69, 20 ), a( 19, 0 )) >>= 33; 449 WRITE( a ); 450 (a( 69, 20 ), a( 19, 0 )) >>= 72; 451 WRITE( a ); 452 } 453 { 454 cout << "sc_proxy<X>::operator >> ( int ) const" << endl; 455 456 sc_lv_base a( SC_LOGIC_X, 70 ); 457 a[69] = SC_LOGIC_Z; 458 WRITE( a ); 459 sc_lv_base b( 70 ); 460 try { 461 b = (a( 69, 20 ), a( 19, 0 )) >> -1; 462 WRITE( b ); 463 } 464 catch( sc_report x ) { 465 cout << "\ncaught exception" << endl; 466 cout << x.what() << endl; 467 } 468 b = (a( 69, 20 ), a( 19, 0 )) >> 3; 469 WRITE( b ); 470 b = (a( 69, 20 ), a( 19, 0 )) >> 33; 471 WRITE( b ); 472 b = (a( 69, 20 ), a( 19, 0 )) >> 72; 473 WRITE( b ); 474 } 475} 476 477void 478test_bitwise_left_rotate() 479{ 480 cout << "*** test_bitwise_left_rotate" << endl; 481 { 482 cout << "sc_bv_base::lrotate( int )" << endl; 483 484 sc_bv_base a( 1, 70 ); 485 a[0] = 0; 486 WRITE( a ); 487 try { 488 a.lrotate( -1 ); 489 WRITE( a ); 490 } 491 catch( sc_report x ) { 492 cout << "\ncaught exception" << endl; 493 cout << x.what() << endl; 494 } 495 a.lrotate( 3 ); 496 WRITE( a ); 497 a.lrotate( 33 ); 498 WRITE( a ); 499 a.lrotate( 72 ); 500 WRITE( a ); 501 } 502 { 503 cout << "lrotate( const sc_bv_base&, int )" << endl; 504 505 sc_bv_base a( 1, 70 ); 506 a[0] = 0; 507 WRITE( a ); 508 sc_bv_base b( 70 ); 509 try { 510 b = lrotate( a, -1 ); 511 WRITE( b ); 512 } 513 catch( sc_report x ) { 514 cout << "\ncaught exception" << endl; 515 cout << x.what() << endl; 516 } 517 b = lrotate( a, 3 ); 518 WRITE( b ); 519 b = lrotate( a, 33 ); 520 WRITE( b ); 521 b = lrotate( a, 72 ); 522 WRITE( b ); 523 } 524 { 525 cout << "sc_lv_base::lrotate( int )" << endl; 526 527 sc_lv_base a( SC_LOGIC_X, 70 ); 528 a[0] = SC_LOGIC_Z; 529 WRITE( a ); 530 try { 531 a.lrotate( -1 ); 532 WRITE( a ); 533 } 534 catch( sc_report x ) { 535 cout << "\ncaught exception" << endl; 536 cout << x.what() << endl; 537 } 538 a.lrotate( 3 ); 539 WRITE( a ); 540 a.lrotate( 33 ); 541 WRITE( a ); 542 a.lrotate( 72 ); 543 WRITE( a ); 544 } 545 { 546 cout << "lrotate( const sc_lv_base&, int )" << endl; 547 548 sc_lv_base a( SC_LOGIC_X, 70 ); 549 a[0] = SC_LOGIC_Z; 550 WRITE( a ); 551 sc_lv_base b( 70 ); 552 try { 553 b = lrotate( a, -1 ); 554 WRITE( b ); 555 } 556 catch( sc_report x ) { 557 cout << "\ncaught exception" << endl; 558 cout << x.what() << endl; 559 } 560 b = lrotate( a, 3 ); 561 WRITE( b ); 562 b = lrotate( a, 33 ); 563 WRITE( b ); 564 b = lrotate( a, 72 ); 565 WRITE( b ); 566 } 567 { 568 cout << "sc_proxy<X>::lrotate( int )" << endl; 569 570 sc_lv_base a( SC_LOGIC_X, 70 ); 571 a[0] = SC_LOGIC_Z; 572 WRITE( a ); 573 try { 574 (a( 69, 20 ), a( 19, 0 )).lrotate( -1 ); 575 WRITE( a ); 576 } 577 catch( sc_report x ) { 578 cout << "\ncaught exception" << endl; 579 cout << x.what() << endl; 580 } 581 (a( 69, 20 ), a( 19, 0 )).lrotate( 3 ); 582 WRITE( a ); 583 (a( 69, 20 ), a( 19, 0 )).lrotate( 33 ); 584 WRITE( a ); 585 (a( 69, 20 ), a( 19, 0 )).lrotate( 72 ); 586 WRITE( a ); 587 } 588 { 589 cout << "lrotate( const sc_proxy<X>&, int )" << endl; 590 591 sc_lv_base a( SC_LOGIC_X, 70 ); 592 a[0] = SC_LOGIC_Z; 593 WRITE( a ); 594 sc_lv_base b( 70 ); 595 try { 596 b = lrotate( (a( 69, 20 ), a( 19, 0 )), -1 ); 597 WRITE( b ); 598 } 599 catch( sc_report x ) { 600 cout << "\ncaught exception" << endl; 601 cout << x.what() << endl; 602 } 603 b = lrotate( (a( 69, 20 ), a( 19, 0 )), 3 ); 604 WRITE( b ); 605 b = lrotate( (a( 69, 20 ), a( 19, 0 )), 33 ); 606 WRITE( b ); 607 b = lrotate( (a( 69, 20 ), a( 19, 0 )), 72 ); 608 WRITE( b ); 609 } 610} 611 612void 613test_bitwise_right_rotate() 614{ 615 cout << "*** test_bitwise_right_rotate" << endl; 616 { 617 cout << "sc_bv_base::rrotate( int )" << endl; 618 619 sc_bv_base a( 1, 70 ); 620 a[69] = 0; 621 WRITE( a ); 622 try { 623 a.rrotate( -1 ); 624 WRITE( a ); 625 } 626 catch( sc_report x ) { 627 cout << "\ncaught exception" << endl; 628 cout << x.what() << endl; 629 } 630 a.rrotate( 3 ); 631 WRITE( a ); 632 a.rrotate( 33 ); 633 WRITE( a ); 634 a.rrotate( 72 ); 635 WRITE( a ); 636 } 637 { 638 cout << "rrotate( const sc_bv_base&, int )" << endl; 639 640 sc_bv_base a( 1, 70 ); 641 a[69] = 0; 642 WRITE( a ); 643 sc_bv_base b( 70 ); 644 try { 645 b = rrotate( a, -1 ); 646 WRITE( b ); 647 } 648 catch( sc_report x ) { 649 cout << "\ncaught exception" << endl; 650 cout << x.what() << endl; 651 } 652 b = rrotate( a, 3 ); 653 WRITE( b ); 654 b = rrotate( a, 33 ); 655 WRITE( b ); 656 b = rrotate( a, 72 ); 657 WRITE( b ); 658 } 659 { 660 cout << "sc_lv_base::rrotate( int )" << endl; 661 662 sc_lv_base a( SC_LOGIC_X, 70 ); 663 a[69] = SC_LOGIC_Z; 664 WRITE( a ); 665 try { 666 a.rrotate( -1 ); 667 WRITE( a ); 668 } 669 catch( sc_report x ) { 670 cout << "\ncaught exception" << endl; 671 cout << x.what() << endl; 672 } 673 a.rrotate( 3 ); 674 WRITE( a ); 675 a.rrotate( 33 ); 676 WRITE( a ); 677 a.rrotate( 72 ); 678 WRITE( a ); 679 } 680 { 681 cout << "rrotate( const sc_lv_base&, int )" << endl; 682 683 sc_lv_base a( SC_LOGIC_X, 70 ); 684 a[69] = SC_LOGIC_Z; 685 WRITE( a ); 686 sc_lv_base b( 70 ); 687 try { 688 b = rrotate( a, -1 ); 689 WRITE( b ); 690 } 691 catch( sc_report x ) { 692 cout << "\ncaught exception" << endl; 693 cout << x.what() << endl; 694 } 695 b = rrotate( a, 3 ); 696 WRITE( b ); 697 b = rrotate( a, 33 ); 698 WRITE( b ); 699 b = rrotate( a, 72 ); 700 WRITE( b ); 701 } 702 { 703 cout << "sc_proxy<X>::rrotate( int )" << endl; 704 705 sc_lv_base a( SC_LOGIC_X, 70 ); 706 a[69] = SC_LOGIC_Z; 707 WRITE( a ); 708 try { 709 (a( 69, 20 ), a( 19, 0 )).rrotate( -1 ); 710 WRITE( a ); 711 } 712 catch( sc_report x ) { 713 cout << "\ncaught exception" << endl; 714 cout << x.what() << endl; 715 } 716 // FIX ME: BUG, the following three operations result in 0XX.. 717 (a( 69, 20 ), a( 19, 0 )).rrotate( 3 ); 718 WRITE( a ); 719 (a( 69, 20 ), a( 19, 0 )).rrotate( 33 ); 720 WRITE( a ); 721 (a( 69, 20 ), a( 19, 0 )).rrotate( 72 ); 722 WRITE( a ); 723 } 724 { 725 cout << "rrotate( const sc_proxy<X>&, int )" << endl; 726 727 sc_lv_base a( SC_LOGIC_X, 70 ); 728 a[69] = SC_LOGIC_Z; 729 WRITE( a ); 730 sc_lv_base b( 70 ); 731 try { 732 b = rrotate( (a( 69, 20 ), a( 19, 0 )), -1 ); 733 WRITE( b ); 734 } 735 catch( sc_report x ) { 736 cout << "\ncaught exception" << endl; 737 cout << x.what() << endl; 738 } 739 b = rrotate( (a( 69, 20 ), a( 19, 0 )), 3 ); 740 WRITE( b ); 741 b = rrotate( (a( 69, 20 ), a( 19, 0 )), 33 ); 742 WRITE( b ); 743 b = rrotate( (a( 69, 20 ), a( 19, 0 )), 72 ); 744 WRITE( b ); 745 } 746} 747 748void 749test_bitwise_reverse() 750{ 751 cout << "*** test_bitwise_reverse" << endl; 752 { 753 cout << "sc_bv_base::reverse()" << endl; 754 755 sc_bv_base a( "1111000", 7 ); 756 WRITE( a ); 757 a.reverse(); 758 WRITE( a ); 759 sc_bv_base b( "11110000", 8 ); 760 WRITE( b ); 761 b.reverse(); 762 WRITE( b ); 763 } 764 { 765 cout << "reverse( const sc_bv_base& )" << endl; 766 767 sc_bv_base a( "1111000", 7 ); 768 WRITE( a ); 769 sc_bv_base b( 7 ); 770 b = reverse( a ); 771 WRITE( b ); 772 sc_bv_base c( "11110000", 8 ); 773 WRITE( c ); 774 sc_bv_base d( 8 ); 775 d = reverse( c ); 776 WRITE( d ); 777 } 778 { 779 cout << "sc_lv_base::reverse()" << endl; 780 781 sc_lv_base a( "01ZX01Z", 7 ); 782 WRITE( a ); 783 a.reverse(); 784 WRITE( a ); 785 sc_lv_base b( "01ZX01ZX", 8 ); 786 WRITE( b ); 787 b.reverse(); 788 WRITE( b ); 789 } 790 { 791 cout << "reverse( const sc_lv_base& )" << endl; 792 793 sc_lv_base a( "01ZX01Z", 7 ); 794 WRITE( a ); 795 sc_lv_base b( 7 ); 796 b = reverse( a ); 797 WRITE( b ); 798 sc_lv_base c( "01ZX01ZX", 8 ); 799 WRITE( c ); 800 sc_lv_base d( 8 ); 801 d = reverse( c ); 802 WRITE( d ); 803 } 804 { 805 cout << "sc_proxy<X>::reverse()" << endl; 806 807 sc_lv_base a( "01ZX01ZX", 8 ); 808 WRITE( a ); 809 (a( 7, 4 ), a( 3, 0 )).reverse(); 810 WRITE( a ); 811 (a( 0, 3 ), a( 4, 7 )).reverse(); 812 WRITE( a ); 813 } 814 { 815 cout << "reverse( const sc_proxy<X>& )" << endl; 816 817 sc_lv_base a( "01ZX01ZX", 8 ); 818 WRITE( a ); 819 sc_lv_base b( 8 ); 820 b = reverse( (a( 7, 4 ), a( 3, 0 )) ); 821 WRITE( b ); 822 b = reverse( (a( 0, 3 ), a( 4, 7 )) ); 823 WRITE( b ); 824 } 825} 826 827void 828test_string_conversions() 829{ 830 cout << "*** test_string_conversions" << endl; 831 { 832 cout << "sc_bv_base" << endl; 833 834 sc_bv_base a( 1, 8 ); 835 sc_bv_base b( 8 ); 836 std::string s; 837 s = a.to_string(); 838 cout << s << endl; 839 b = s.c_str(); 840 sc_assert( b == a ); 841 s = a.to_string( SC_BIN ); 842 cout << s << endl; 843 b = s.c_str(); 844 sc_assert( b == a ); 845 s = a.to_string( SC_BIN_US ); 846 cout << s << endl; 847 b = s.c_str(); 848 sc_assert( b == a ); 849 s = a.to_string( SC_BIN_SM ); 850 cout << s << endl; 851 b = s.c_str(); 852 sc_assert( b == a ); 853 s = a.to_string( SC_OCT ); 854 cout << s << endl; 855 b = s.c_str(); 856 sc_assert( b == a ); 857 s = a.to_string( SC_OCT_US ); 858 cout << s << endl; 859 b = s.c_str(); 860 sc_assert( b == a ); 861 s = a.to_string( SC_OCT_SM ); 862 cout << s << endl; 863 b = s.c_str(); 864 sc_assert( b == a ); 865 s = a.to_string( SC_HEX ); 866 cout << s << endl; 867 b = s.c_str(); 868 sc_assert( b == a ); 869 s = a.to_string( SC_HEX_US ); 870 cout << s << endl; 871 b = s.c_str(); 872 sc_assert( b == a ); 873 s = a.to_string( SC_HEX_SM ); 874 cout << s << endl; 875 b = s.c_str(); 876 sc_assert( b == a ); 877 s = a.to_string( SC_DEC ); 878 cout << s << endl; 879 b = s.c_str(); 880 sc_assert( b == a ); 881 s = a.to_string( SC_CSD ); 882 cout << s << endl; 883 b = s.c_str(); 884 sc_assert( b == a ); 885 } 886 { 887 cout << "sc_lv_base" << endl; 888 889 sc_lv_base a( SC_LOGIC_1, 8 ); 890 sc_lv_base b( 8 ); 891 std::string s; 892 s = a.to_string(); 893 cout << s << endl; 894 b = s.c_str(); 895 sc_assert( b == a ); 896 s = a.to_string( SC_BIN ); 897 cout << s << endl; 898 b = s.c_str(); 899 sc_assert( b == a ); 900 s = a.to_string( SC_BIN_US ); 901 cout << s << endl; 902 b = s.c_str(); 903 sc_assert( b == a ); 904 s = a.to_string( SC_BIN_SM ); 905 cout << s << endl; 906 b = s.c_str(); 907 sc_assert( b == a ); 908 s = a.to_string( SC_OCT ); 909 cout << s << endl; 910 b = s.c_str(); 911 sc_assert( b == a ); 912 s = a.to_string( SC_OCT_US ); 913 cout << s << endl; 914 b = s.c_str(); 915 sc_assert( b == a ); 916 s = a.to_string( SC_OCT_SM ); 917 cout << s << endl; 918 b = s.c_str(); 919 sc_assert( b == a ); 920 s = a.to_string( SC_HEX ); 921 cout << s << endl; 922 b = s.c_str(); 923 sc_assert( b == a ); 924 s = a.to_string( SC_HEX_US ); 925 cout << s << endl; 926 b = s.c_str(); 927 sc_assert( b == a ); 928 s = a.to_string( SC_HEX_SM ); 929 cout << s << endl; 930 b = s.c_str(); 931 sc_assert( b == a ); 932 s = a.to_string( SC_DEC ); 933 cout << s << endl; 934 b = s.c_str(); 935 sc_assert( b == a ); 936 s = a.to_string( SC_CSD ); 937 cout << s << endl; 938 b = s.c_str(); 939 sc_assert( b == a ); 940 } 941 { 942 cout << "sc_proxy<X>" << endl; 943 944 sc_lv_base a( SC_LOGIC_1, 8 ); 945 sc_lv_base b( 8 ); 946 std::string s; 947 s = (a( 7, 4 ), a( 3, 0 )).to_string(); 948 cout << s << endl; 949 (b( 7, 4 ), b( 3, 0 )) = s.c_str(); 950 sc_assert( b == a ); 951 s = (a( 7, 4 ), a( 3, 0 )).to_string( SC_BIN ); 952 cout << s << endl; 953 (b( 7, 4 ), b( 3, 0 )) = s.c_str(); 954 sc_assert( b == a ); 955 s = (a( 7, 4 ), a( 3, 0 )).to_string( SC_BIN_US ); 956 cout << s << endl; 957 (b( 7, 4 ), b( 3, 0 )) = s.c_str(); 958 sc_assert( b == a ); 959 s = (a( 7, 4 ), a( 3, 0 )).to_string( SC_BIN_SM ); 960 cout << s << endl; 961 (b( 7, 4 ), b( 3, 0 )) = s.c_str(); 962 sc_assert( b == a ); 963 s = (a( 7, 4 ), a( 3, 0 )).to_string( SC_OCT ); 964 cout << s << endl; 965 (b( 7, 4 ), b( 3, 0 )) = s.c_str(); 966 sc_assert( b == a ); 967 s = (a( 7, 4 ), a( 3, 0 )).to_string( SC_OCT_US ); 968 cout << s << endl; 969 (b( 7, 4 ), b( 3, 0 )) = s.c_str(); 970 sc_assert( b == a ); 971 s = (a( 7, 4 ), a( 3, 0 )).to_string( SC_OCT_SM ); 972 cout << s << endl; 973 (b( 7, 4 ), b( 3, 0 )) = s.c_str(); 974 sc_assert( b == a ); 975 s = (a( 7, 4 ), a( 3, 0 )).to_string( SC_HEX ); 976 cout << s << endl; 977 (b( 7, 4 ), b( 3, 0 )) = s.c_str(); 978 sc_assert( b == a ); 979 s = (a( 7, 4 ), a( 3, 0 )).to_string( SC_HEX_US ); 980 cout << s << endl; 981 (b( 7, 4 ), b( 3, 0 )) = s.c_str(); 982 sc_assert( b == a ); 983 s = (a( 7, 4 ), a( 3, 0 )).to_string( SC_HEX_SM ); 984 cout << s << endl; 985 (b( 7, 4 ), b( 3, 0 )) = s.c_str(); 986 sc_assert( b == a ); 987 s = (a( 7, 4 ), a( 3, 0 )).to_string( SC_DEC ); 988 cout << s << endl; 989 (b( 7, 4 ), b( 3, 0 )) = s.c_str(); 990 sc_assert( b == a ); 991 s = (a( 7, 4 ), a( 3, 0 )).to_string( SC_CSD ); 992 cout << s << endl; 993 (b( 7, 4 ), b( 3, 0 )) = s.c_str(); 994 sc_assert( b == a ); 995 } 996} 997 998int 999sc_main( int, char*[] ) 1000{ 1001 test_ctors(); 1002 test_bitwise_complement(); 1003 test_bitwise_and(); 1004 test_bitwise_or(); 1005 test_bitwise_xor(); 1006 test_bitwise_left_shift(); 1007 test_bitwise_right_shift(); 1008 test_bitwise_left_rotate(); 1009 test_bitwise_right_rotate(); 1010 test_bitwise_reverse(); 1011 test_string_conversions(); 1012 1013 return 0; 1014} 1015