net.mograsim.logic.core/src/net/mograsim/logic/core/tests/ComponentTest.java

   1 package net.mograsim.logic.core.tests;\r
   2 \r
   3 import static org.junit.Assert.assertTrue;\r
   4 import static org.junit.jupiter.api.Assertions.assertArrayEquals;\r
   5 import static org.junit.jupiter.api.Assertions.assertEquals;\r
   6 import static org.junit.jupiter.api.Assertions.fail;\r
   7 \r
   8 import java.util.function.LongConsumer;\r
   9 \r
  10 import org.junit.jupiter.api.Test;\r
  11 \r
  12 import net.mograsim.logic.core.components.Connector;\r
  13 import net.mograsim.logic.core.components.Demux;\r
  14 import net.mograsim.logic.core.components.Merger;\r
  15 import net.mograsim.logic.core.components.Mux;\r
  16 import net.mograsim.logic.core.components.Splitter;\r
  17 import net.mograsim.logic.core.components.TriStateBuffer;\r
  18 import net.mograsim.logic.core.components.gates.AndGate;\r
  19 import net.mograsim.logic.core.components.gates.NotGate;\r
  20 import net.mograsim.logic.core.components.gates.OrGate;\r
  21 import net.mograsim.logic.core.components.gates.XorGate;\r
  22 import net.mograsim.logic.core.timeline.Timeline;\r
  23 import net.mograsim.logic.core.types.Bit;\r
  24 import net.mograsim.logic.core.types.BitVector;\r
  25 import net.mograsim.logic.core.wires.Wire;\r
  26 import net.mograsim.logic.core.wires.Wire.ReadEnd;\r
  27 import net.mograsim.logic.core.wires.Wire.ReadWriteEnd;\r
  28 \r
  29 class ComponentTest\r
  30 {\r
  31         private Timeline t = new Timeline(11);\r
  32 \r
  33         @Test\r
  34         void circuitExampleTest()\r
  35         {\r
  36                 Wire a = new Wire(t, 1, 1), b = new Wire(t, 1, 1), c = new Wire(t, 1, 10), d = new Wire(t, 2, 1), e = new Wire(t, 1, 1),\r
  37                                 f = new Wire(t, 1, 1), g = new Wire(t, 1, 1), h = new Wire(t, 2, 1), i = new Wire(t, 2, 1), j = new Wire(t, 1, 1),\r
  38                                 k = new Wire(t, 1, 1);\r
  39                 new AndGate(t, 1, f.createReadWriteEnd(), a.createReadOnlyEnd(), b.createReadOnlyEnd());\r
  40                 new NotGate(t, 1, f.createReadOnlyEnd(), g.createReadWriteEnd());\r
  41                 new Merger(t, h.createReadWriteEnd(), c.createReadOnlyEnd(), g.createReadOnlyEnd());\r
  42                 new Mux(t, 1, i.createReadWriteEnd(), e.createReadOnlyEnd(), h.createReadOnlyEnd(), d.createReadOnlyEnd());\r
  43                 new Splitter(t, i.createReadOnlyEnd(), k.createReadWriteEnd(), j.createReadWriteEnd());\r
  44 \r
  45                 a.createReadWriteEnd().feedSignals(Bit.ZERO);\r
  46                 b.createReadWriteEnd().feedSignals(Bit.ONE);\r
  47                 c.createReadWriteEnd().feedSignals(Bit.ZERO);\r
  48                 d.createReadWriteEnd().feedSignals(Bit.ONE, Bit.ONE);\r
  49                 e.createReadWriteEnd().feedSignals(Bit.ZERO);\r
  50 \r
  51                 t.executeAll();\r
  52 \r
  53                 assertEquals(Bit.ONE, j.getValue());\r
  54                 assertEquals(Bit.ZERO, k.getValue());\r
  55         }\r
  56 \r
  57         @Test\r
  58         void splitterTest()\r
  59         {\r
  60                 t.reset();\r
  61                 Wire a = new Wire(t, 3, 1), b = new Wire(t, 2, 1), c = new Wire(t, 3, 1), in = new Wire(t, 8, 1);\r
  62                 in.createReadWriteEnd().feedSignals(Bit.ZERO, Bit.ONE, Bit.ZERO, Bit.ONE, Bit.ZERO, Bit.ONE, Bit.ZERO, Bit.ONE);\r
  63                 new Splitter(t, in.createReadOnlyEnd(), a.createReadWriteEnd(), b.createReadWriteEnd(), c.createReadWriteEnd());\r
  64 \r
  65                 t.executeAll();\r
  66 \r
  67                 assertBitArrayEquals(a.getValues(), Bit.ZERO, Bit.ONE, Bit.ZERO);\r
  68                 assertBitArrayEquals(b.getValues(), Bit.ONE, Bit.ZERO);\r
  69                 assertBitArrayEquals(c.getValues(), Bit.ONE, Bit.ZERO, Bit.ONE);\r
  70         }\r
  71 \r
  72         @Test\r
  73         void mergerTest()\r
  74         {\r
  75                 t.reset();\r
  76                 Wire a = new Wire(t, 3, 1), b = new Wire(t, 2, 1), c = new Wire(t, 3, 1), out = new Wire(t, 8, 1);\r
  77                 a.createReadWriteEnd().feedSignals(Bit.ZERO, Bit.ONE, Bit.ZERO);\r
  78                 b.createReadWriteEnd().feedSignals(Bit.ONE, Bit.ZERO);\r
  79                 c.createReadWriteEnd().feedSignals(Bit.ONE, Bit.ZERO, Bit.ONE);\r
  80 \r
  81                 new Merger(t, out.createReadWriteEnd(), a.createReadOnlyEnd(), b.createReadOnlyEnd(), c.createReadOnlyEnd());\r
  82 \r
  83                 t.executeAll();\r
  84 \r
  85                 assertBitArrayEquals(out.getValues(), Bit.ZERO, Bit.ONE, Bit.ZERO, Bit.ONE, Bit.ZERO, Bit.ONE, Bit.ZERO, Bit.ONE);\r
  86         }\r
  87 \r
  88         @Test\r
  89         void triStateBufferTest()\r
  90         {\r
  91                 Wire a = new Wire(t, 1, 1), b = new Wire(t, 1, 1), en = new Wire(t, 1, 1), notEn = new Wire(t, 1, 1);\r
  92                 new NotGate(t, 1, en.createReadOnlyEnd(), notEn.createReadWriteEnd());\r
  93                 new TriStateBuffer(t, 1, a.createReadOnlyEnd(), b.createReadWriteEnd(), en.createReadOnlyEnd());\r
  94                 new TriStateBuffer(t, 1, b.createReadOnlyEnd(), a.createReadWriteEnd(), notEn.createReadOnlyEnd());\r
  95 \r
  96                 ReadWriteEnd enI = en.createReadWriteEnd(), aI = a.createReadWriteEnd(), bI = b.createReadWriteEnd();\r
  97                 enI.feedSignals(Bit.ONE);\r
  98                 aI.feedSignals(Bit.ONE);\r
  99                 bI.feedSignals(Bit.Z);\r
 100 \r
 101                 t.executeAll();\r
 102 \r
 103                 assertEquals(Bit.ONE, b.getValue());\r
 104 \r
 105                 bI.feedSignals(Bit.ZERO);\r
 106 \r
 107                 t.executeAll();\r
 108 \r
 109                 assertEquals(Bit.X, b.getValue());\r
 110                 assertEquals(Bit.ONE, a.getValue());\r
 111 \r
 112                 aI.clearSignals();\r
 113                 enI.feedSignals(Bit.ZERO);\r
 114 \r
 115                 t.executeAll();\r
 116 \r
 117                 assertEquals(Bit.ZERO, a.getValue());\r
 118 \r
 119         }\r
 120 \r
 121         @Test\r
 122         void muxTest()\r
 123         {\r
 124                 t.reset();\r
 125                 Wire a = new Wire(t, 4, 3), b = new Wire(t, 4, 6), c = new Wire(t, 4, 4), select = new Wire(t, 2, 5), out = new Wire(t, 4, 1);\r
 126                 ReadWriteEnd selectIn = select.createReadWriteEnd();\r
 127 \r
 128                 selectIn.feedSignals(Bit.ZERO, Bit.ZERO);\r
 129                 a.createReadWriteEnd().feedSignals(Bit.ONE, Bit.ZERO, Bit.ONE, Bit.ZERO);\r
 130                 c.createReadWriteEnd().feedSignals(Bit.ZERO, Bit.ONE, Bit.ZERO, Bit.ONE);\r
 131 \r
 132                 new Mux(t, 1, out.createReadWriteEnd(), select.createReadOnlyEnd(), a.createReadOnlyEnd(), b.createReadOnlyEnd(),\r
 133                                 c.createReadOnlyEnd());\r
 134                 t.executeAll();\r
 135 \r
 136                 assertBitArrayEquals(out.getValues(), Bit.ONE, Bit.ZERO, Bit.ONE, Bit.ZERO);\r
 137                 selectIn.feedSignals(Bit.ZERO, Bit.ONE);\r
 138                 t.executeAll();\r
 139 \r
 140                 assertBitArrayEquals(out.getValues(), Bit.ZERO, Bit.ONE, Bit.ZERO, Bit.ONE);\r
 141 \r
 142                 selectIn.feedSignals(Bit.ONE, Bit.ONE);\r
 143                 t.executeAll();\r
 144 \r
 145                 assertBitArrayEquals(out.getValues(), Bit.Z, Bit.Z, Bit.Z, Bit.Z);\r
 146 \r
 147         }\r
 148 \r
 149         @Test\r
 150         void demuxTest()\r
 151         {\r
 152                 t.reset();\r
 153                 Wire a = new Wire(t, 4, 3), b = new Wire(t, 4, 6), c = new Wire(t, 4, 4), select = new Wire(t, 2, 5), in = new Wire(t, 4, 1);\r
 154                 ReadWriteEnd selectIn = select.createReadWriteEnd();\r
 155 \r
 156                 selectIn.feedSignals(Bit.ZERO, Bit.ZERO);\r
 157                 in.createReadWriteEnd().feedSignals(Bit.ONE, Bit.ZERO, Bit.ONE, Bit.ZERO);\r
 158 \r
 159                 new Demux(t, 1, in.createReadOnlyEnd(), select.createReadOnlyEnd(), a.createReadWriteEnd(), b.createReadWriteEnd(),\r
 160                                 c.createReadWriteEnd());\r
 161                 t.executeAll();\r
 162 \r
 163                 assertBitArrayEquals(a.getValues(), Bit.ONE, Bit.ZERO, Bit.ONE, Bit.ZERO);\r
 164                 assertBitArrayEquals(b.getValues(), Bit.U, Bit.U, Bit.U, Bit.U);\r
 165                 assertBitArrayEquals(c.getValues(), Bit.U, Bit.U, Bit.U, Bit.U);\r
 166                 selectIn.feedSignals(Bit.ZERO, Bit.ONE);\r
 167                 t.executeAll();\r
 168 \r
 169                 assertBitArrayEquals(a.getValues(), Bit.Z, Bit.Z, Bit.Z, Bit.Z);\r
 170                 assertBitArrayEquals(b.getValues(), Bit.U, Bit.U, Bit.U, Bit.U);\r
 171                 assertBitArrayEquals(c.getValues(), Bit.ONE, Bit.ZERO, Bit.ONE, Bit.ZERO);\r
 172 \r
 173                 selectIn.feedSignals(Bit.ONE, Bit.ONE);\r
 174                 t.executeAll();\r
 175 \r
 176                 assertBitArrayEquals(a.getValues(), Bit.Z, Bit.Z, Bit.Z, Bit.Z);\r
 177                 assertBitArrayEquals(b.getValues(), Bit.U, Bit.U, Bit.U, Bit.U);\r
 178                 assertBitArrayEquals(c.getValues(), Bit.Z, Bit.Z, Bit.Z, Bit.Z);\r
 179 \r
 180         }\r
 181 \r
 182         @Test\r
 183         void andTest()\r
 184         {\r
 185                 t.reset();\r
 186                 Wire a = new Wire(t, 4, 1), b = new Wire(t, 4, 3), c = new Wire(t, 4, 1);\r
 187                 new AndGate(t, 1, c.createReadWriteEnd(), a.createReadOnlyEnd(), b.createReadOnlyEnd());\r
 188                 a.createReadWriteEnd().feedSignals(Bit.ONE, Bit.ONE, Bit.ZERO, Bit.ZERO);\r
 189                 b.createReadWriteEnd().feedSignals(Bit.ZERO, Bit.ONE, Bit.ZERO, Bit.ONE);\r
 190 \r
 191                 t.executeAll();\r
 192 \r
 193                 assertBitArrayEquals(c.getValues(), Bit.ZERO, Bit.ONE, Bit.ZERO, Bit.ZERO);\r
 194         }\r
 195 \r
 196         @Test\r
 197         void orTest()\r
 198         {\r
 199                 t.reset();\r
 200                 Wire a = new Wire(t, 4, 1), b = new Wire(t, 4, 3), c = new Wire(t, 4, 1);\r
 201                 new OrGate(t, 1, c.createReadWriteEnd(), a.createReadOnlyEnd(), b.createReadOnlyEnd());\r
 202                 a.createReadWriteEnd().feedSignals(Bit.ONE, Bit.ONE, Bit.ZERO, Bit.ZERO);\r
 203                 b.createReadWriteEnd().feedSignals(Bit.ZERO, Bit.ONE, Bit.ZERO, Bit.ONE);\r
 204 \r
 205                 t.executeAll();\r
 206 \r
 207                 assertBitArrayEquals(c.getValues(), Bit.ONE, Bit.ONE, Bit.ZERO, Bit.ONE);\r
 208         }\r
 209 \r
 210         @Test\r
 211         void xorTest()\r
 212         {\r
 213                 t.reset();\r
 214                 Wire a = new Wire(t, 3, 1), b = new Wire(t, 3, 2), c = new Wire(t, 3, 1), d = new Wire(t, 3, 1);\r
 215                 new XorGate(t, 1, d.createReadWriteEnd(), a.createReadOnlyEnd(), b.createReadOnlyEnd(), c.createReadOnlyEnd());\r
 216                 a.createReadWriteEnd().feedSignals(Bit.ZERO, Bit.ONE, Bit.ONE);\r
 217                 b.createReadWriteEnd().feedSignals(Bit.ONE, Bit.ZERO, Bit.ONE);\r
 218                 c.createReadWriteEnd().feedSignals(Bit.ONE, Bit.ZERO, Bit.ONE);\r
 219 \r
 220                 t.executeAll();\r
 221 \r
 222                 assertBitArrayEquals(d.getValues(), Bit.ZERO, Bit.ONE, Bit.ONE);\r
 223         }\r
 224 \r
 225         @Test\r
 226         void notTest()\r
 227         {\r
 228                 t.reset();\r
 229                 Wire a = new Wire(t, 3, 1), b = new Wire(t, 3, 2);\r
 230                 new NotGate(t, 1, a.createReadOnlyEnd(), b.createReadWriteEnd());\r
 231                 a.createReadWriteEnd().feedSignals(Bit.ZERO, Bit.ONE, Bit.ONE);\r
 232 \r
 233                 t.executeAll();\r
 234 \r
 235                 assertBitArrayEquals(b.getValues(), Bit.ONE, Bit.ZERO, Bit.ZERO);\r
 236         }\r
 237 \r
 238         @Test\r
 239         void rsLatchCircuitTest()\r
 240         {\r
 241                 t.reset();\r
 242                 Wire r = new Wire(t, 1, 1), s = new Wire(t, 1, 1), t1 = new Wire(t, 1, 15), t2 = new Wire(t, 1, 1), q = new Wire(t, 1, 1),\r
 243                                 nq = new Wire(t, 1, 1);\r
 244 \r
 245                 new OrGate(t, 1, t2.createReadWriteEnd(), r.createReadOnlyEnd(), nq.createReadOnlyEnd());\r
 246                 new OrGate(t, 1, t1.createReadWriteEnd(), s.createReadOnlyEnd(), q.createReadOnlyEnd());\r
 247                 new NotGate(t, 1, t2.createReadOnlyEnd(), q.createReadWriteEnd());\r
 248                 new NotGate(t, 1, t1.createReadOnlyEnd(), nq.createReadWriteEnd());\r
 249 \r
 250                 ReadWriteEnd sIn = s.createReadWriteEnd(), rIn = r.createReadWriteEnd();\r
 251 \r
 252                 sIn.feedSignals(Bit.ONE);\r
 253                 rIn.feedSignals(Bit.ZERO);\r
 254 \r
 255                 t.executeAll();\r
 256 \r
 257                 assertEquals(Bit.ONE, q.getValue());\r
 258                 assertEquals(Bit.ZERO, nq.getValue());\r
 259 \r
 260                 sIn.feedSignals(Bit.ZERO);\r
 261 \r
 262                 t.executeAll();\r
 263                 assertEquals(Bit.ONE, q.getValue());\r
 264                 assertEquals(Bit.ZERO, nq.getValue());\r
 265 \r
 266                 rIn.feedSignals(Bit.ONE);\r
 267 \r
 268                 t.executeAll();\r
 269 \r
 270                 assertEquals(Bit.ZERO, q.getValue());\r
 271                 assertEquals(Bit.ONE, nq.getValue());\r
 272         }\r
 273 \r
 274         @Test\r
 275         void numericValueTest()\r
 276         {\r
 277                 t.reset();\r
 278 \r
 279                 Wire a = new Wire(t, 4, 1);\r
 280                 a.createReadWriteEnd().feedSignals(Bit.ONE, Bit.ONE, Bit.ONE, Bit.ONE);\r
 281 \r
 282                 t.executeAll();\r
 283 \r
 284                 assertEquals(15, a.getUnsignedValue());\r
 285                 assertEquals(-1, a.getSignedValue());\r
 286         }\r
 287 \r
 288         boolean flag = false;\r
 289 \r
 290         @Test\r
 291         void simpleTimelineTest()\r
 292         {\r
 293                 Timeline t = new Timeline(3);\r
 294                 flag = false;\r
 295                 t.addEvent((e) ->\r
 296                 {\r
 297                         if (!flag)\r
 298                                 fail("Events executed out of order!");\r
 299                         flag = false;\r
 300                 }, 15);\r
 301                 t.addEvent((e) ->\r
 302                 {\r
 303                         if (flag)\r
 304                                 fail("Events executed out of order!");\r
 305                         flag = true;\r
 306                 }, 10);\r
 307                 t.addEvent((e) ->\r
 308                 {\r
 309                         if (flag)\r
 310                                 fail("Events executed out of order!");\r
 311                         flag = true;\r
 312                 }, 20);\r
 313                 t.addEvent((e) ->\r
 314                 {\r
 315                         fail("Only supposed to execute until timestamp 20, not 25");\r
 316                 }, 25);\r
 317 \r
 318                 t.executeUntil(t.laterThan(20), 100);\r
 319 \r
 320                 if (!flag)\r
 321                         fail("Not all events were executed in order!");\r
 322         }\r
 323 \r
 324         @Test\r
 325         void multipleInputs()\r
 326         {\r
 327                 t.reset();\r
 328                 Wire w = new Wire(t, 2, 1);\r
 329                 ReadWriteEnd wI1 = w.createReadWriteEnd(), wI2 = w.createReadWriteEnd();\r
 330                 wI1.feedSignals(Bit.ONE, Bit.Z);\r
 331                 wI2.feedSignals(Bit.Z, Bit.X);\r
 332                 t.executeAll();\r
 333                 assertBitArrayEquals(w.getValues(), Bit.ONE, Bit.X);\r
 334 \r
 335                 wI2.feedSignals(Bit.ZERO, Bit.Z);\r
 336                 t.executeAll();\r
 337                 assertBitArrayEquals(w.getValues(), Bit.X, Bit.Z);\r
 338 \r
 339                 wI2.feedSignals(Bit.Z, Bit.Z);\r
 340                 t.executeAll();\r
 341                 assertBitArrayEquals(w.getValues(), Bit.ONE, Bit.Z);\r
 342 \r
 343                 wI2.feedSignals(Bit.ONE, Bit.Z);\r
 344                 ReadEnd rE = w.createReadOnlyEnd();\r
 345                 rE.registerObserver((i) -> fail("WireEnd notified observer, although value did not change."));\r
 346                 t.executeAll();\r
 347                 rE.close();\r
 348                 wI1.feedSignals(Bit.X, Bit.X);\r
 349                 t.executeAll();\r
 350                 wI1.registerObserver((i) -> fail("WireEnd notified observer, although it was closed."));\r
 351                 wI1.close();\r
 352                 assertBitArrayEquals(w.getValues(), Bit.ONE, Bit.Z);\r
 353         }\r
 354 \r
 355         @Test\r
 356         void wireConnections()\r
 357         {\r
 358                 // Nur ein Experiment, was über mehrere 'passive' Bausteine hinweg passieren würde\r
 359 \r
 360                 t.reset();\r
 361 \r
 362                 Wire a = new Wire(t, 1, 2);\r
 363                 Wire b = new Wire(t, 1, 2);\r
 364                 Wire c = new Wire(t, 1, 2);\r
 365                 ReadWriteEnd aI = a.createReadWriteEnd();\r
 366                 ReadWriteEnd bI = b.createReadWriteEnd();\r
 367                 ReadWriteEnd cI = c.createReadWriteEnd();\r
 368 \r
 369                 TestBitDisplay test = new TestBitDisplay(t, c.createReadOnlyEnd());\r
 370                 TestBitDisplay test2 = new TestBitDisplay(t, a.createReadOnlyEnd());\r
 371                 LongConsumer print = time -> System.out.format("Time %2d\n   a: %s\n   b: %s\n   c: %s\n", time, a, b, c);\r
 372 \r
 373                 cI.feedSignals(Bit.ONE);\r
 374                 test.assertAfterSimulationIs(print, Bit.ONE);\r
 375 \r
 376                 cI.feedSignals(Bit.X);\r
 377                 test.assertAfterSimulationIs(print, Bit.X);\r
 378 \r
 379                 cI.feedSignals(Bit.X);\r
 380                 cI.feedSignals(Bit.Z);\r
 381                 test.assertAfterSimulationIs(print, Bit.Z);\r
 382 \r
 383                 new Connector(t, b.createReadWriteEnd(), c.createReadWriteEnd()).connect();\r
 384                 test.assertAfterSimulationIs(print, Bit.Z);\r
 385                 System.err.println("ONE");\r
 386                 bI.feedSignals(Bit.ONE);\r
 387                 test.assertAfterSimulationIs(print, Bit.ONE);\r
 388                 System.err.println("ZERO");\r
 389                 bI.feedSignals(Bit.ZERO);\r
 390                 test.assertAfterSimulationIs(print, Bit.ZERO);\r
 391                 System.err.println("Z");\r
 392                 bI.feedSignals(Bit.Z);\r
 393                 test.assertAfterSimulationIs(print, Bit.Z);\r
 394 \r
 395                 new Connector(t, a.createReadWriteEnd(), b.createReadWriteEnd()).connect();\r
 396                 System.err.println("Z 2");\r
 397                 aI.feedSignals(Bit.Z);\r
 398                 test.assertAfterSimulationIs(print, Bit.Z);\r
 399                 test2.assertAfterSimulationIs(Bit.Z);\r
 400                 System.err.println("ONE 2");\r
 401                 aI.feedSignals(Bit.ONE);\r
 402                 test.assertAfterSimulationIs(print, Bit.ONE);\r
 403                 test2.assertAfterSimulationIs(Bit.ONE);\r
 404                 System.err.println("ZERO 2");\r
 405                 aI.feedSignals(Bit.ZERO);\r
 406                 test.assertAfterSimulationIs(print, Bit.ZERO);\r
 407                 test2.assertAfterSimulationIs(Bit.ZERO);\r
 408                 System.err.println("Z 2 II");\r
 409                 aI.feedSignals(Bit.Z);\r
 410                 test.assertAfterSimulationIs(print, Bit.Z);\r
 411                 test2.assertAfterSimulationIs(Bit.Z);\r
 412 \r
 413                 System.err.println("No Conflict yet");\r
 414                 bI.feedSignals(Bit.ONE);\r
 415                 test.assertAfterSimulationIs(print, Bit.ONE);\r
 416                 test2.assertAfterSimulationIs(Bit.ONE);\r
 417                 aI.feedSignals(Bit.ONE);\r
 418                 test.assertAfterSimulationIs(print, Bit.ONE);\r
 419                 test2.assertAfterSimulationIs(Bit.ONE);\r
 420                 System.err.println("Conflict");\r
 421                 aI.feedSignals(Bit.ZERO);\r
 422                 test.assertAfterSimulationIs(print, Bit.X);\r
 423                 test2.assertAfterSimulationIs(Bit.X);\r
 424                 aI.feedSignals(Bit.ONE);\r
 425                 test.assertAfterSimulationIs(print, Bit.ONE);\r
 426                 test2.assertAfterSimulationIs(Bit.ONE);\r
 427         }\r
 428 \r
 429         private static void assertBitArrayEquals(BitVector actual, Bit... expected)\r
 430         {\r
 431                 assertArrayEquals(expected, actual.getBits());\r
 432         }\r
 433 }\r