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