net.mograsim.logic.model.am2900/test/net/mograsim/logic/model/am2900/util/TestEnvironmentHelper.java

   1 package net.mograsim.logic.model.am2900.util;
   2
   3 import static org.junit.jupiter.api.Assertions.fail;
   4
   5 import java.lang.reflect.Field;
   6 import java.util.HashMap;
   7 import java.util.HashSet;
   8 import java.util.LinkedList;
   9 import java.util.Objects;
  10 import java.util.Optional;
  11 import java.util.Queue;
  12 import java.util.Set;
  13 import java.util.TreeSet;
  14
  15 import net.mograsim.logic.core.components.CoreBitDisplay;
  16 import net.mograsim.logic.core.components.CoreManualSwitch;
  17 import net.mograsim.logic.core.timeline.Timeline;
  18 import net.mograsim.logic.model.LogicUIStandaloneGUI;
  19 import net.mograsim.logic.model.am2900.Am2900Loader;
  20 import net.mograsim.logic.model.am2900.TestableCircuit;
  21 import net.mograsim.logic.model.am2900.TestableCircuit.Result;
  22 import net.mograsim.logic.model.model.LogicModel;
  23 import net.mograsim.logic.model.model.LogicModelModifiable;
  24 import net.mograsim.logic.model.model.components.ModelComponent;
  25 import net.mograsim.logic.model.model.components.atomic.ModelBitDisplay;
  26 import net.mograsim.logic.model.model.components.atomic.ModelManualSwitch;
  27 import net.mograsim.logic.model.model.components.submodels.SubmodelComponent;
  28 import net.mograsim.logic.model.model.wires.ModelWire;
  29 import net.mograsim.logic.model.model.wires.Pin;
  30 import net.mograsim.logic.model.modeladapter.CoreModelParameters;
  31 import net.mograsim.logic.model.modeladapter.LogicCoreAdapter;
  32 import net.mograsim.logic.model.serializing.IndirectModelComponentCreator;
  33 import net.mograsim.logic.model.util.ModellingTool;
  34
  35 public class TestEnvironmentHelper
  36 {
  37         private final TestableCircuit testEnvInstance;
  38         private final Class<?> testEnvClass;
  39         private final String modelId;
  40         private Field componentField;
  41         private Optional<Field> timelineField = Optional.empty();
  42
  43         private ModelComponent component;
  44         private Timeline timeline;
  45         private LogicModelModifiable logicModel;
  46         private ModellingTool modellingTool;
  47         private HashMap<String, ModelManualSwitch> idSwitchMap = new HashMap<>();
  48         private HashMap<String, ModelBitDisplay> idDisplayMap = new HashMap<>();
  49
  50         private DebugState debug = DebugState.NO_DEBUG;
  51         private Set<String> wireDebugChangeSet;
  52         private boolean debugWires = false;
  53         public int debugEventThreshold = 10_000;
  54         public int debugEventCount = 500;
  55         private int eventCounter;
  56
  57         public TestEnvironmentHelper(TestableCircuit testEnv, String modelId)
  58         {
  59                 this.testEnvInstance = testEnv;
  60                 this.modelId = modelId;
  61                 this.testEnvClass = testEnvInstance.getClass();
  62                 for (Field f : testEnvClass.getDeclaredFields())
  63                 {
  64                         if (ModelComponent.class.isAssignableFrom(f.getType()))
  65                         {
  66                                 componentField = f;
  67                                 componentField.setAccessible(true);
  68                         } else if (Timeline.class.isAssignableFrom(f.getType()))
  69                         {
  70                                 f.setAccessible(true);
  71                                 timelineField = Optional.of(f);
  72                         }
  73                 }
  74                 if (componentField == null)
  75                         throw new IllegalStateException("No component or timeline field found!");
  76         }
  77
  78         public void setup(DebugState debug)
  79         {
  80                 this.debug = debug;
  81                 // Create logic model
  82                 logicModel = new LogicModelModifiable();
  83                 modellingTool = ModellingTool.createFor(logicModel);
  84                 Am2900Loader.setup();
  85                 component = IndirectModelComponentCreator.createComponent(logicModel, modelId);
  86                 setField(componentField, component);
  87
  88                 component.getPins().values().forEach(this::extendModelPin);
  89
  90                 // Create core model
  91                 CoreModelParameters params = new CoreModelParameters();
  92                 params.gateProcessTime = 50;
  93                 params.wireTravelTime = 10;
  94                 timeline = LogicCoreAdapter.convert(logicModel, params);
  95                 timelineField.ifPresent(f -> setField(f, timeline));
  96
  97                 // Bind switches/displays to this test class
  98                 component.getPins().values().forEach(this::bindModelPin);
  99
 100                 if (debug == DebugState.DEBUG_AT_PERFORMANCE_COST)
 101                 {
 102                         setupDebugging();
 103                 }
 104                 timeline.addEventAddedListener(te -> eventCounter++);
 105         }
 106
 107         private void extendModelPin(Pin p)
 108         {
 109                 String javaIdentId = idToJavaIdentifier(p.name);
 110                 try
 111                 {
 112                         Field f = testEnvClass.getDeclaredField(javaIdentId);
 113                         Class<?> type = f.getType();
 114                         if (CoreManualSwitch.class.isAssignableFrom(type))
 115                         {
 116                                 ModelManualSwitch gms = new ModelManualSwitch(logicModel, p.logicWidth);
 117                                 modellingTool.connect(p, gms.getOutputPin());
 118                                 idSwitchMap.put(p.name, gms);
 119                         } else if (CoreBitDisplay.class.isAssignableFrom(type))
 120                         {
 121                                 ModelBitDisplay gbd = new ModelBitDisplay(logicModel, p.logicWidth);
 122                                 modellingTool.connect(p, gbd.getInputPin());
 123                                 idDisplayMap.put(p.name, gbd);
 124                         } else if (SwitchWithDisplay.class.isAssignableFrom(type))
 125                         {
 126                                 SwitchWithDisplay swd = new SwitchWithDisplay(logicModel, p);
 127                                 setField(f, swd);
 128                         } else
 129                         {
 130                                 fail("unkown field type " + type);
 131                         }
 132                 }
 133                 catch (NoSuchFieldException | SecurityException e)
 134                 {
 135                         fail(e);
 136                 }
 137         }
 138
 139         private void bindModelPin(Pin p)
 140         {
 141                 String javaIdentId = idToJavaIdentifier(p.name);
 142                 if (idDisplayMap.containsKey(p.name))
 143                         setField(javaIdentId, idDisplayMap.get(p.name).getBitDisplay());
 144                 if (idSwitchMap.containsKey(p.name))
 145                         setField(javaIdentId, idSwitchMap.get(p.name).getManualSwitch());
 146         }
 147
 148         private void setupDebugging()
 149         {
 150                 // Debug code
 151                 HashSet<ModelWire> wiresIncludingSubmodels = new HashSet<>();
 152                 Queue<LogicModel> modelsToIterate = new LinkedList<>();
 153                 modelsToIterate.add(logicModel);
 154                 while (modelsToIterate.size() > 0)
 155                 {
 156                         LogicModel model = modelsToIterate.poll();
 157                         wiresIncludingSubmodels.addAll(model.getWiresByName().values());
 158                         for (ModelComponent comp : model.getComponentsByName().values())
 159                                 if (comp instanceof SubmodelComponent)
 160                                         modelsToIterate.offer(((SubmodelComponent) comp).submodel);
 161                 }
 162                 System.out.println(wiresIncludingSubmodels.size());
 163                 logicModel.setRedrawHandler(() -> wiresIncludingSubmodels.forEach(w ->
 164                 {
 165                         if (debugWires)
 166                         {
 167                                 wireDebugChangeSet.add(w.toString());
 168                         }
 169                 }));
 170         }
 171
 172         public Result run()
 173         {
 174                 // Normal execution until completion or eventLimit
 175                 int eventLimit = debugEventThreshold;
 176                 eventCounter = 0;
 177                 debugWires = false;
 178                 while (eventCounter < eventLimit)
 179                 {
 180                         timeline.executeNext();
 181                         if (!timeline.hasNext())
 182                                 return Result.SUCCESS;
 183                 }
 184
 185                 // Start debugging if event limit is reached (if debug is active)
 186                 if (debug == DebugState.DEBUG_AT_PERFORMANCE_COST)
 187                         return debugThisRun();
 188
 189                 return Result.OUT_OF_TIME;
 190         }
 191
 192         private Result debugThisRun()
 193         {
 194                 int eventLimit = debugEventThreshold;
 195                 debugWires = true;
 196                 wireDebugChangeSet = new TreeSet<>();
 197                 Set<String> oldChangeSet;
 198                 // observe wire changes to detect, if we are really stuck in an endless loop
 199                 do
 200                 {
 201                         eventLimit += debugEventCount;
 202                         oldChangeSet = wireDebugChangeSet;
 203                         wireDebugChangeSet = new TreeSet<>();
 204                         while (eventCounter < eventLimit)
 205                         {
 206                                 timeline.executeNext();
 207                                 if (!timeline.hasNext())
 208                                 {
 209                                         // no endless loop, but more events needed than expected
 210                                         System.out.println("run() took longer than expected: " + eventCounter);
 211                                         return Result.SUCCESS;
 212                                 }
 213                         }
 214                 } while (!oldChangeSet.equals(wireDebugChangeSet));
 215                 // if stuck, abort execution and print wires
 216                 System.err.print("Problematic Wire updates:");
 217                 wireDebugChangeSet.forEach(System.out::println);
 218                 System.err.println("run() failed: " + eventCounter);
 219                 return Result.OUT_OF_TIME;
 220         }
 221
 222         private static String idToJavaIdentifier(String s)
 223         {
 224                 StringBuilder sb = new StringBuilder(s.length());
 225                 char c = s.charAt(0);
 226                 sb.append(Character.isJavaIdentifierStart(c) ? c : '_');
 227                 for (int i = 1; i < s.length(); i++)
 228                         sb.append(Character.isJavaIdentifierPart(c = s.charAt(i)) ? c : '_');
 229                 return sb.toString();
 230         }
 231
 232         private <S> void setField(Field f, S value)
 233         {
 234                 try
 235                 {
 236                         f.setAccessible(true);
 237                         f.set(testEnvInstance, Objects.requireNonNull(value));
 238                 }
 239                 catch (Exception e)
 240                 {
 241                         fail(e);
 242                 }
 243         }
 244
 245         private <S> void setField(String name, S value)
 246         {
 247                 try
 248                 {
 249                         Field f = testEnvClass.getDeclaredField(name);
 250                         f.setAccessible(true);
 251                         f.set(testEnvInstance, Objects.requireNonNull(value));
 252                 }
 253                 catch (Exception e)
 254                 {
 255                         fail(e);
 256                 }
 257         }
 258
 259         public void displayState()
 260         {
 261                 try
 262                 {
 263                         new LogicUIStandaloneGUI(logicModel).run();
 264                         logicModel.setRedrawHandler(null);
 265                 }
 266                 catch (Exception e)
 267                 {
 268                         e.printStackTrace();
 269                 }
 270         }
 271
 272         public enum DebugState
 273         {
 274                 NO_DEBUG, DEBUG_AT_PERFORMANCE_COST;
 275         }
 276 }