Testing trade_type.

galaxy.cpp

@@ -45,6 +45,48 @@ std::ostream &operator<<(std::ostream &os, const port &p) {
   return os;
 }
 
+int trade_type(port_type port1, port_type port2) {
+  // NONE = 0
+  // GOOD = 1 = OE PAIR
+  // OK   = 2 = ?? Pair
+  // FAIR = 3 = B / S
+
+  buysell p1 = get_buysell(port1);
+  buysell p2 = get_buysell(port2);
+
+  // O != E for both ports, and O != O
+  if ((p1.foe[ORG] != p1.foe[EQU]) && (p2.foe[ORG] != p2.foe[EQU]) &&
+      (p1.foe[ORG] != p2.foe[ORG])) {
+    return 1;
+  }
+
+  buysell inv2 = invert_buysell(p2);
+  int matches = 0;  // or pos.size();
+  std::vector<int> pos;
+
+  // find which FOE are flipped.  Save index pos.
+  for (int x = 0; x < 3; ++x) {
+    inv2.foe[x] = (p1.foe[x] == inv2.foe[x]);
+    if (inv2.foe[x]) {
+      matches++;
+      pos.push_back(x);
+    }
+  }
+
+  if (matches > 1) {
+    // at least 2 matches.  but are they trade pairs?
+    // I can tell by comparing the last two positions in the same port.
+    if (p1.foe[pos[matches - 1]] == p1.foe[pos[matches - 2]]) {
+      // they are NOT.
+      return 3;
+    }
+    return 2;
+  }
+
+  if (matches == 1) return 3;
+  return 0;
+}
+
 /*
 // adding this breaks test-galaxy's port = {2, 2, {1,2,3}, {1,2,3}} code.
 port::port() {

galaxy.h

@@ -13,7 +13,7 @@
 
 #include "yaml-cpp/yaml.h"
 
-enum PRODUCT { FUEL = 0, ORG = 1, EQUIP = 2 };
+enum PRODUCT { FUEL = 0, ORG = 1, EQU = 2 };
 
 // Class 0 : Special
 // Class 9 : StarDock BBB
@@ -37,6 +37,7 @@ struct buysell_text {
 // #define MAX_WARPS 6
 
 typedef uint16_t sector_type;
+typedef uint8_t port_type;
 
 struct sector_warps {
   sector_type sector;  // Yes, for debug
@@ -68,7 +69,7 @@ struct sector_warps {
 
 /* convert type to buysell flag values, buy = true */
 
