fix outdated changed start state tests

Author: stilscher

tests/incremental/00-basic/02-changed_start_state1.c

@@ -4,9 +4,10 @@ int g = 1;
 
 int main() {
     // After the presolve phase, g is in the start state but neither in the context nor in the start variables.
-    // If the start state of main is not overwriten when main is destabilized because of a changed start state,
-    // the first assert will wrongly succeed and the second fail in the incremental run
-    assert(g == 1); // SUCCESS
-    assert(g == 2); // FAIL
+    // If the change of the start state of main would not be propagated by the call to side on all start variables, the
+    // asserts in the incremental run would wrongly fail. Side however only joins with the previous value instead of
+    // overwriting, therefore the current imprecision.
+    assert(g == 1);
+    assert(g != 2);
     return 0;
 }

tests/incremental/00-basic/02-changed_start_state1.patch

@@ -1,18 +1,19 @@
---- a/tests/incremental/02-changed_start_state.c
-+++ b/tests/incremental/02-changed_start_state.c
-@@ -1,12 +1,12 @@
+--- a/tests/incremental/00-basic/02-changed_start_state1.c
++++ b/tests/incremental/00-basic/02-changed_start_state1.c
+@@ -1,13 +1,13 @@
  #include <assert.h>
 
 -int g = 1;
 +int g = 2;
 
  int main() {
      // After the presolve phase, g is in the start state but neither in the context nor in the start variables.
-     // If the start state of main is not overwriten when main is destabilized because of a changed start state,
-     // the first assert will wrongly succeed and the second fail in the incremental run
--    assert(g == 1); // SUCCESS
--    assert(g == 2); // FAIL
-+    assert(g == 1); // UNKNOWN
-+    assert(g == 2); // UNKNOWN
+     // If the change of the start state of main would not be propagated by the call to side on all start variables, the
+     // asserts in the incremental run would wrongly fail. Side however only joins with the previous value instead of
+     // overwriting, therefore the current imprecision.
+-    assert(g == 1);
+-    assert(g != 2);
++    assert(g != 1); // TODO (restarting)
++    assert(g == 2); // TODO
      return 0;
  }

tests/incremental/00-basic/03-changed_start_state2.c

@@ -4,9 +4,10 @@ int g = 1;
 
 int main() {
     // After the presolve phase, g is in the start state but neither in the context nor in the start variables.
-    // If the start state of main is not overwriten when main is destabilized because of a changed start state,
-    // the first assert will wrongly succeed and the second fail in the incremental run
-    assert(g == 1); // SUCCESS
-    assert(g == 2); // FAIL
+    // If the change of the start state of main would not be propagated by the call to side on all start variables, the
+    // asserts in the incremental run would wrongly fail. Side however only joins with the previous value instead of
+    // overwriting, therefore the current imprecision.
+    assert(g == 1);
+    assert(g != 2);
     return 0;
 }

tests/incremental/00-basic/03-changed_start_state2.patch

@@ -1,18 +1,19 @@
---- a/tests/incremental/03-changed_start_state.c
-+++ b/tests/incremental/03-changed_start_state.c
-@@ -1,12 +1,12 @@
+--- a/tests/incremental/00-basic/03-changed_start_state2.c
++++ b/tests/incremental/00-basic/03-changed_start_state2.c
+@@ -1,13 +1,13 @@
  #include <assert.h>
 
 -int g = 1;
 +int g = 2;
 
  int main() {
      // After the presolve phase, g is in the start state but neither in the context nor in the start variables.
-     // If the start state of main is not overwriten when main is destabilized because of a changed start state,
-     // the first assert will wrongly succeed and the second fail in the incremental run
--    assert(g == 1); // SUCCESS
--    assert(g == 2); // FAIL
-+    assert(g == 1); // FAIL
-+    assert(g == 2); // SUCCESS
+     // If the change of the start state of main would not be propagated by the call to side on all start variables, the
+     // asserts in the incremental run would wrongly fail. Side however only joins with the previous value instead of
+     // overwriting, therefore the current imprecision.
+-    assert(g == 1);
+-    assert(g != 2);
++    assert(g != 1); // TODO (restarting)
++    assert(g == 2); // TODO
      return 0;
  }