dep-selector-libgecode 1.0.0.alpha.0

data/ext/libgecode3/vendor/gecode-3.7.3/test/array.cpp

@@ -0,0 +1,277 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Gregory Crosswhite <gcross@phys.washington.edu>
+ *
+ *  Copyright:
+ *     Gregory Crosswhite, 2011
+ *
+ *  Last modified:
+ *     $Date: 2011-05-26 00:56:41 +1000 (Thu, 26 May 2011) $ by $Author: schulte $
+ *     $Revision: 12022 $
+ *
+ *  This file is part of Gecode, the generic constraint
+ *  development environment:
+ *     http://www.gecode.org
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining
+ *  a copy of this software and associated documentation files (the
+ *  "Software"), to deal in the Software without restriction, including
+ *  without limitation the rights to use, copy, modify, merge, publish,
+ *  distribute, sublicense, and/or sell copies of the Software, and to
+ *  permit persons to whom the Software is furnished to do so, subject to
+ *  the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be
+ *  included in all copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ *  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ *  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ *  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ *  LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ *  OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ *  WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ */
+
+#include <gecode/kernel.hh>
+#include <gecode/int.hh>
+
+#include "test/test.hh"
+
+/// Check the test result and handle failed test
+#define CHECK_TEST(T,M)                                         \
+if (opt.log)                                                    \
+  olog << ind(3) << "Check: " << (M) << std::endl;              \
+if (!(T)) {                                                     \
+  problem = (M); goto failed;                         \
+}
+
+/// Start new test
+#define START_TEST(T)                                           \
+  if (opt.log) {                                                \
+     olog.str("");                                              \
+     olog << ind(2) << "Testing: " << (T) << std::endl;         \
+  }                                                             \
+  test = (T);
+
+namespace Test { 
+
+  /// Tests for arrays
+  namespace Array {
+
+  /// Test name prefix
+  static const std::string prefix("Array::Iterator::");
+
+  /// %Base class for testing iterators
+  class Iterator : public Test::Base {
+  protected:
+    /// Maximum array size
+    static const int n = 16;
+    /// Initialize test
+    Iterator(const std::string& name) : Test::Base(prefix + name) {}
+    /// Perform actual tests
+    template<class Array> bool runTestForArray(Array& a) {
+      // Test/problem information.
+      const char* test    = "NONE";
+      const char* problem = "NONE";
+      // Constant reference to the array
+      const Array& const_a = a;
+
+      START_TEST("Iteration");
+      {
+        typedef typename Array::reference reference;
+        typedef typename Array::pointer pointer;
+        typedef typename Array::iterator iterator;
+        const iterator begin = a.begin(), end = a.end();
+        CHECK_TEST(end-begin==a.size(),"Distance != size");
+        int index = 0;
+        iterator iter = begin;
+        for(; iter != end; ++iter, ++index) {
+          reference ref = *iter;
+          const pointer ptr = &ref;
+          CHECK_TEST(ptr==&a[index],"Iterator points to the wrong element (going forward)");
+        }
+        CHECK_TEST(index==a.size(),"Iteration covered the wrong number of elements (going forward)");
+        for(; iter != begin; --iter, --index) {
+          reference ref = *(iter-1);
+          const pointer ptr = &ref;
+          CHECK_TEST(ptr==&a[index-1],"Iterator points to the wrong element (going backwards)");
+        }
+        CHECK_TEST(index==0,"Iteration covered the wrong number of elements (going backward)");
+      }
+      START_TEST("Read-only iteration");
+      {
+        typedef typename Array::const_reference reference;
+        typedef typename Array::const_pointer pointer;
+        typedef typename Array::const_iterator iterator;
+        const iterator begin = const_a.begin(), end = const_a.end();
+        CHECK_TEST(end-begin==const_a.size(),"Distance != size");
+        int index = 0;
+        iterator iter = begin;
+        for(; iter != end; ++iter, ++index) {
+          reference ref = *iter;
+          const pointer ptr = &ref;
+          CHECK_TEST(ptr==&const_a[index],"Iterator points to the wrong element (going forward)");
+        }
+        CHECK_TEST(index==const_a.size(),"Iteration covered the wrong number of elements (going forward)");
+        for(; iter != begin; --iter, --index) {
+          reference ref = *(iter-1);
+          const pointer ptr = &ref;
+          CHECK_TEST(ptr==&const_a[index-1],"Iterator points to the wrong element (going backwards)");
+        }
+        CHECK_TEST(index==0,"Iteration covered the wrong number of elements (going backward)");
+      }
+
+      START_TEST("Reverse iteration");
+      {
+        typedef typename Array::reference reference;
+        typedef typename Array::pointer pointer;
+        typedef typename Array::reverse_iterator iterator;
+        const iterator begin = a.rbegin(), end = a.rend();
+        CHECK_TEST(end-begin==a.size(),"Distance != size");
+        int index = a.size();
+        iterator iter = begin;
+        for(; iter != end; ++iter, --index) {
+          reference ref = *iter;
+          const pointer ptr = &ref;
+          CHECK_TEST(ptr==&a[index-1],"Iterator points to the wrong element (going forward)");
+        }
+        CHECK_TEST(index==0,"Iteration covered the wrong number of elements (going forward)");
+        for(; iter != begin; --iter, ++index) {
+          reference ref = *(iter-1);
+          const pointer ptr = &ref;
+          CHECK_TEST(ptr==&a[index],"Iterator points to the wrong element (going backwards)");
+        }
+        CHECK_TEST(index==a.size(),"Iteration covered the wrong number of elements (going backward)");
+      }
+
+      START_TEST("Reverse read-only iteration");
+      {
+        typedef typename Array::const_reference reference;
+        typedef typename Array::const_pointer pointer;
+        typedef typename Array::const_reverse_iterator iterator;
+        const iterator begin = const_a.rbegin(), end = const_a.rend();
+        CHECK_TEST(end-begin==const_a.size(),"Distance != size");
+        int index = a.size();
+        iterator iter = begin;
+        for(; iter != end; ++iter, --index) {
+          reference ref = *iter;
+          const pointer ptr = &ref;
+          CHECK_TEST(ptr==&const_a[index-1],"Iterator points to the wrong element (going forward)");
+        }
+        CHECK_TEST(index==0,"Iteration covered the wrong number of elements (going forward)");
+        for(; iter != begin; --iter, ++index) {
+          reference ref = *(iter-1);
+          const pointer ptr = &ref;
+          CHECK_TEST(ptr==&const_a[index],"Iterator points to the wrong element (going backwards)");
+        }
+        CHECK_TEST(index==a.size(),"Iteration covered the wrong number of elements (going backward)");
+      }
+
+      return true;
+    failed:
+      if (opt.log)
+        olog << "FAILURE" << std::endl
+        << ind(1) << "Test:       " << test << std::endl
+        << ind(1) << "Problem:    " << problem << std::endl;
+      return false;
+    }
+  };
+
+  /// Test space
+  class TestSpace : public Gecode::Space {
+  public:
+    TestSpace(void) : Space() {}
+    TestSpace(bool share, TestSpace& s) : Space(share,s) {}
+    virtual Space* copy(bool share) {
+      return new TestSpace(share,*this);
+    }
+  };
+
+  /// %Class for testing the VarArray iterator
+  class VarArrayIterator : public Iterator {
+  protected:
+    /// Maximum array size
+    static const int n = 16;
+    /// Array type being tested
+    typedef Gecode::VarArray<Gecode::IntVar> Array;
+  public:
+    /// Initialize test
+    VarArrayIterator(void) : Iterator("VarArray") {}
+    /// Perform actual tests
+    bool run(void) {
+      // Space for the test
+      TestSpace s;
+      // VarArray for the test
+      Array a(s,rand(n));
+      // Run the iterator test
+      return runTestForArray(a);
+    }
+  } varArrayIteratorTest;
+
+  /// %Class for testing the VarArgs iterator
+  class VarArgsIterator : public Iterator {
+  protected:
+    /// Maximum array size
+    static const int n = 16;
+    /// Array type being tested
+    typedef Gecode::ArgArrayBase<int> Array;
+  public:
+    /// Initialize test
+    VarArgsIterator(void) : Iterator("VarArgs") {}
+    /// Perform actual tests
+    bool run(void) {
+      // Space for the test
+      TestSpace s;
+      // VarArray for the test
+      Array a(rand(n));
+      // Run the iterator test
+      return runTestForArray(a);
+    }
+  } varArgsIteratorTest;
+
+  /// %Class for testing the ViewArray iterator
+  class ViewArrayIterator : public Iterator {
+  protected:
+    /// Maximum array size
+    static const int n = 16;
+    /// Array type being tested
+    typedef Gecode::ViewArray<Gecode::IntVar> Array;
+  public:
+    /// Initialize test
+    ViewArrayIterator(void) : Iterator("ViewArray") {}
+    /// Perform actual tests
+    bool run(void) {
+      // Space for the test
+      TestSpace s;
+      // VarArray for the test
+      Array a(s,rand(n));
+      // Run the iterator test
+      return runTestForArray(a);
+    }
+  } viewArrayIteratorTest;
+
+  /// %Class for testing the SharedArray iterator
+  class SharedArrayIterator : public Iterator {
+  protected:
+    /// Maximum array size
+    static const int n = 16;
+    /// Array type being tested
+    typedef Gecode::SharedArray<int> Array;
+  public:
+    /// Initialize test
+    SharedArrayIterator(void) : Iterator("SharedArray") {}
+    /// Perform actual tests
+    bool run(void) {
+      // SharedArray for the test
+      Array a(rand(n));
+      // Run the iterator test
+      return runTestForArray(a);
+    }
+  } sharedArrayIteratorTest;
+
+}}
+
+// STATISTICS: test-kernel

