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