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