test/test_Iterator.cpp in rice-4.0.4 vs test/test_Iterator.cpp in rice-4.1.0

@@ -53,10 +53,15 @@
 
 namespace
 {
   struct Data
   {
+    Data(uint32_t value)
+    {
+      this->index = value;
+    }
+
     uint32_t index;
   };
 
   class ContainerValues
   {
@@ -74,10 +79,20 @@
     std::vector<Data>::iterator end()
     {
       return this->data_.end();
     }
 
+    std::vector<Data>::const_iterator cbegin() const
+    {
+      return this->data_.cbegin();
+    }
+
+    std::vector<Data>::const_iterator cend() const
+    {
+      return this->data_.cend();
+    }
+
     std::vector<Data> data_;
   };
 
   class ContainerPointers
   {
@@ -103,10 +118,20 @@
     std::vector<Data*>::iterator end()
     {
       return this->data_.end();
     }
 
+    std::vector<Data*>::reverse_iterator rbegin()
+    {
+      return this->data_.rbegin();
+    }
+
+    std::vector<Data*>::reverse_iterator rend()
+    {
+      return this->data_.rend();
+    }
+
     std::vector<Data*> data_;
   };
 }
 
 template <>
@@ -142,20 +167,124 @@
   ASSERT_EQUAL(Object(detail::to_ruby(1)), a[0]);
   ASSERT_EQUAL(Object(detail::to_ruby(2)), a[1]);
   ASSERT_EQUAL(Object(detail::to_ruby(3)), a[2]);
 }
 
+TESTCASE(const_iterator_value)
+{
+  define_class<ContainerValues>("ContainerValues")
+    .define_constructor(Constructor<ContainerValues>())
+    .define_iterator(&ContainerValues::cbegin, &ContainerValues::cend);
+
+  Module m = define_module("TestingModule");
+
+  std::string code = R"(result = []
+                        container = ContainerValues.new
+                        container.each do |x|
+                          result << x
+                        end
+                        result)";
+
+  Array result = m.module_eval(code);
+
+  ASSERT_EQUAL(3u, result.size());
+  ASSERT_EQUAL(Object(detail::to_ruby(1)), result[0]);
+  ASSERT_EQUAL(Object(detail::to_ruby(2)), result[1]);
+  ASSERT_EQUAL(Object(detail::to_ruby(3)), result[2]);
+}
+
 TESTCASE(iterator_pointer)
 {
   define_class<ContainerPointers>("ContainerPointers")
     .define_constructor(Constructor<ContainerPointers>())
     .define_iterator(&ContainerPointers::begin, &ContainerPointers::end);
 
   ContainerPointers* container = new ContainerPointers();
   Object wrapper = Data_Object<ContainerPointers>(container);
 
-  Array a = wrapper.instance_eval("a = []; each() { |x| a << x }; a");
-  ASSERT_EQUAL(3u, a.size());
-  ASSERT_EQUAL(Object(detail::to_ruby(1)), a[0]);
-  ASSERT_EQUAL(Object(detail::to_ruby(2)), a[1]);
-  ASSERT_EQUAL(Object(detail::to_ruby(3)), a[2]);
+  Module m = define_module("TestingModule");
+
+  std::string code = R"(result = []
+                        container = ContainerPointers.new
+                        container.each do |x|
+                          result << x
+                        end
+                        result)";
+
+  Array result = m.module_eval(code);
+
+  ASSERT_EQUAL(3u, result.size());
+  ASSERT_EQUAL(Object(detail::to_ruby(1)), result[0]);
+  ASSERT_EQUAL(Object(detail::to_ruby(2)), result[1]);
+  ASSERT_EQUAL(Object(detail::to_ruby(3)), result[2]);
 }
+
+TESTCASE(two_iterator_pointer)
+{
+  define_class<ContainerPointers>("ContainerPointers")
+    .define_constructor(Constructor<ContainerPointers>())
+    .define_iterator(&ContainerPointers::begin, &ContainerPointers::end)
+    .define_iterator(&ContainerPointers::rbegin, &ContainerPointers::rend, "reach");
+
+  ContainerPointers* container = new ContainerPointers();
+  Object wrapper = Data_Object<ContainerPointers>(container);
+
+  Module m = define_module("TestingModule");
+
+  std::string code = R"(result = []
+                        container = ContainerPointers.new
+                        container.each do |x|
+                          result << x
+                        end
+                        container.reach do |x|
+                          result << x
+                        end
+                        result)";
+
+  Array result = m.module_eval(code);
+
+  ASSERT_EQUAL(6u, result.size());
+  ASSERT_EQUAL(Object(detail::to_ruby(1)), result[0]);
+  ASSERT_EQUAL(Object(detail::to_ruby(2)), result[1]);
+  ASSERT_EQUAL(Object(detail::to_ruby(3)), result[2]);
+  ASSERT_EQUAL(Object(detail::to_ruby(3)), result[3]);
+  ASSERT_EQUAL(Object(detail::to_ruby(2)), result[4]);
+  ASSERT_EQUAL(Object(detail::to_ruby(1)), result[5]);
+}
+
+TESTCASE(map)
+{
+  define_class<ContainerPointers>("ContainerPointers")
+    .define_constructor(Constructor<ContainerPointers>())
+    .define_iterator(&ContainerPointers::begin, &ContainerPointers::end);
+
+  Module m = define_module("Testing");
+
+  std::string code = R"(container = ContainerPointers.new
+                        container.map do |x|
+                          x * 2
+                        end)";
+
+  Array result = m.module_eval(code);
+
+  ASSERT_EQUAL(3u, result.size());
+  ASSERT_EQUAL(Object(detail::to_ruby(2)), result[0]);
+  ASSERT_EQUAL(Object(detail::to_ruby(4)), result[1]);
+  ASSERT_EQUAL(Object(detail::to_ruby(6)), result[2]);
+}
+
+TESTCASE(to_enum)
+{
+  Module m = define_module("TestingModule");
+
+  std::string code = R"(container = ContainerPointers.new
+                        container.each.map do |x|
+                          x * 2
+                        end)";
+
+  Array result = m.module_eval(code);
+
+  ASSERT_EQUAL(3u, result.size());
+  ASSERT_EQUAL(Object(detail::to_ruby(2)), result[0]);
+  ASSERT_EQUAL(Object(detail::to_ruby(4)), result[1]);
+  ASSERT_EQUAL(Object(detail::to_ruby(6)), result[2]);
+}
\ No newline at end of file