tests/net.mograsim.logic.core.tests/src/net/mograsim/logic/core/types/BitVectorTest.java

   1 package net.mograsim.logic.core.types;
   2
   3 import static net.mograsim.logic.core.types.BitVector.*;
   4 import static net.mograsim.logic.core.types.Bit.*;
   5 import static org.junit.jupiter.api.Assertions.*;
   6
   7 import java.math.BigInteger;
   8 import java.util.Iterator;
   9
  10 import org.junit.jupiter.api.Test;
  11
  12 @SuppressWarnings("static-method") // JUnit requires non-static methods
  13 class BitVectorTest
  14 {
  15
  16         @Test
  17         void testOfBitArray()
  18         {
  19                 BitVector.of(); // should be allowed and work
  20
  21                 assertSame(SINGLE_U, BitVector.of(U));
  22                 assertSame(SINGLE_X, BitVector.of(X));
  23                 assertSame(SINGLE_0, BitVector.of(ZERO));
  24                 assertSame(SINGLE_1, BitVector.of(ONE));
  25                 assertSame(SINGLE_Z, BitVector.of(Z));
  26         }
  27
  28         @Test
  29         void testOfBitInt()
  30         {
  31                 assertEquals(BitVector.of(), BitVector.of(ONE, 0));
  32
  33                 assertSame(SINGLE_U, BitVector.of(U, 1));
  34                 assertSame(SINGLE_X, BitVector.of(X, 1));
  35                 assertSame(SINGLE_0, BitVector.of(ZERO, 1));
  36                 assertSame(SINGLE_1, BitVector.of(ONE, 1));
  37                 assertSame(SINGLE_Z, BitVector.of(Z, 1));
  38
  39                 assertEquals(BitVector.of(X, X, X), BitVector.of(X, 3));
  40         }
  41
  42         @Test
  43         void testGetUnsignedValue()
  44         {
  45                 assertEquals(BigInteger.valueOf(0b101), BitVector.parse("101").getUnsignedValue());
  46                 assertEquals(BigInteger.valueOf(0b01010), BitVector.parse("01010").getUnsignedValue());
  47                 assertEquals(BigInteger.valueOf(0), BitVector.parse("0000").getUnsignedValue());
  48                 assertEquals(BigInteger.valueOf(0b0000000101), BitVector.parse("0000000101").getUnsignedValue());
  49                 assertEquals(BigInteger.valueOf(0b1010000000), BitVector.parse("1010000000").getUnsignedValue());
  50
  51                 assertThrows(NumberFormatException.class, () -> BitVector.parse("00X1").getUnsignedValue());
  52         }
  53
  54         @Test
  55         void testOfLongInt()
  56         {
  57                 assertEquals(BitVector.parse("101"), BitVector.from(0b101L, 3));
  58                 assertEquals(BitVector.parse("01010"), BitVector.from(0b01010L, 5));
  59                 assertEquals(BitVector.parse("10101"), BitVector.from(-11L, 5));
  60                 assertEquals(BitVector.parse("0000"), BitVector.from(0L, 4));
  61         }
  62
  63         @Test
  64         void testOfBigIntegerInt()
  65         {
  66                 assertEquals(BitVector.parse("101"), BitVector.from(BigInteger.valueOf(0b101), 3));
  67                 assertEquals(BitVector.parse("01010"), BitVector.from(BigInteger.valueOf(0b01010), 5));
  68                 assertEquals(BitVector.parse("10101"), BitVector.from(BigInteger.valueOf(-11), 5));
  69                 assertEquals(BitVector.parse("0000"), BitVector.from(BigInteger.valueOf(0), 4));
  70         }
  71
  72         @Test
  73         void testMutator()
  74         {
  75                 var bv = BitVector.SINGLE_1;
  76                 var bvm = bv.mutator();
  77
  78                 assertFalse(bvm.isEmpty());
  79                 assertEquals(ONE, bvm.getLSBit(0));
  80                 assertEquals(SINGLE_1, bvm.toBitVector());
  81         }
  82
  83         @Test
  84         void testGetMSBit()
  85         {
  86                 assertEquals(ONE, SINGLE_1.getMSBit(0));
  87                 assertEquals(ONE, BitVector.of(ONE, X, X, X).getMSBit(0));
  88                 assertEquals(ONE, BitVector.of(X, X, X, X, ONE, X).getMSBit(4));
  89         }
  90
  91         @Test
  92         void testGetLSBit()
  93         {
  94                 assertEquals(ONE, SINGLE_1.getLSBit(0));
  95                 assertEquals(ONE, BitVector.of(X, X, X, ONE).getLSBit(0));
  96                 assertEquals(ONE, BitVector.of(X, X, X, X, ONE, X).getLSBit(1));
  97         }
  98
  99         @Test
 100         void testGetBits()
 101         {
 102                 assertArrayEquals(new Bit[] { X, ONE, Z }, BitVector.of(X, ONE, Z).getBits());
 103                 assertArrayEquals(new Bit[] { X, ONE, Z }, BitVector.parse("X1Z").getBits());
 104         }
 105
 106         @Test
 107         void testIsBinary()
 108         {
 109                 assertTrue(SINGLE_0.isBinary());
 110                 assertTrue(SINGLE_1.isBinary());
 111
 112                 assertFalse(SINGLE_U.isBinary());
 113                 assertFalse(SINGLE_X.isBinary());
 114                 assertFalse(SINGLE_Z.isBinary());
 115
 116                 assertTrue(BitVector.of(ONE, ZERO, ONE, ONE, ZERO).isBinary());
 117                 assertFalse(BitVector.of(ONE, ZERO, ZERO, X).isBinary());
 118         }
 119
 120         @Test
 121         void testJoin()
 122         {
 123                 // binary
 124                 assertEquals(SINGLE_0, SINGLE_0.join(SINGLE_0));
 125                 assertEquals(SINGLE_X, SINGLE_0.join(SINGLE_1));
 126                 assertEquals(SINGLE_1, SINGLE_1.join(SINGLE_1));
 127
 128                 // other
 129                 assertEquals(SINGLE_1, SINGLE_Z.join(SINGLE_1));
 130                 assertEquals(SINGLE_U, SINGLE_0.join(SINGLE_U));
 131                 assertEquals(SINGLE_X, SINGLE_X.join(SINGLE_Z));
 132
 133                 // higher length
 134                 var result = BitVector.of(U, X, ZERO, ONE, Z).join(BitVector.of(ONE, ZERO, ZERO, ONE, Z));
 135                 assertEquals(BitVector.of(U, X, ZERO, ONE, Z), result);
 136         }
 137
 138         @Test
 139         void testAnd()
 140         {
 141                 // binary
 142                 assertEquals(SINGLE_0, SINGLE_0.and(SINGLE_0));
 143                 assertEquals(SINGLE_0, SINGLE_0.and(SINGLE_1));
 144                 assertEquals(SINGLE_1, SINGLE_1.and(SINGLE_1));
 145
 146                 // other
 147                 assertEquals(SINGLE_X, SINGLE_Z.and(SINGLE_1));
 148                 assertEquals(SINGLE_0, SINGLE_0.and(SINGLE_U));
 149                 assertEquals(SINGLE_X, SINGLE_X.and(SINGLE_Z));
 150
 151                 // higher length
 152                 var result = BitVector.of(U, X, ZERO, ONE, ONE).and(BitVector.of(ONE, ONE, ZERO, ZERO, ONE));
 153                 assertEquals(BitVector.of(U, X, ZERO, ZERO, ONE), result);
 154         }
 155
 156         @Test
 157         void testOr()
 158         {
 159                 // binary
 160                 assertEquals(SINGLE_0, SINGLE_0.or(SINGLE_0));
 161                 assertEquals(SINGLE_1, SINGLE_0.or(SINGLE_1));
 162                 assertEquals(SINGLE_1, SINGLE_1.or(SINGLE_1));
 163
 164                 // other
 165                 assertEquals(SINGLE_1, SINGLE_Z.or(SINGLE_1));
 166                 assertEquals(SINGLE_1, SINGLE_1.or(SINGLE_U));
 167                 assertEquals(SINGLE_X, SINGLE_X.or(SINGLE_Z));
 168
 169                 // higher length
 170                 var result = BitVector.of(U, X, ZERO, ONE, ZERO).or(BitVector.of(ZERO, ZERO, ZERO, ONE, ONE));
 171                 assertEquals(BitVector.of(U, X, ZERO, ONE, ONE), result);
 172         }
 173
 174         @Test
 175         void testXor()
 176         {
 177                 // binary
 178                 assertEquals(SINGLE_0, SINGLE_0.xor(SINGLE_0));
 179                 assertEquals(SINGLE_1, SINGLE_0.xor(SINGLE_1));
 180                 assertEquals(SINGLE_0, SINGLE_1.xor(SINGLE_1));
 181
 182                 // other
 183                 assertEquals(SINGLE_X, SINGLE_Z.xor(SINGLE_1));
 184                 assertEquals(SINGLE_U, SINGLE_0.xor(SINGLE_U));
 185                 assertEquals(SINGLE_X, SINGLE_X.xor(SINGLE_Z));
 186
 187                 // higher length
 188                 var result = BitVector.of(U, X, ZERO, ONE, ONE).xor(BitVector.of(ONE, ZERO, ZERO, ZERO, ONE));
 189                 assertEquals(BitVector.of(U, X, ZERO, ONE, ZERO), result);
 190         }
 191
 192         @Test
 193         void testNot()
 194         {
 195                 // binary
 196                 assertEquals(SINGLE_1, SINGLE_0.not());
 197                 assertEquals(SINGLE_0, SINGLE_1.not());
 198
 199                 // other
 200                 assertEquals(SINGLE_U, SINGLE_U.not());
 201                 assertEquals(SINGLE_X, SINGLE_X.not());
 202                 assertEquals(SINGLE_X, SINGLE_Z.not());
 203
 204                 // higher length
 205                 var result = BitVector.of(U, X, ZERO, ONE, Z).not();
 206                 assertEquals(BitVector.of(U, X, ONE, ZERO, X), result);
 207         }
 208
 209         @Test
 210         void testLength()
 211         {
 212                 assertEquals(0, BitVector.of().length());
 213                 assertEquals(1, SINGLE_0.length());
 214                 assertEquals(3, BitVector.of(X, X, Z).length());
 215         }
 216
 217         @Test
 218         void testConcat()
 219         {
 220                 assertEquals(BitVector.of(U, X), SINGLE_U.concat(SINGLE_X));
 221                 assertEquals(BitVector.of(Z, X, U, ONE, X), BitVector.of(Z, X, U).concat(BitVector.of(ONE, X)));
 222         }
 223
 224         @Test
 225         void testSubVectorInt()
 226         {
 227                 assertEquals(SINGLE_0, SINGLE_0.subVector(0));
 228                 assertEquals(BitVector.of(), SINGLE_0.subVector(1));
 229                 assertEquals(SINGLE_0, BitVector.of(ONE, ZERO).subVector(1));
 230                 assertEquals(BitVector.of(X, Z), BitVector.of(ZERO, U, ONE, X, Z).subVector(3));
 231         }
 232
 233         @Test
 234         void testSubVectorIntInt()
 235         {
 236                 assertEquals(SINGLE_0, SINGLE_0.subVector(0, 1));
 237                 assertEquals(BitVector.of(), SINGLE_0.subVector(0, 0));
 238                 assertEquals(SINGLE_0, BitVector.of(ONE, ZERO).subVector(1, 2));
 239                 assertEquals(BitVector.of(ONE, X), BitVector.of(ZERO, U, ONE, X, Z).subVector(2, 4));
 240         }
 241
 242         @Test
 243         void testEqualsObject()
 244         {
 245                 assertEquals(SINGLE_X, SINGLE_X);
 246                 assertNotEquals(SINGLE_0, SINGLE_1);
 247
 248                 assertEquals(BitVector.of(X, Z, U), BitVector.of(X, Z, U));
 249                 assertNotEquals(BitVector.of(X, Z, U), BitVector.of(X, X, U));
 250         }
 251
 252         @Test
 253         void testEqualsWithOffset()
 254         {
 255                 assertTrue(SINGLE_X.equalsWithOffset(SINGLE_X, 0));
 256                 assertFalse(SINGLE_0.equalsWithOffset(SINGLE_1, 0));
 257
 258                 assertTrue(BitVector.of(X, Z, U).equalsWithOffset(BitVector.of(Z, U), 1));
 259                 assertFalse(BitVector.of(X, Z, U).equalsWithOffset(BitVector.of(X, U), 1));
 260                 assertTrue(BitVector.of(X, Z, U).equalsWithOffset(BitVector.of(U), 2));
 261         }
 262
 263         @Test
 264         void testParse()
 265         {
 266                 assertEquals(SINGLE_U, BitVector.parse("U"));
 267                 assertEquals(SINGLE_X, BitVector.parse("X"));
 268                 assertEquals(SINGLE_0, BitVector.parse("0"));
 269                 assertEquals(SINGLE_1, BitVector.parse("1"));
 270                 assertEquals(SINGLE_Z, BitVector.parse("Z"));
 271
 272                 assertEquals(BitVector.of(X, U, Z, ONE, ZERO), BitVector.parse("XUZ10"));
 273
 274                 assertThrows(RuntimeException.class, () -> BitVector.parse("01BX"));
 275         }
 276
 277         @Test
 278         void testIterator()
 279         {
 280                 var bv = BitVector.of(U, Z, ONE, ZERO, X);
 281                 Iterator<Bit> it = bv.iterator();
 282
 283                 assertEquals(U, it.next());
 284                 assertEquals(Z, it.next());
 285                 assertEquals(ONE, it.next());
 286                 assertEquals(ZERO, it.next());
 287                 assertEquals(X, it.next());
 288                 assertFalse(it.hasNext());
 289         }
 290 }