-constexpr buysell get_buysell(uint8_t type) {
+constexpr buysell get_buysell(port_type type) {
   switch (type) {
     case 1:  // BBS TTF
       return {true, true, false};
@@ -100,7 +101,7 @@ constexpr buysell_text text_from_buysell(const buysell market) {
   return text;
 }
 
-constexpr buysell_text text_from_type(uint8_t type) {
+constexpr buysell_text text_from_type(port_type type) {
   switch (type) {
     case 1:
       return buysell_text{'B', 'B', 'S'};
@@ -152,6 +153,20 @@ constexpr buysell invert_buysell(const buysell market) {
   }
 }
 
+/**
+ * Find possible trades with these two port types
+ * 
+ * 0 = NONE
+ * 1 = GOOD OE trade pair
+ * 2 = OK trade pair
+ * 3 = FAIR (one buys, one sells)
+ * 
+ * @param port1 
+ * @param port2 
+ * @return int 
+ */
+int trade_type(port_type port1, port_type port2);
+
 constexpr uint8_t type_from_buysell(const buysell market) {
   if (market.foe[0]) {
     if (market.foe[1]) {

test-galaxy.cpp

@@ -1,22 +1,18 @@
 
-#include "gtest/gtest.h"
-
-#include "galaxy.h"
-
 #include <array>
 #include <map>
 #include <string>
 #include <vector>
 
+#include "galaxy.h"
+#include "gtest/gtest.h"
+
 /*
 
 How can I add logging, but not really add/use it?
 
 */
 
-
-
-
 #define GTEST_COUT std::cerr << "[          ] [ INFO ]"
 
 namespace {
@@ -43,8 +39,7 @@ TEST(ports, get_buysell) {
     const char *flags;
 
     flags = port_classes[type];
-    for (int x = 0; x < 3; ++x)
-      expected.foe[x] = flags[x] == 'B';
+    for (int x = 0; x < 3; ++x) expected.foe[x] = flags[x] == 'B';
     buysell result = get_buysell(type);
     for (int x = 0; x < 3; ++x)
       EXPECT_EQ(result.foe[x], expected.foe[x])
@@ -58,8 +53,7 @@ TEST(ports, invert_buysell) {
     const char *flags;
 
     flags = port_classes[type];
-    for (int x = 0; x < 3; ++x)
-      expected.foe[x] = flags[x] != 'B';
+    for (int x = 0; x < 3; ++x) expected.foe[x] = flags[x] != 'B';
     buysell result = get_buysell(type);
     buysell invert = invert_buysell(result);
     for (int x = 0; x < 3; ++x)
@@ -74,8 +68,7 @@ TEST(ports, text_from_type) {
     const char *flags;
 
     flags = port_classes[type];
-    for (int x = 0; x < 3; ++x)
-      expected.txt[x] = flags[x];
+    for (int x = 0; x < 3; ++x) expected.txt[x] = flags[x];
     buysell_text result = text_from_type(type);
     EXPECT_EQ(result, expected) << "type: " << type;
   }
@@ -88,8 +81,7 @@ TEST(ports, text_from_buysell) {
     const char *flags;
 
     flags = port_classes[type];
-    for (int x = 0; x < 3; ++x)
-      expected.txt[x] = flags[x];
+    for (int x = 0; x < 3; ++x) expected.txt[x] = flags[x];
     buysell_text result = text_from_buysell(source);
     EXPECT_EQ(result, expected) << "type: " << type;
   }
@@ -103,34 +95,83 @@ TEST(ports, type_from_buysell) {
   }
 }
 
+struct pair {
+  int t1;
+  int t2;
+  friend bool operator<(const pair &lhs, const pair &rhs) {
+    if (lhs.t1 == rhs.t1) {
+      return lhs.t2 < rhs.t2;
+    }
+    return lhs.t1 < rhs.t1;
+  };
+  friend bool operator==(const pair &lhs, const pair &rhs) {
+    return (lhs.t1 == rhs.t1) && (lhs.t2 == rhs.t2);
+  };
+};
+
+TEST(ports, trade_types) {
+  std::map<pair, int> expected;
+  for (int x = 0; x < 9; ++x) {
+    pair p{x, x};  // ; p.t1 = x; p.t2 = 2;
+    expected[p] = 0;
+  }
+
+  expected[pair{1, 2}] = 1;
+  expected[pair{1, 4}] = 1;
+  expected[pair{2, 5}] = 1;
+  expected[pair{4, 5}] = 1;
+
+  // I'm checking 0's and 1's.
+  
+  /*
+  GTEST_COUT << "size:" << expected.size() << std::endl;
+
+  for (auto const & i : expected ) {
+    GTEST_COUT << i.first.t1 << "," << i.first.t2 << " :" << i.second <<
+  std::endl;
+  }
+
+  GTEST_COUT << "Done!" << std::endl;
+  */
+
+  for (int p1 = 1; p1 <= 8; ++p1) {
+    for (int p2 = p1; p2 <= 8; ++p2) {
+      GTEST_COUT << "Type " << p1 << " and " << p2 << std::endl;
+      int t = trade_type(p1, p2);
+      int t2 = trade_type(p2, p1);
+      EXPECT_EQ(t, t2) << "Comparing reversed types";
+      pair p{p1, p2};
+      auto r = expected.find(p);
+      if (r != expected.end()) {
+        EXPECT_EQ(t, r->second) << "Comparision";
+      } else {
+        GTEST_COUT << "TODO: Need type for " << p1 << " , " << p2 << " : " << t
+                   << std::endl;
+      }
+    }
+  }
+}
+
 TEST(ports, parse_portcim) {
   // This really needs to be checked against real lines from a log file
   // THis was copied directly from client (indentation may be off)
   std::map<std::string, port> data = {
-      {"  2 - 2420 100%    612  35% - 2020 100% ", // BSB
-       {2, 2, {2420, 612, 2020}, {100, 35, 100}}
-       },
-      {"  4 - 2880 100% -  275  23%     61   6% ", // BBS
+      {"  2 - 2420 100%    612  35% - 2020 100% ",  // BSB
+       {2, 2, {2420, 612, 2020}, {100, 35, 100}}},
+      {"  4 - 2880 100% -  275  23%     61   6% ",  // BBS
        {4, 1, {2880, 275, 61}, {100, 23, 6}}},
-      {"  6 -  820 100%   1952  89% - 2680 100% ", // BSB
-       {6, 2, {820, 1952, 2680}, {100, 89, 100}}
-       },
-      {"  8 - 1000 100% -  855  85% - 1000 100% ", // BBB
-       {8, 8, {1000, 855, 1000}, {100, 85, 100}}
-       },
-      {" 20 - 1708  97% -  710  56%    287  15% ", // BBS
-       {20, 1, {1708, 710, 287}, {97, 56, 15}}
-       },
-      {" 23 - 2120 100% -  709  40%   1902  69% ", // BBS
-       {23, 1, {2120, 709, 1902}, {100, 40, 69}}
-       },
-      {" 28   1511  98% -  478  29%    589  35% ", // SBS
-       {28, 5, {1511, 478, 589}, {98, 29, 35}}
-       },
-      {" 29    913  56% -  970 100% - 1990 100% ", // SBB
-       {29, 3, {913, 970, 1990}, {56, 100, 100}}
-       }
-      };
+      {"  6 -  820 100%   1952  89% - 2680 100% ",  // BSB
+       {6, 2, {820, 1952, 2680}, {100, 89, 100}}},
+      {"  8 - 1000 100% -  855  85% - 1000 100% ",  // BBB
+       {8, 8, {1000, 855, 1000}, {100, 85, 100}}},
+      {" 20 - 1708  97% -  710  56%    287  15% ",  // BBS
+       {20, 1, {1708, 710, 287}, {97, 56, 15}}},
+      {" 23 - 2120 100% -  709  40%   1902  69% ",  // BBS
+       {23, 1, {2120, 709, 1902}, {100, 40, 69}}},
+      {" 28   1511  98% -  478  29%    589  35% ",  // SBS
+       {28, 5, {1511, 478, 589}, {98, 29, 35}}},
+      {" 29    913  56% -  970 100% - 1990 100% ",  // SBB
+       {29, 3, {913, 970, 1990}, {56, 100, 100}}}};
 
   /*
   // If you could make this a map or something better please improve
@@ -192,4 +233,4 @@ TEST(ports, parse_portcim) {
   // EXPECT_EQ(parse.percent, ports[0].percent);
 }
 
-} // namespace
+}  // namespace