fix(build): avoid cyclic dependency

IntelliJ can handle dependencies between test configurations going in the
reverse direction compared to dependencies between main configurations, but
Eclipse can't. Manually copy some code over to break the reverse dependency.

2 files changed, 33 insertions, 10 deletions

diff --git a/subprojects/language-semantics/build.gradle.kts b/subprojects/language-semantics/build.gradle.kts
index 777ef993..689f621e 100644
--- a/subprojects/language-semantics/build.gradle.kts
+++ b/subprojects/language-semantics/build.gradle.kts
@@ -16,7 +16,6 @@ dependencies {
         api(project(":refinery-store-reasoning"))
         implementation(project(":refinery-store-reasoning-scope"))
         runtimeOnly(libs.eclipseCollections)
-        testImplementation(project(":refinery-generator"))
         testImplementation(project(":refinery-store-dse-visualization"))
         testImplementation(project(":refinery-store-query-interpreter"))
         testImplementation(testFixtures(project(":refinery-language")))
diff --git a/subprojects/language-semantics/src/test/java/tools/refinery/language/semantics/SolutionSerializerTest.java b/subprojects/language-semantics/src/test/java/tools/refinery/language/semantics/SolutionSerializerTest.java
index 2d759c86..8ef449b0 100644
--- a/subprojects/language-semantics/src/test/java/tools/refinery/language/semantics/SolutionSerializerTest.java
+++ b/subprojects/language-semantics/src/test/java/tools/refinery/language/semantics/SolutionSerializerTest.java
@@ -6,19 +6,29 @@
 package tools.refinery.language.semantics;
 
 import com.google.inject.Inject;
+import com.google.inject.Provider;
 import org.eclipse.xtext.testing.InjectWith;
 import org.eclipse.xtext.testing.extensions.InjectionExtension;
 import org.junit.jupiter.api.extension.ExtendWith;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.Arguments;
 import org.junit.jupiter.params.provider.MethodSource;
-import tools.refinery.generator.ModelGeneratorFactory;
-import tools.refinery.generator.ProblemLoader;
+import tools.refinery.language.model.tests.utils.ProblemParseHelper;
 import tools.refinery.language.tests.ProblemInjectorProvider;
+import tools.refinery.store.dse.propagation.PropagationAdapter;
+import tools.refinery.store.dse.strategy.BestFirstStoreManager;
+import tools.refinery.store.dse.transition.DesignSpaceExplorationAdapter;
+import tools.refinery.store.model.ModelStore;
+import tools.refinery.store.query.interpreter.QueryInterpreterAdapter;
+import tools.refinery.store.reasoning.ReasoningAdapter;
+import tools.refinery.store.reasoning.ReasoningStoreAdapter;
+import tools.refinery.store.reasoning.literal.Concreteness;
+import tools.refinery.store.statecoding.StateCoderAdapter;
 
 import java.io.ByteArrayOutputStream;
 import java.io.IOException;
 import java.util.Map;
+import java.util.Set;
 import java.util.stream.Stream;
 
 import static org.hamcrest.MatcherAssert.assertThat;
@@ -28,21 +38,35 @@ import static org.hamcrest.Matchers.is;
 @InjectWith(ProblemInjectorProvider.class)
 class SolutionSerializerTest {
         @Inject
-        ProblemLoader loader;
+        private ProblemParseHelper parseHelper;
 
         @Inject
-        ModelGeneratorFactory generatorFactory;
+        private Provider<ModelInitializer> initializerProvider;
 
         @Inject
-        SolutionSerializer serializer;
+        private Provider<SolutionSerializer> serializerProvider;
 
         @ParameterizedTest
         @MethodSource
         void solutionSerializerTest(String prefix, String input, String expectedOutput) throws IOException {
-                var problem = loader.loadString(prefix + "\n" + input);
-                var generator = generatorFactory.createGenerator(problem);
-                generator.generate();
-                var solution = serializer.serializeSolution(generator.getProblemTrace(), generator.getModel());
+                var problem = parseHelper.parse(prefix + "\n" + input).problem();
+                var storeBuilder = ModelStore.builder()
+                                .with(QueryInterpreterAdapter.builder())
+                                .with(PropagationAdapter.builder())
+                                .with(StateCoderAdapter.builder())
+                                .with(DesignSpaceExplorationAdapter.builder())
+                                .with(ReasoningAdapter.builder()
+                                                .requiredInterpretations(Set.of(Concreteness.CANDIDATE)));
+                var initializer = initializerProvider.get();
+                var modelSeed = initializer.createModel(problem, storeBuilder);
+                var store = storeBuilder.build();
+                var model = store.getAdapter(ReasoningStoreAdapter.class).createInitialModel(modelSeed);
+                var initialVersion = model.commit();
+                var bestFirst = new BestFirstStoreManager(store, 1);
+                bestFirst.startExploration(initialVersion, 0);
+                model.restore(bestFirst.getSolutionStore().getSolutions().getFirst().version());
+                var serializer = serializerProvider.get();
+                var solution = serializer.serializeSolution(initializer.getProblemTrace(), model);
                 String actualOutput;
                 try (var outputStream = new ByteArrayOutputStream()) {
                         solution.eResource().save(outputStream, Map.of());