src/Test/ConversionTest.cxx

   1 // Copyright (C) 2019  EDF R&D
   2 //
   3 // This library is free software; you can redistribute it and/or
   4 // modify it under the terms of the GNU Lesser General Public
   5 // License as published by the Free Software Foundation; either
   6 // version 2.1 of the License, or (at your option) any later version.
   7 //
   8 // This library is distributed in the hope that it will be useful,
   9 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  10 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  11 // Lesser General Public License for more details.
  12 //
  13 // You should have received a copy of the GNU Lesser General Public
  14 // License along with this library; if not, write to the Free Software
  15 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  16 //
  17 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  18 //
  19 #include "ConversionTest.hxx"
  20 #include "py2cpp.hxx"
  21
  22 void ConversionTest::setUp()
  23 {
  24   Py_Initialize();
  25 }
  26
  27 void ConversionTest::tearDown()
  28 {
  29   Py_Finalize();
  30 }
  31
  32 void ConversionTest::cleanUp(){}
  33
  34 void ConversionTest::basicTest()
  35 {
  36   CPPUNIT_ASSERT(42==py2cpp::fromPyPtr<int>(py2cpp::toPyPtr(42)));
  37   CPPUNIT_ASSERT(4.2==py2cpp::fromPyPtr<double>(py2cpp::toPyPtr(4.2)));
  38   CPPUNIT_ASSERT(py2cpp::fromPyPtr<bool>(py2cpp::toPyPtr(true)));
  39   CPPUNIT_ASSERT(!py2cpp::fromPyPtr<bool>(py2cpp::toPyPtr(false)));
  40   std::string toto;
  41   toto = py2cpp::fromPyPtr<std::string>(py2cpp::toPyPtr(std::string("toto")));
  42   CPPUNIT_ASSERT(toto == "toto");
  43
  44   auto v = std::make_tuple(4, 4.2);
  45   py2cpp::PyPtr obj = py2cpp::toPyPtr(v);
  46
  47   std::string s1;
  48   double d;
  49   int i;
  50   std::tuple<int&, double&> tup(i, d);
  51   py2cpp::fromPyPtr(obj, tup);
  52   CPPUNIT_ASSERT(4==std::get<0>(tup));
  53   CPPUNIT_ASSERT(4.2==std::get<1>(tup));
  54   int i2;
  55   double d2;
  56   py2cpp::pyResult(i2, d2) = obj;
  57   CPPUNIT_ASSERT(4==i2);
  58   CPPUNIT_ASSERT(4.2==d2);
  59   py2cpp::pyResult(i2) = py2cpp::toPyPtr(42);
  60   CPPUNIT_ASSERT(42 == i2);
  61 }
  62
  63 void ConversionTest::functionTest()
  64 {
  65   int i;
  66   double d;
  67   std::string str;
  68   py2cpp::PyFunction fn;
  69
  70   CPPUNIT_ASSERT(fn.load("TestPy2cpp", "f1"));
  71   CPPUNIT_ASSERT(fn);
  72   py2cpp::pyResult(i, d) = fn(5, 4.8);
  73   CPPUNIT_ASSERT(4==i);
  74   CPPUNIT_ASSERT(6.7==d);
  75   CPPUNIT_ASSERT(0==py2cpp::getLastPyError().size());
  76
  77   fn.load("TestPy2cpp", "f2");
  78   CPPUNIT_ASSERT(fn);
  79   py2cpp::pyResult(str) = fn();
  80   CPPUNIT_ASSERT(str=="Hello world!");
  81   CPPUNIT_ASSERT(0==py2cpp::getLastPyError().size());
  82
  83   fn.load("TestPy2cpp", "f3");
  84   CPPUNIT_ASSERT(fn);
  85   py2cpp::pyResult(d, str) = fn(7, 2, "Toto");
  86   CPPUNIT_ASSERT(3.5 == d);
  87   CPPUNIT_ASSERT(str == "Toto is here!");
  88   CPPUNIT_ASSERT(0==py2cpp::getLastPyError().size());
  89
  90   CPPUNIT_ASSERT(!fn.load("nonexistent","nonexistent"));
  91   CPPUNIT_ASSERT(!fn);
  92   CPPUNIT_ASSERT(0 < py2cpp::getLastPyError().size());
  93 }
  94
  95 void ConversionTest::vectorTest()
  96 {
  97   std::vector<double> v = {1.1, 2.2, 3.3, 4.4};
  98   py2cpp::PyPtr obj = py2cpp::toPyPtr(v);
  99   py2cpp::fromPyPtr(obj, v);
 100
 101   std::vector<double> result;
 102   py2cpp::PyFunction fn;
 103   fn.load("TestPy2cpp", "add1ToList");
 104   py2cpp::pyResult(result) = fn(v);
 105
 106   CPPUNIT_ASSERT(std::vector<double>({2.1, 3.2, 4.3, 5.4}) == result);
 107 }
 108
 109 void ConversionTest::listTest()
 110 {
 111   std::list<double> v = {1.1, 2.2, 3.3, 4.4};
 112   py2cpp::PyPtr obj = py2cpp::toPyPtr(v);
 113   py2cpp::fromPyPtr(obj, v);
 114
 115   std::list<double> result;
 116   py2cpp::PyFunction fn;
 117   fn.load("TestPy2cpp", "add1ToList");
 118   py2cpp::pyResult(result) = fn(v);
 119
 120   CPPUNIT_ASSERT(std::list<double>({2.1, 3.2, 4.3, 5.4}) == result);
 121 }
 122
 123 void ConversionTest::pyobjTest()
 124 {
 125   py2cpp::PyFunction objcall;
 126   objcall.load("TestPy2cpp","MyClass");
 127   CPPUNIT_ASSERT(objcall);
 128   py2cpp::PyPtr obj = objcall(std::list<std::string>({"Toto", "Titi", "Zaza"}),
 129                               std::vector<double>({5.5, 2.7, 1.8, 9.2}));
 130   py2cpp::PyFunction objFn1, objFn2, objFn3;
 131   objFn1.load(obj, "namesTogether");
 132   objFn2.load(obj, "valuesSum");
 133   objFn3.load(obj, "addVal");
 134   std::string strResult;
 135   double dbResult;
 136   py2cpp::pyResult(strResult) = objFn1();
 137   py2cpp::pyResult(dbResult) = objFn2();
 138   CPPUNIT_ASSERT(strResult == "Toto-Titi-Zaza");
 139   CPPUNIT_ASSERT(19.2 == dbResult);
 140
 141   objFn3(1);
 142   py2cpp::pyResult(dbResult) = objFn2();
 143   CPPUNIT_ASSERT(23.2 == dbResult);
 144
 145   py2cpp::PyFunction myObjectSize;
 146   myObjectSize.load("TestPy2cpp", "myObjectSize");
 147   int i;
 148   py2cpp::pyResult(i) = myObjectSize(obj);
 149   CPPUNIT_ASSERT(7==i);
 150   CPPUNIT_ASSERT(obj.getAttr("names").repr() == "['Toto', 'Titi', 'Zaza']");
 151   CPPUNIT_ASSERT(obj.getAttr("values").repr() == "[6.5, 3.7, 2.8, 10.2]");
 152
 153   objFn1.load("TestPy2cpp","newobj");
 154   py2cpp::PyPtr newobj;
 155   py2cpp::pyResult(newobj, i) = objFn1(obj, std::vector<int>({1,2,3}));
 156   CPPUNIT_ASSERT(6==i);
 157   CPPUNIT_ASSERT(newobj.getAttr("names").repr() == "['Toto', 'Titi', 'Zaza']");
 158   CPPUNIT_ASSERT(newobj.getAttr("values").repr() == "[1, 2, 3]");
 159 }
 160
 161 void ConversionTest::pyErrorTest()
 162 {
 163   double d;
 164   std::string str;
 165   py2cpp::PyFunction fn;
 166   fn.load("TestPy2cpp", "f3");
 167   try
 168   {
 169     fn(7, 0, "problem");
 170     CPPUNIT_FAIL("Expected exception 'py2cpp::ExecutionException'!");
 171   }
 172   catch (const py2cpp::ExecutionException& err)
 173   {
 174     str = err.what();
 175     CPPUNIT_ASSERT(str.find("ZeroDivisionError:") != std::string::npos) ;
 176   }
 177
 178   try
 179   {
 180     py2cpp::pyResult(d, str) = fn(7, 0, "problem");
 181     CPPUNIT_FAIL("Expected exception 'py2cpp::ExecutionException'!");
 182   }
 183   catch (const py2cpp::ExecutionException& err)
 184   {
 185     str = err.what();
 186     CPPUNIT_ASSERT(str.find("ZeroDivisionError:") != std::string::npos) ;
 187   }
 188 }
 189
 190 void ConversionTest::castErrorTest()
 191 {
 192   int i;
 193   double d;
 194   std::string str;
 195   std::vector<int> vi;
 196   std::vector<double> vd;
 197   std::vector<std::string> vs;
 198   std::map<std::string, std::vector<double> > msvd;
 199   py2cpp::ConversionCheck check;
 200   py2cpp::PyPtr obj;
 201
 202   obj = py2cpp::toPyPtr(42);
 203   check = py2cpp::fromPyPtr(obj, d);
 204   CPPUNIT_ASSERT(check);
 205   check = py2cpp::fromPyPtr(obj, vi);
 206   CPPUNIT_ASSERT(check.getMessage() ==
 207 "Cannot convert the python object <42> to c++ type std::vector.\n");
 208   check = py2cpp::fromPyPtr(obj, str);
 209   CPPUNIT_ASSERT(check.getMessage() ==
 210 "Cannot convert the python object <42> to c++ type std::string.\n");
 211   check = py2cpp::fromPyPtr(obj, msvd);
 212   CPPUNIT_ASSERT(check.getMessage() ==
 213 "Cannot convert the python object <42> to c++ type std::map.\n");
 214
 215   obj = py2cpp::toPyPtr(std::vector<int>({1,2,3,4,5,6}));
 216   check = py2cpp::fromPyPtr(obj, i);
 217   CPPUNIT_ASSERT(check.getMessage() ==
 218 "Cannot convert the python object <[1, 2, 3, 4, 5, 6]> to c++ type int.\n");
 219   check = py2cpp::fromPyPtr(obj, d);
 220   CPPUNIT_ASSERT(check.getMessage() ==
 221 "Cannot convert the python object <[1, 2, 3, 4, 5, 6]> to c++ type double.\n");
 222   check = py2cpp::fromPyPtr(obj, vi);
 223   CPPUNIT_ASSERT(check);
 224   check = py2cpp::fromPyPtr(obj, vd);
 225   CPPUNIT_ASSERT(check);
 226   check = py2cpp::fromPyPtr(obj, str);
 227   CPPUNIT_ASSERT(check.getMessage() ==
 228 "Cannot convert the python object <[1, 2, 3, 4, 5, 6]> to c++ type std::string.\n"
 229   );
 230
 231   check = py2cpp::fromPyPtr(obj, vs);
 232   CPPUNIT_ASSERT(check.getMessage() ==
 233 "Cannot convert the python object <1> to c++ type std::string.\n"
 234 "Cannot convert the python object <[1, 2, 3, 4, 5, 6]> to c++ type std::vector.\n"
 235   );
 236   check = py2cpp::fromPyPtr(obj, msvd);
 237   CPPUNIT_ASSERT(check.getMessage() ==
 238 "Cannot convert the python object <[1, 2, 3, 4, 5, 6]> to c++ type std::map.\n");
 239
 240   std::map<int, double> mid({ {1, 1.1},{2, 2.2},{3, 3.3},{4, 4.4},{5, 5.5}});
 241   obj = py2cpp::toPyPtr(mid);
 242   check = py2cpp::fromPyPtr(obj, i);
 243   // Cannot check the message because the string representation of the python
 244   // dictionary may change.
 245   CPPUNIT_ASSERT(!check);
 246   check = py2cpp::fromPyPtr(obj, vd);
 247   CPPUNIT_ASSERT(!check);
 248   check = py2cpp::fromPyPtr(obj, msvd);
 249   CPPUNIT_ASSERT(!check);
 250
 251   std::map<std::string, double> msd({ {"1", 1.1},{"2", 2.2},{"3", 3.3},
 252                                     {"4", 4.4},{"5", 5.5}});
 253   obj = py2cpp::toPyPtr(msd);
 254   check = py2cpp::fromPyPtr(obj, msvd);
 255   CPPUNIT_ASSERT(!check);
 256
 257   std::map<std::string, std::vector<std::string> > msvs ;
 258   msvs["a"] = std::vector<std::string>({"azer", "aqwx"});
 259   msvs["b"] = std::vector<std::string>({"bn,", "bvcxw"});
 260   obj = py2cpp::toPyPtr(msvs);
 261   check = py2cpp::fromPyPtr(obj, msvd);
 262   CPPUNIT_ASSERT(!check);
 263 }
 264
 265 CPPUNIT_TEST_SUITE_REGISTRATION( ConversionTest );
 266 #include "TestMain.cxx"