Merged branch 'dev_native' into lm_sla_supports_auto

Added igl library files

src/igl/xml/serialization_test.skip

@@ -0,0 +1,489 @@
+//
+// Copyright (C) 2014 Christian Schüller <schuellchr@gmail.com>
+//
+// This Source Code Form is subject to the terms of the Mozilla Public License
+// v. 2.0. If a copy of the MPL was not distributed with this file, You can
+// obtain one at http://mozilla.org/MPL/2.0/.
+//#ifndef IGL_SERIALIZATION_TEST_H
+//#define IGL_SERIALIZATION_TEST_H
+
+//#include <igl/Timer.h>
+#include "serialize_xml.h"
+#include "XMLSerializable.h"
+
+namespace igl
+{
+  namespace xml
+  {
+  
+    struct Test1111
+    {
+    };
+  
+    struct Test1 : public XMLSerializable
+    {
+      std::string ts;
+      std::vector<Test1*> tvt;
+      Test1* tt;
+  
+      Test1()
+      {
+        tt = NULL;
+      }
+  
+      void InitSerialization()
+      {
+        Add(ts,"ts",false);
+        Add(tvt,"tvt");
+        Add(tt,"tt");
+      }
+    };
+  
+    struct Test2: public XMLSerializableBase
+    {
+      char tc;
+      int* ti;
+      std::vector<short> tvb;
+      float tf;
+  
+      Test2()
+      {
+        tc = '1';
+        ti = NULL;
+        tf = 1.0004;
+        tvb.push_back(2);
+        tvb.push_back(3);
+      }
+  
+      void Serialize(tinyxml2::XMLDocument* doc,tinyxml2::XMLElement* element) const
+      {
+        serialize_xml(tc,"tc",doc,element);
+        serialize_xml(ti,"ti",doc,element);
+        serialize_xml(tvb,"tvb",doc,element);
+      }
+      void Deserialize(const tinyxml2::XMLDocument* doc,const tinyxml2::XMLElement* element)
+      {
+        deserialize_xml(tc,"tc",doc,element);
+        deserialize_xml(ti,"ti",doc,element);
+        deserialize_xml(tvb,"tvb",doc,element);
+      }
+      void Serialize(std::vector<char>& buffer) const
+      {
+        serialize(tc,"tc",buffer);
+        serialize(ti,"ti",buffer);
+        serialize(tvb,"tvb",buffer);
+        serialize(tf,"tf",buffer);
+      }
+      void Deserialize(const std::vector<char>& buffer)
+      {
+        deserialize(tc,"tc",buffer);
+        deserialize(ti,"ti",buffer);
+        deserialize(tvb,"tvb",buffer);
+        deserialize(tf,"tf",buffer);
+      }
+    };
+  
+    void serialization_test()
+    {
+      std::string file("test");
+  
+      bool tbIn = true,tbOut;
+      char tcIn = 't',tcOut;
+      unsigned char tucIn = 'u',tucOut;
+      short tsIn = 6,tsOut;
+      int tiIn = -10,tiOut;
+      unsigned int tuiIn = 10,tuiOut;
+      float tfIn = 1.0005,tfOut;
+      double tdIn = 1.000000005,tdOut;
+  
+      int* tinpIn = NULL,*tinpOut = NULL;
+      float* tfpIn = new float,*tfpOut = NULL;
+      *tfpIn = 1.11101;
+  
+      std::string tstrIn("test12345"),tstrOut;
+  
+      Test2 tObjIn,tObjOut;
+      int ti = 2;
+      tObjIn.ti = &ti;
+  
+  
+      Test1 test1,test2,test3;
+      test1.ts = "100";
+      test2.ts = "200";
+      test3.ts = "300";
+  
+      Test1 testA, testC;
+      testA.tt = &test1;
+      testA.ts = "test123";
+      testA.tvt.push_back(&test2);
+      testA.tvt.push_back(&test3);
+  
+      Test1 testB = testA;
+      testB.ts = "400";
+      testB.tvt.pop_back();
+  
+      std::pair<int,bool> tPairIn(10,true);
+      std::pair<int,bool> tPairOut;
+  
+      std::vector<int> tVector1In ={1,2,3,4,5};
+      std::vector<int> tVector1Out;
+  
+      std::pair<int,bool> p1(10,1);
+      std::pair<int,bool> p2(1,0);
+      std::pair<int,bool> p3(10000,1);
+      std::vector<std::pair<int,bool> > tVector2In ={p1,p2,p3};
+      std::vector<std::pair<int,bool> > tVector2Out;
+  
+      std::set<std::pair<int,bool> > tSetIn ={p1,p2,p3};
+      std::set<std::pair<int,bool> > tSetOut;
+  
+      std::map<int,bool> tMapIn ={p1,p2,p3};
+      std::map<int,bool> tMapOut;
+  
+      Eigen::Matrix<float,3,3> tDenseMatrixIn;
+      tDenseMatrixIn << Eigen::Matrix<float,3,3>::Random();
+      tDenseMatrixIn.coeffRef(0,0) = 1.00001;
+      Eigen::Matrix<float,3,3> tDenseMatrixOut;
+  
+      Eigen::Matrix<float,3,3,Eigen::RowMajor> tDenseRowMatrixIn;
+      tDenseRowMatrixIn << Eigen::Matrix<float,3,3,Eigen::RowMajor>::Random();
+      Eigen::Matrix<float,3,3,Eigen::RowMajor> tDenseRowMatrixOut;
+  
+      Eigen::SparseMatrix<double> tSparseMatrixIn;
+      tSparseMatrixIn.resize(3,3);
+      tSparseMatrixIn.insert(0,0) = 1.3;
+      tSparseMatrixIn.insert(1,1) = 10.2;
+      tSparseMatrixIn.insert(2,2) = 100.1;
+      tSparseMatrixIn.finalize();
+      Eigen::SparseMatrix<double> tSparseMatrixOut;
+  
+      // binary serialization
+  
+      serialize(tbIn,file);
+      deserialize(tbOut,file);
+      assert(tbIn == tbOut);
+  
+      serialize(tcIn,file);
+      deserialize(tcOut,file);
+      assert(tcIn == tcOut);
+  
+      serialize(tucIn,file);
+      deserialize(tucOut,file);
+      assert(tucIn == tucOut);
+  
+      serialize(tsIn,file);
+      deserialize(tsOut,file);
+      assert(tsIn == tsOut);
+  
+      serialize(tiIn,file);
+      deserialize(tiOut,file);
+      assert(tiIn == tiOut);
+  
+      serialize(tuiIn,file);
+      deserialize(tuiOut,file);
+      assert(tuiIn == tuiOut);
+  
+      serialize(tfIn,file);
+      deserialize(tfOut,file);
+      assert(tfIn == tfOut);
+  
+      serialize(tdIn,file);
+      deserialize(tdOut,file);
+      assert(tdIn == tdOut);
+  
+      serialize(tinpIn,file);
+      deserialize(tinpOut,file);
+      assert(tinpIn == tinpOut);
+  
+      serialize(tfpIn,file);
+      deserialize(tfpOut,file);
+      assert(*tfpIn == *tfpOut);
+      tfpOut = NULL;
+  
+      serialize(tstrIn,file);
+      deserialize(tstrOut,file);
+      assert(tstrIn == tstrOut);
+  
+      // updating
+      serialize(tbIn,"tb",file,true);
+      serialize(tcIn,"tc",file);
+      serialize(tiIn,"ti",file);
+      tiIn++;
+      serialize(tiIn,"ti",file);
+      tiIn++;
+      serialize(tiIn,"ti",file);
+      deserialize(tbOut,"tb",file);
+      deserialize(tcOut,"tc",file);
+      deserialize(tiOut,"ti",file);
+      assert(tbIn == tbOut);
+      assert(tcIn == tcOut);
+      assert(tiIn == tiOut);
+  
+      serialize(tsIn,"tsIn",file,true);
+      serialize(tVector1In,"tVector1In",file);
+      serialize(tVector2In,"tsIn",file);
+      deserialize(tVector2Out,"tsIn",file);
+      for(unsigned int i=0;i<tVector2In.size();i++)
+      {
+        assert(tVector2In[i].first == tVector2Out[i].first);
+        assert(tVector2In[i].second == tVector2Out[i].second);
+      }
+      tVector2Out.clear();
+  
+      serialize(tObjIn,file);
+      deserialize(tObjOut,file);
+      assert(tObjIn.tc == tObjOut.tc);
+      assert(*tObjIn.ti == *tObjOut.ti);
+      for(unsigned int i=0;i<tObjIn.tvb.size();i++)
+        assert(tObjIn.tvb[i] == tObjOut.tvb[i]);
+      tObjOut.ti = NULL;
+  
+      serialize(tPairIn,file);
+      deserialize(tPairOut,file);
+      assert(tPairIn.first == tPairOut.first);
+      assert(tPairIn.second == tPairOut.second);
+  
+      serialize(tVector1In,file);
+      deserialize(tVector1Out,file);
+      for(unsigned int i=0;i<tVector1In.size();i++)
+        assert(tVector1In[i] == tVector1Out[i]);
+  
+      serialize(tVector2In,file);
+      deserialize(tVector2Out,file);
+      for(unsigned int i=0;i<tVector2In.size();i++)
+      {
+        assert(tVector2In[i].first == tVector2Out[i].first);
+        assert(tVector2In[i].second == tVector2Out[i].second);
+      }
+  
+      serialize(tSetIn,file);
+      deserialize(tSetOut,file);
+      assert(tSetIn.size() == tSetOut.size());
+  
+      serialize(tMapIn,file);
+      deserialize(tMapOut,file);
+      assert(tMapIn.size() == tMapOut.size());
+  
+      serialize(tDenseMatrixIn,file);
+      deserialize(tDenseMatrixOut,file);
+      assert((tDenseMatrixIn - tDenseMatrixOut).sum() == 0);
+  
+      serialize(tDenseRowMatrixIn,file);
+      deserialize(tDenseRowMatrixOut,file);
+      assert((tDenseRowMatrixIn - tDenseRowMatrixOut).sum() == 0);
+  
+      serialize(tSparseMatrixIn,file);
+      deserialize(tSparseMatrixOut,file);
+      assert((tSparseMatrixIn - tSparseMatrixOut).sum() == 0);
+  
+      serialize(testB,file);
+      deserialize(testC,file);
+      assert(testB.ts == testC.ts);
+      assert(testB.tvt.size() == testC.tvt.size());
+      for(unsigned int i=0;i<testB.tvt.size();i++)
+      {
+        assert(testB.tvt[i]->ts == testC.tvt[i]->ts);
+        assert(testB.tvt[i]->tvt.size() == testC.tvt[i]->tvt.size());
+        assert(testB.tvt[i]->tt == testC.tvt[i]->tt);
+      }
+      assert(testB.tt->ts == testC.tt->ts);
+      assert(testB.tt->tvt.size() == testC.tt->tvt.size());
+      assert(testB.tt->tt == testC.tt->tt);
+      testC = Test1();
+  
+      // big data test
+      /*std::vector<std::vector<float> > bigDataIn,bigDataOut;
+      for(unsigned int i=0;i<10000;i++)
+      {
+      std::vector<float> v;
+      for(unsigned int j=0;j<10000;j++)
+      {
+      v.push_back(j);
+      }
+      bigDataIn.push_back(v);
+      }
+  
+      Timer timer;
+      timer.start();
+      serialize(bigDataIn,file);
+      timer.stop();
+      std::cout << "ser: " << timer.getElapsedTimeInMilliSec() << std::endl;
+  
+      timer.start();
+      deserialize(bigDataOut,file);
+      timer.stop();
+      std::cout << "des: " << timer.getElapsedTimeInMilliSec() << std::endl;
+      char c;
+      std::cin >> c; */
+  
+      // xml serialization
+  
+      serialize_xml(tbIn,file);
+      deserialize_xml(tbOut,file);
+      assert(tbIn == tbOut);
+  
+      serialize_xml(tcIn,file);
+      deserialize_xml(tcOut,file);
+      assert(tcIn == tcOut);
+  
+      serialize_xml(tucIn,file);
+      deserialize_xml(tucOut,file);
+      assert(tucIn == tucOut);
+  
+      serialize_xml(tsIn,file);
+      deserialize_xml(tsOut,file);
+      assert(tsIn == tsOut);
+  
+      serialize_xml(tiIn,file);
+      deserialize_xml(tiOut,file);
+      assert(tiIn == tiOut);
+  
+      serialize_xml(tuiIn,file);
+      deserialize_xml(tuiOut,file);
+      assert(tuiIn == tuiOut);
+  
+      serialize_xml(tfIn,file);
+      deserialize_xml(tfOut,file);
+      assert(tfIn == tfOut);
+  
+      serialize_xml(tdIn,file);
+      deserialize_xml(tdOut,file);
+      assert(tdIn == tdOut);
+  
+      serialize_xml(tinpIn,file);
+      deserialize_xml(tinpOut,file);
+      assert(tinpIn == tinpOut);
+  
+      serialize_xml(tfpIn,file);
+      deserialize_xml(tfpOut,file);
+      assert(*tfpIn == *tfpOut);
+  
+      serialize_xml(tstrIn,file);
+      deserialize_xml(tstrOut,file);
+      assert(tstrIn == tstrOut);
+  
+      // updating
+      serialize_xml(tbIn,"tb",file,false,true);
+      serialize_xml(tcIn,"tc",file);
+      serialize_xml(tiIn,"ti",file);
+      tiIn++;
+      serialize_xml(tiIn,"ti",file);
+      tiIn++;
+      serialize_xml(tiIn,"ti",file);
+      deserialize_xml(tbOut,"tb",file);
+      deserialize_xml(tcOut,"tc",file);
+      deserialize_xml(tiOut,"ti",file);
+      assert(tbIn == tbOut);
+      assert(tcIn == tcOut);
+      assert(tiIn == tiOut);
+  
+      serialize_xml(tsIn,"tsIn",file,false,true);
+      serialize_xml(tVector1In,"tVector1In",file);
+      serialize_xml(tVector2In,"tsIn",file);
+      deserialize_xml(tVector2Out,"tsIn",file);
+      for(unsigned int i=0;i<tVector2In.size();i++)
+      {
+        assert(tVector2In[i].first == tVector2Out[i].first);
+        assert(tVector2In[i].second == tVector2Out[i].second);
+      }
+      tVector2Out.clear();
+  
+      // binarization
+      serialize_xml(tVector2In,"tVector2In",file,true);
+      deserialize_xml(tVector2Out,"tVector2In",file);
+      for(unsigned int i=0;i<tVector2In.size();i++)
+      {
+        assert(tVector2In[i].first == tVector2Out[i].first);
+        assert(tVector2In[i].second == tVector2Out[i].second);
+      }
+  
+      serialize_xml(tObjIn,file);
+      deserialize_xml(tObjOut,file);
+      assert(tObjIn.tc == tObjOut.tc);
+      assert(*tObjIn.ti == *tObjOut.ti);
+      for(unsigned int i=0;i<tObjIn.tvb.size();i++)
+        assert(tObjIn.tvb[i] == tObjOut.tvb[i]);
+  
+      serialize_xml(tPairIn,file);
+      deserialize_xml(tPairOut,file);
+      assert(tPairIn.first == tPairOut.first);
+      assert(tPairIn.second == tPairOut.second);
+  
+      serialize_xml(tVector1In,file);
+      deserialize_xml(tVector1Out,file);
+      for(unsigned int i=0;i<tVector1In.size();i++)
+        assert(tVector1In[i] == tVector1Out[i]);
+  
+      serialize_xml(tVector2In,file);
+      deserialize_xml(tVector2Out,file);
+      for(unsigned int i=0;i<tVector2In.size();i++)
+      {
+        assert(tVector2In[i].first == tVector2Out[i].first);
+        assert(tVector2In[i].second == tVector2Out[i].second);
+      }
+  
+      serialize_xml(tSetIn,file);
+      deserialize_xml(tSetOut,file);
+      assert(tSetIn.size() == tSetOut.size());
+  
+      serialize_xml(tMapIn,file);
+      deserialize_xml(tMapOut,file);
+      assert(tMapIn.size() == tMapOut.size());
+  
+      serialize_xml(tDenseMatrixIn,file);
+      deserialize_xml(tDenseMatrixOut,file);
+      assert((tDenseMatrixIn - tDenseMatrixOut).sum() == 0);
+  
+      serialize_xml(tDenseRowMatrixIn,file);
+      deserialize_xml(tDenseRowMatrixOut,file);
+      assert((tDenseRowMatrixIn - tDenseRowMatrixOut).sum() == 0);
+  
+      serialize_xml(tSparseMatrixIn,file);
+      deserialize_xml(tSparseMatrixOut,file);
+      assert((tSparseMatrixIn - tSparseMatrixOut).sum() == 0);
+  
+      serialize_xml(testB,file);
+      deserialize_xml(testC,file);
+      assert(testB.ts == testC.ts);
+      assert(testB.tvt.size() == testC.tvt.size());
+      for(unsigned int i=0;i<testB.tvt.size();i++)
+      {
+        assert(testB.tvt[i]->ts == testC.tvt[i]->ts);
+        assert(testB.tvt[i]->tvt.size() == testC.tvt[i]->tvt.size());
+        assert(testB.tvt[i]->tt == testC.tvt[i]->tt);
+      }
+      assert(testB.tt->ts == testC.tt->ts);
+      assert(testB.tt->tvt.size() == testC.tt->tvt.size());
+      assert(testB.tt->tt == testC.tt->tt);
+  
+      // big data test
+      /*std::vector<std::vector<float> > bigDataIn,bigDataOut;
+      for(unsigned int i=0;i<10000;i++)
+      {
+      std::vector<float> v;
+      for(unsigned int j=0;j<10000;j++)
+      {
+      v.push_back(j);
+      }
+      bigDataIn.push_back(v);
+      }
+  
+      Timer timer;
+      timer.start();
+      serialize_xml(bigDataIn,"bigDataIn",file,seRIALIZE_BINARY);
+      timer.stop();
+      std::cout << "ser: " << timer.getElapsedTimeInMilliSec() << std::endl;
+  
+      timer.start();
+      deserialize_xml(bigDataOut,"bigDataIn",file);
+      timer.stop();
+      std::cout << "des: " << timer.getElapsedTimeInMilliSec() << std::endl;
+      char c;
+      std::cin >> c;*/
+  
+      std::cout << "All tests run successfully!\n";
+    }
+  }
+}
+
+//#endif