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