Merge branch 'complex-syms-clean' into additional_tests

Author: anyaevostinar

source/sgp_mode/CPU.h

@@ -252,7 +252,7 @@ class CPU {
         {"Nop-0", 0},     {"ShiftLeft", 1}, {"ShiftRight", 1}, {"Increment", 1},
         {"Decrement", 1}, {"Push", 1},      {"Pop", 1},        {"SwapStack", 0},
         {"Swap", 2},      {"Add", 3},       {"Subtract", 3},   {"Nand", 3},
-        {"Reproduce", 0}, {"PrivateIO", 1},  {"Donate", 0},   {"Steal", 0}};
+        {"Reproduce", 0}, {"SharedIO", 1},  {"Donate", 0},   {"Steal", 0}};
 
     for (auto i : program) {
       PrintOp(i, arities, cpu.GetActiveCore().GetGlobalJumpTable(), out);

source/test/sgp_mode_test/GenomeLibrary.test.cc

@@ -36,7 +36,6 @@ void TestGenome(emp::Ptr<Task> task, void (ProgramBuilder::*method)()) {
 TEST_CASE("Generate NOT program", "[sgp]") {
   TestGenome(emp::NewPtr<InputTask>(NOT), &ProgramBuilder::AddNot);
 }
-
 TEST_CASE("Generate NAND program", "[sgp]") {
   TestGenome(emp::NewPtr<InputTask>(NAND), &ProgramBuilder::AddNand);
 }
@@ -88,4 +87,25 @@ TEST_CASE("Empty ProgramBuilder can't do tasks", "[sgp]") {
   for (auto data : world.GetTaskSet()) {
     REQUIRE(data.n_succeeds_host == 0);
   }
+}
+
+TEST_CASE("BuildNoRepro creates obligate mutualist program", "[sgp]") {
+  ProgramBuilder builder;
+  size_t program_len = 100;
+
+  sgpl::Program<Spec> program = builder.BuildNoRepro(program_len);
+
+  REQUIRE(program.size() == program_len);
+
+  for (size_t i = program.size() - 5; i < program.size(); ++i) {
+    REQUIRE(program[i].op_code == Library::GetOpCode("Donate"));
+  }
+
+  for (auto &inst : program) {
+    REQUIRE(inst.op_code != Library::GetOpCode("Reproduce"));
+  }
+
+  REQUIRE(program[0].op_code == Library::GetOpCode("Global Anchor"));
+  REQUIRE(program[0].tag == START_TAG);
+
 }

source/test/sgp_mode_test/SGPSymbiont.test.cc

@@ -4,21 +4,19 @@
 #include "../../sgp_mode/SGPDataNodes.h"
 
 TEST_CASE("SGPSymbiont Reproduce", "[sgp]") {
-	emp::Random random(31);
-	SymConfigSGP config;
-	SGPWorld world(random, &config, LogicTasks);
-	emp::Ptr<SGPSymbiont> sym_parent = emp::NewPtr<SGPSymbiont>(&random, &world, &config, CreateNotProgram(100));
-	
+  emp::Random random(31);
+  SymConfigSGP config;
+  SGPWorld world(random, &config, LogicTasks);
+  emp::Ptr<SGPSymbiont> sym_parent = emp::NewPtr<SGPSymbiont>(&random, &world, &config, CreateNotProgram(100));
 
-	THEN("Symbiont child increases its lineage reproduction count"){
-		emp::Ptr<SGPSymbiont> sym_baby = (sym_parent->Reproduce()).DynamicCast<SGPSymbiont>();
-		REQUIRE(sym_parent->GetReproCount() == sym_baby->GetReproCount() - 1);
-		sym_baby.Delete();
+  THEN("Symbiont child increases its lineage reproduction count") {
+    emp::Ptr<SGPSymbiont> sym_baby = (sym_parent->Reproduce()).DynamicCast<SGPSymbiont>();
+    REQUIRE(sym_parent->GetReproCount() == sym_baby->GetReproCount() - 1);
+    sym_baby.Delete();
     sym_parent.Delete();
-	}
+  }
 
   WHEN("Parental task tracking is on") {
-
     emp::Ptr<SGPHost> host = emp::NewPtr<SGPHost>(&random, &world, &config, CreateNotProgram(100));
     config.TRACK_PARENT_TASKS(1);
     world.AddOrgAt(host, 0);
@@ -40,6 +38,7 @@ TEST_CASE("SGPSymbiont Reproduce", "[sgp]") {
       REQUIRE(sym_baby->GetCPU().state.parent_tasks_performed->CountOnes() == 1);
     }
 
+
     THEN("The symbiont child tracks any gains or loses in task completions") {
       // in this second generation, we expect the symbiont to gain the NOT task
       // since first-gen organisms are marked as having parents who have completed no tasks
@@ -64,7 +63,6 @@ TEST_CASE("SGPSymbiont Reproduce", "[sgp]") {
   }
 }
 
-
 TEST_CASE("When ONLY_FIRST_TASK_CREDIT is 1, the most tasks a symbiont can receive credit for is 1", "[sgp]"){
 
   emp::Random random(1);
@@ -305,3 +303,57 @@ TEST_CASE("When ONLY_FIRST_TASK_CREDIT is 0, symbionts receive credit for all ta
 
 
 }
+
+TEST_CASE("Symbiont comparison operators", "[sgp]") {
+  emp::Random random(31);
+	SymConfigSGP config;
+	SGPWorld world(random, &config, LogicTasks);
+	emp::Ptr<SGPSymbiont> sym_parent = emp::NewPtr<SGPSymbiont>(&random, &world, &config, CreateNotProgram(100));
+
+    emp::Ptr<SGPHost> host = emp::NewPtr<SGPHost>(&random, &world, &config, CreateNotProgram(100));
+    config.TRACK_PARENT_TASKS(1);
+    world.AddOrgAt(host, 0);
+    host->AddSymbiont(sym_parent);
+
+    for (int i = 0; i < 25; i++) {
+      world.Update();
+    }
+    emp::Ptr<SGPSymbiont> clone1 = emp::NewPtr<SGPSymbiont>(*sym_parent);
+    emp::Ptr<SGPSymbiont> clone2 = emp::NewPtr<SGPSymbiont>(*sym_parent);
+    emp::Ptr<SGPSymbiont> different = emp::NewPtr<SGPSymbiont>(&random, &world, &config, CreateNotProgram(99)); // For comparing
+
+    REQUIRE(*sym_parent == *clone1);
+    REQUIRE(*clone1 == *clone2);
+
+    REQUIRE_FALSE(*sym_parent == *different);
+
+    // Can't assert true/false without knowing bitcode ordering,
+    // assert that bitcode ordering is well-defined
+    bool lt = *sym_parent < *different || *different < *sym_parent;
+    REQUIRE(lt);
+    
+    clone1.Delete();
+    clone2.Delete();
+    different.Delete();
+  }
+
+TEST_CASE("SGPSymbiont destructor cleans up shared pointers and in-progress reproduction", "[sgp]") {
+  emp::Random random(31);
+	SymConfigSGP config;
+	SGPWorld world(random, &config, LogicTasks);
+  emp::Ptr<SGPSymbiont> sym = emp::NewPtr<SGPSymbiont>(&random, &world, &config, CreateNotProgram(100));
+  sym->GetCPU().state.in_progress_repro = 3;
+  world.to_reproduce.resize(5); 
+  world.to_reproduce[3].second = emp::WorldPosition(1, 2); 
+
+  REQUIRE(world.to_reproduce[3].second.IsValid());
+
+  WHEN("Symbionts is destroyed") {
+    sym.Delete(); 
+    
+    THEN("Reproduction queue is invalidated after symbiont is destroyed") {
+      REQUIRE_FALSE(world.to_reproduce[3].second.IsValid());
+    }
+  }
+}
+