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