data/ext/libgecode3/vendor/gecode-3.7.3/test/assign.cpp

@@ -0,0 +1,278 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2008
+ *
+ *  Last modified:
+ *     $Date: 2009-03-02 21:35:30 +1100 (Mon, 02 Mar 2009) $ by $Author: schulte $
+ *     $Revision: 8325 $
+ *
+ *  This file is part of Gecode, the generic constraint
+ *  development environment:
+ *     http://www.gecode.org
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining
+ *  a copy of this software and associated documentation files (the
+ *  "Software"), to deal in the Software without restriction, including
+ *  without limitation the rights to use, copy, modify, merge, publish,
+ *  distribute, sublicense, and/or sell copies of the Software, and to
+ *  permit persons to whom the Software is furnished to do so, subject to
+ *  the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be
+ *  included in all copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ *  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ *  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ *  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ *  LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ *  OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ *  WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ */
+
+#include "test/assign.hh"
+
+#include <gecode/search.hh>
+
+namespace Test { namespace Assign {
+
+  /// Space for executing integer tests
+  class IntTestSpace : public Gecode::Space {
+  public:
+    /// Variables to be tested
+    Gecode::IntVarArray x;
+    /// Initialize test space
+    IntTestSpace(int n, Gecode::IntSet& d)
+      : x(*this, n, d) {}
+    /// Constructor for cloning \a s
+    IntTestSpace(bool share, IntTestSpace& s)
+      : Gecode::Space(share,s) {
+      x.update(*this, share, s.x);
+    }
+    /// Copy space during cloning
+    virtual Gecode::Space* copy(bool share) {
+      return new IntTestSpace(share,*this);
+    }
+  };
+
+  /// Space for executing Boolean tests
+  class BoolTestSpace : public Gecode::Space {
+  public:
+    /// Variables to be tested
+    Gecode::BoolVarArray x;
+    /// Initialize test space
+    BoolTestSpace(int n)
+      : x(*this, n, 0, 1) {}
+    /// Constructor for cloning \a s
+    BoolTestSpace(bool share, BoolTestSpace& s)
+      : Gecode::Space(share,s) {
+      x.update(*this, share, s.x);
+    }
+    /// Copy space during cloning
+    virtual Gecode::Space* copy(bool share) {
+      return new BoolTestSpace(share,*this);
+    }
+  };
+
+#ifdef GECODE_HAS_SET_VARS
+
+  /// Space for executing Boolean tests
+  class SetTestSpace : public Gecode::Space {
+  public:
+    /// Variables to be tested
+    Gecode::SetVarArray x;
+    /// Initialize test space
+    SetTestSpace(int n, const Gecode::IntSet& d)
+      : x(*this, n, Gecode::IntSet::empty, d) {}
+    /// Constructor for cloning \a s
+    SetTestSpace(bool share, SetTestSpace& s)
+      : Gecode::Space(share,s) {
+      x.update(*this, share, s.x);
+    }
+    /// Copy space during cloning
+    virtual Gecode::Space* copy(bool share) {
+      return new SetTestSpace(share,*this);
+    }
+  };
+
+#endif
+
+  /** \name Collection of possible arguments for integer assignments
+   *
+   * \relates IntTestSpace BoolTestSpace
+   */
+  //@{
+  /// Integer value assignments
+  const Gecode::IntAssign int_assign[] = {
+    Gecode::INT_ASSIGN_MIN,
+    Gecode::INT_ASSIGN_MED,
+    Gecode::INT_ASSIGN_MAX,
+    Gecode::INT_ASSIGN_RND
+  };
+  /// Number of integer value selections
+  const int n_int_assign =
+    sizeof(int_assign)/sizeof(Gecode::IntAssign);
+  /// Names for integer assignments
+  const char* int_assign_name[] = {
+    "INT_ASSIGN_MIN",
+    "INT_ASSIGN_MED",
+    "INT_ASSIGN_MAX",
+    "INT_ASSIGN_RND"
+  };
+  //@}
+
+  IntTest::IntTest(const std::string& s, int a, const Gecode::IntSet& d)
+    : Base("Int::Assign::"+s), arity(a), dom(d) {
+  }
+
+  bool
+  IntTest::run(void) {
+    using namespace Gecode;
+    IntTestSpace* root = new IntTestSpace(arity,dom);
+    post(*root, root->x);
+    (void) root->status();
+
+    for (int val = n_int_assign; val--; ) {
+      IntTestSpace* clone = static_cast<IntTestSpace*>(root->clone(false));
+      Gecode::Search::Options o;
+      o.a_d = Base::rand(10);
+      o.c_d = Base::rand(10);
+      assign(*clone, clone->x, int_assign[val]);
+      Gecode::DFS<IntTestSpace> e_s(clone, o);
+      delete clone;
+
+      // Find number of solutions
+      int solutions = 0;
+      while (Space* s = e_s.next()) {
+        delete s; solutions++;
+      }
+      if (solutions != 1) {
+        std::cout << "FAILURE" << std::endl
+                  << "\tc_d=" << o.c_d << ", a_d=" << o.a_d << std::endl
+                  << "\t" << int_assign_name[val] << std::endl;
+        delete root;
+        return false;
+      }
+    }
+    delete root;
+    return true;
+  }
+
+  BoolTest::BoolTest(const std::string& s, int a)
+    : Base("Bool::Assign::"+s), arity(a) {
+  }
+
+  bool
+  BoolTest::run(void) {
+    using namespace Gecode;
+    BoolTestSpace* root = new BoolTestSpace(arity);
+    post(*root, root->x);
+    (void) root->status();
+
+    for (int val = n_int_assign; val--; ) {
+      BoolTestSpace* clone = static_cast<BoolTestSpace*>(root->clone(false));
+      Gecode::Search::Options o;
+      o.a_d = Base::rand(10);
+      o.c_d = Base::rand(10);
+      assign(*clone, clone->x, int_assign[val]);
+      Gecode::DFS<BoolTestSpace> e_s(clone, o);
+      delete clone;
+
+      // Find number of solutions
+      int solutions = 0;
+      while (Space* s = e_s.next()) {
+        delete s; solutions++;
+      }
+      if (solutions != 1) {
+        std::cout << "FAILURE" << std::endl
+                  << "\tc_d=" << o.c_d << ", a_d=" << o.a_d << std::endl
+                  << "\t" << int_assign_name[val] << std::endl;
+        delete root;
+        return false;
+      }
+    }
+    delete root;
+    return true;
+  }
+
+#ifdef GECODE_HAS_SET_VARS
+
+  /** \name Collection of possible arguments for set assignments
+   *
+   * \relates SetTestSpace
+   */
+  //@{
+  /// Set value assignments
+  const Gecode::SetAssign set_assign[] = {
+    Gecode::SET_ASSIGN_MIN_INC,
+    Gecode::SET_ASSIGN_MIN_EXC,
+    Gecode::SET_ASSIGN_MED_INC,
+    Gecode::SET_ASSIGN_MED_EXC,
+    Gecode::SET_ASSIGN_MAX_INC,
+    Gecode::SET_ASSIGN_MAX_EXC,
+    Gecode::SET_ASSIGN_RND_INC,
+    Gecode::SET_ASSIGN_RND_EXC
+  };
+  /// Number of set value selections
+  const int n_set_assign =
+    sizeof(set_assign)/sizeof(Gecode::SetAssign);
+  /// Names for integer assignments
+  const char* set_assign_name[] = {
+    "SET_ASSIGN_MIN_INC",
+    "SET_ASSIGN_MIN_EXC",
+    "SET_ASSIGN_MED_INC",
+    "SET_ASSIGN_MED_EXC",
+    "SET_ASSIGN_MAX_INC",
+    "SET_ASSIGN_MAX_EXC",
+    "SET_ASSIGN_RND_INC",
+    "SET_ASSIGN_RND_EXC"
+  };
+  //@}
+
+  SetTest::SetTest(const std::string& s, int a, const Gecode::IntSet& d)
+    : Base("Set::Assign::"+s), arity(a), dom(d) {
+  }
+
+  bool
+  SetTest::run(void) {
+    using namespace Gecode;
+    SetTestSpace* root = new SetTestSpace(arity,dom);
+    post(*root, root->x);
+    (void) root->status();
+
+    for (int val = n_int_assign; val--; ) {
+      SetTestSpace* clone = static_cast<SetTestSpace*>(root->clone(false));
+      Gecode::Search::Options o;
+      o.a_d = Base::rand(10);
+      o.c_d = Base::rand(10);
+      assign(*clone, clone->x, set_assign[val]);
+      Gecode::DFS<SetTestSpace> e_s(clone, o);
+      delete clone;
+
+      // Find number of solutions
+      int solutions = 0;
+      while (Space* s = e_s.next()) {
+        delete s; solutions++;
+      }
+      if (solutions != 1) {
+        std::cout << "FAILURE" << std::endl
+                  << "\tc_d=" << o.c_d << ", a_d=" << o.a_d << std::endl
+                  << "\t" << set_assign_name[val] << std::endl;
+        delete root;
+        return false;
+      }
+    }
+    delete root;
+    return true;
+  }
+
+#endif
+
+}}
+
+// STATISTICS: test-branch