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