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