rice 4.7.1 → 4.9.0

data/test/test_Callback.cpp

@@ -20,7 +20,7 @@ TEARDOWN(Callback)
 
 namespace
 {
-  using Callback_T = char*(*)(int, double, bool, char*);
+  using Callback_T = char*(*)(int, double, bool, char*, int&);
   Callback_T globalCallback;
 
   void registerCallback(Callback_T callback)
@@ -28,11 +28,11 @@ namespace
     globalCallback = callback;
   }
 
-  char* triggerCallback(int anInt, double aDouble, bool aBool, char* aString)
+  char* triggerCallback(int anInt, double aDouble, bool aBool, char* aString, int& intRef)
   {
     if (globalCallback)
     {
-      return globalCallback(anInt, aDouble, aBool, aString);
+      return globalCallback(anInt, aDouble, aBool, aString, intRef);
     }
     throw std::runtime_error("Callback has not been registered");
   }
@@ -41,13 +41,12 @@ namespace
 TESTCASE(LambdaCallBack)
 {
   Module m = define_module("TestingLambda");
-  m.define_module_function("register_callback", registerCallback).
-    define_module_function("trigger_callback", triggerCallback);
+  m.define_module_function("register_callback", registerCallback);
 
   ASSERT_EQUAL(globalCallback, nullptr);
 
-  std::string code = R"(callback = lambda do |an_int, a_double, a_bool, a_string|
-                                     values = [an_int, a_double, a_bool, a_string]
+  std::string code = R"(callback = lambda do |an_int, a_double, a_bool, a_string, an_intref|
+                                     values = [an_int, a_double, a_bool, a_string, an_intref]
                                      values.map {|value| value.to_s}.join(" - ")
                                    end
                         register_callback(callback))";
@@ -55,25 +54,26 @@ TESTCASE(LambdaCallBack)
   m.module_eval(code);
   ASSERT((globalCallback != nullptr));
 
-  String result = m.call("trigger_callback", 1, 2, true, "hello");
-  ASSERT_EQUAL("1 - 2.0 - true - hello", result.c_str());
+  int ref = 4;
+  char* result = triggerCallback(1, 2, true, "hello", ref);
+  ASSERT_EQUAL("1 - 2.0 - true - hello - 4", result);
 }
 
 TESTCASE(BlockCallBack)
 {
   Module m = define_module("TestingBlock");
-  m.define_module_function("register_callback", registerCallback).
+  m.define_module_function("register_callback", registerCallback, Arg("callback").setBlock()).
     define_module_function("trigger_callback", triggerCallback);
 
-  std::string code = R"(register_callback do |an_int, a_double, a_bool, a_string|
-                          values = [an_int, a_double, a_bool, a_string]
+  std::string code = R"(register_callback do |an_int, a_double, a_bool, a_string, an_intref|
+                          values = [an_int, a_double, a_bool, a_string, an_intref]
                           values.map {|value| value.to_s}.join(" - ")
                         end)";
 
   m.module_eval(code);
 
-  String result = m.call("trigger_callback", 4, 5.5, false, "Hello block");
-  ASSERT_EQUAL("4 - 5.5 - false - Hello block", result.c_str());
+  String result = m.call("trigger_callback", 4, 5.5, false, "Hello block", 8);
+  ASSERT_EQUAL("4 - 5.5 - false - Hello block - 8", result.c_str());
 }
 
 TESTCASE(ProcCallBack)
@@ -82,16 +82,17 @@ TESTCASE(ProcCallBack)
   m.define_module_function("register_callback", registerCallback).
     define_module_function("trigger_callback", triggerCallback);
 
-  std::string code = R"(callback = Proc.new do |an_int, a_double, a_bool, a_string|
-                                      values = [an_int, a_double, a_bool, a_string]
+  std::string code = R"(callback = Proc.new do |an_int, a_double, a_bool, a_string, an_intref|
+                                      values = [an_int, a_double, a_bool, a_string, an_intref]
                                       values.map {|value| value.to_s}.join(" - ")
                                    end
                         register_callback(callback))";
 
   m.module_eval(code);
 
-  String result = m.call("trigger_callback", 8, 4.4, true, "Hello proc");
-  ASSERT_EQUAL("8 - 4.4 - true - Hello proc", result.c_str());
+  int ref = 9;
+  String result = m.call("trigger_callback", 8, 4.4, true, "Hello proc", ref);
+  ASSERT_EQUAL("8 - 4.4 - true - Hello proc - 9", result.c_str());
 }
 
 TESTCASE(MethodCallBack)
@@ -100,16 +101,16 @@ TESTCASE(MethodCallBack)
   m.define_module_function("register_callback", registerCallback).
     define_module_function("trigger_callback", triggerCallback);
 
-  std::string code = R"(def self.callback(an_int, a_double, a_bool, a_string)
-                          values = [an_int, a_double, a_bool, a_string]
+  std::string code = R"(def self.callback(an_int, a_double, a_bool, a_string, an_intref)
+                          values = [an_int, a_double, a_bool, a_string, an_intref]
                           values.map {|value| value.to_s}.join(" - ")
                         end
                         register_callback(method(:callback).to_proc))";
 
   m.module_eval(code);
 
-  String result = m.call("trigger_callback", 11.1, 22.9, true, "Hello method");
-  ASSERT_EQUAL("11 - 22.9 - true - Hello method", result.c_str());
+  String result = m.call("trigger_callback", 11.1, 22.9, true, "Hello method", 17.2);
+  ASSERT_EQUAL("11 - 22.9 - true - Hello method - 17", result.c_str());
 }
 
 namespace
@@ -123,7 +124,7 @@ namespace
 TESTCASE(FunctionArg)
 {
   Module m = define_module("TestingFunctionArg");
-  m.define_module_function("function_arg", functionArg);
+  m.define_module_function("function_arg", functionArg, Arg("i"), Arg("block").setBlock());
 
   std::string code = R"(function_arg(4) do |i|
                           i * i
@@ -227,3 +228,56 @@ TESTCASE(UserData)
   String result = m.call("trigger_callback");
   ASSERT_EQUAL("TestingUserData::UserDataClass", result.c_str());
 }
+
+namespace
+{
+  using Callback_T4 = void(*)(void* userData);
+  Callback_T4 globalCallback4;
+  void* globalUserData4 = nullptr;
+
+  void registerCallback4(Callback_T4 callback, void* userData)
+  {
+    globalCallback4 = callback;
+    globalUserData4 = userData;
+  }
+
+  void triggerCallback4()
+  {
+    if (globalCallback4)
+    {
+      globalCallback4(globalUserData4);
+    }
+    else
+    {
+      throw std::runtime_error("Callback has not been registered");
+    }
+  }
+}
+
+TESTCASE(VoidReturn)
+{
+  Module m = define_module("TestingUserData");
+  m.define_module_function("register_callback4", registerCallback4, Arg("callback"), Arg("user_data").setOpaque()).
+    define_module_function("trigger_callback4", triggerCallback4);
+
+  define_callback<Callback_T4>(Arg("user_data").setOpaque());
+
+  std::string code = R"(class UserDataClass
+                        end
+
+                        user_data_1 = UserDataClass.new
+
+                        callback = Proc.new do |user_data_2|
+                                     unless user_data_1.equal?(user_data_2)
+                                       raise("Unexpected user data object")
+                                     end
+                                     user_data_2.class.name
+                                   end
+
+                        register_callback4(callback, user_data_1))";
+
+  m.module_eval(code);
+
+  Object result = m.call("trigger_callback4");
+  ASSERT_EQUAL(Qnil, result.value());
+}

data/test/test_Data_Object.cpp

@@ -33,7 +33,7 @@ namespace
 namespace Rice
 {
   template<>
-  void ruby_mark(MyDataType* myDataType)
+  void ruby_mark(MyDataType*)
   {
     test_ruby_mark_called = true;
   }

data/test/test_Data_Type.cpp

@@ -20,7 +20,7 @@ TEARDOWN(Data_Type)
   rb_gc_start();
 }
 
-namespace
+/*namespace
 {
   class MyClass
   {
@@ -38,7 +38,7 @@ namespace
       multiple_args_called = false;
     }
 
-    static Object singleton_method_object_int(Object object, int anInt)
+    static Object singleton_method_object_int(Object object, int)
     {
       return object;
     }
@@ -427,12 +427,12 @@ namespace
     RValue(RValue&& other) = default;
 
     // Move assignment operator.
-    RValue& operator=(RValue&& other) noexcept
+    RValue& operator=(RValue&&) noexcept
     {
       return *this;
     }
 
-    bool takesRValue(RValue&& rvalue)
+    bool takesRValue(RValue&&)
     {
       return true;
     }
@@ -499,7 +499,7 @@ TESTCASE(null_ptrs)
 
   result = o.call("set", nullptr);
   ASSERT_EQUAL(Qnil, result.value());
-}
+}*/
 
 namespace
 {
@@ -595,7 +595,7 @@ TESTCASE(pointers)
   result = object.call("check_void_helper", helper);
   ASSERT_EQUAL(Qtrue, result.value());
 }
-
+/*
 namespace
 {
   class BigObject
@@ -612,11 +612,11 @@ namespace
   class Processor
   {
   public:
-    BigObject** createBigObjects(size_t size)
+    BigObject** createBigObjects(int size)
     {
       BigObject** result = new BigObject*[size];
 
-      for (size_t i = 0; i < size; ++i)
+      for (int i = 0; i < size; ++i)
       {
         result[i] = new BigObject(i + 5);
       }
@@ -661,14 +661,14 @@ TESTCASE(pointerToPointer)
     .define_constructor(Constructor<Processor>())
     .define_method("create", &Processor::createBigObjects)
     .define_method("sum", &Processor::sumBigObjects,
-                          Arg("bigObjects").setBuffer(), Arg("size"))
+                          ArgBuffer("bigObjects"), Arg("size"))
     .define_method("sum_const", &Processor::sumBigObjectsConst,
-                                Arg("bigObjects").setBuffer(), Arg("size"));
+      ArgBuffer("bigObjects"), Arg("size"));
 
   std::string code = R"(count = 2
-                          processor = ProcessorClass.new
-                          big_objects = processor.create(count)
-                          processor.sum(big_objects, count))";
+                        processor = ProcessorClass.new
+                        big_objects = processor.create(count)
+                        processor.sum(big_objects, count))";
 
   Object result = m.module_eval(code);
   ASSERT_EQUAL(11, detail::From_Ruby<int>().convert(result));
@@ -688,15 +688,15 @@ namespace
   {
   };
 
-  void undefinedArg(UnknownClass unknownClass)
+  void undefinedArg(UnknownClass)
   {
   }
 
-  void undefinedArg(UnknownClass& unknownClass)
+  void undefinedArg(UnknownClass&)
   {
   }
 
-  void undefinedArg(UnknownClass* unknownClass)
+  void undefinedArg(UnknownClass*)
   {
   }
 
@@ -773,8 +773,6 @@ namespace RangesTest
     {
     }
 
-    RangeCustom(const RangeCustom& other) = default;
-
     int x;
     int y;
   };
@@ -826,7 +824,7 @@ TESTCASE(array_of_ranges)
     .define_attr("y", &RangesTest::RangeCustom::y);
 
   m.define_module_function("sum_ranges_array", RangesTest::sumRangesArray, 
-                                               Arg("ranges[]").setBuffer(), Arg("size"));
+                           ArgBuffer("ranges[]"), Arg("size"));
 
   std::string code = R"(range1 = RangeCustom.new(1, 2)
                         range2 = RangeCustom.new(3, 4)
@@ -849,7 +847,7 @@ TESTCASE(pointer_of_ranges)
     .define_attr("y", &RangesTest::RangeCustom::y);
 
   m.define_module_function<int(*)(const RangesTest::RangeCustom*, int)>("sum_ranges", RangesTest::sumRanges,
-                                                                        Arg("ranges").setBuffer(), Arg("size"));
+                                                                        ArgBuffer("ranges"), Arg("size"));
 
   std::string code = R"(range1 = RangeCustom.new(1, 2)
                         range2 = RangeCustom.new(3, 4)
@@ -872,7 +870,7 @@ TESTCASE(pointer_of_ranges_wrong)
     .define_attr("y", &RangesTest::RangeCustom::y);
 
   m.define_module_function<int(*)(const RangesTest::RangeCustom*, int)>("sum_ranges_wrong", RangesTest::sumRanges,
-                                  Arg("ranges").setBuffer());
+                                  ArgBuffer("ranges"));
 
   std::string code = R"(range1 = RangeCustom.new(1, 2)
                         range2 = RangeCustom.new(3, 4)
@@ -897,7 +895,7 @@ TESTCASE(pointer_of_pointer_ranges)
     .define_attr("x", &RangesTest::RangeCustom::x)
     .define_attr("y", &RangesTest::RangeCustom::y);
 
-  m.define_module_function<int(*)(const RangesTest::RangeCustom**, int)>("sum_ranges", RangesTest::sumRanges, Arg("ranges").setBuffer());
+  m.define_module_function<int(*)(const RangesTest::RangeCustom**, int)>("sum_ranges", RangesTest::sumRanges, ArgBuffer("ranges"));
 
   std::string code = R"(range1 = RangeCustom.new(1, 2)
                         range2 = RangeCustom.new(3, 4)
@@ -908,3 +906,4 @@ TESTCASE(pointer_of_pointer_ranges)
   Object result = m.module_eval(code);
   ASSERT_EQUAL(21, detail::From_Ruby<int>().convert(result));
 }
+*/

data/test/test_Director.cpp

@@ -85,10 +85,9 @@ namespace {
         return detail::From_Ruby<int>().convert( getSelf().call("process", num) );
       }
 
-      int default_process(int num)
+      int default_process(int)
       {
         raisePureVirtual();
-        return 0;
       }
 
       virtual int doSomething(int num)
@@ -222,10 +221,9 @@ namespace {
         return detail::From_Ruby<int>().convert( getSelf().call("do_it_impl", in) );
       }
 
-      int default_doItImpl(int in)
+      int default_doItImpl(int)
       {
         raisePureVirtual();
-        return 0;
       }
   };
 

data/test/test_Enum.cpp

@@ -76,7 +76,7 @@ TESTCASE(values)
   std::string code = R"(Color.values)";
 
   Array a = m.module_eval(code);
-  ASSERT_EQUAL(3u, a.size());
+  ASSERT_EQUAL(3, a.size());
 
   Data_Object<Color> enum_0(a[0]);
   ASSERT_EQUAL(RED, *enum_0);
@@ -96,7 +96,7 @@ TESTCASE(seasons_values)
   std::string code = R"(Season.values)";
 
   Array a = m.module_eval(code);
-  ASSERT_EQUAL(4u, a.size());
+  ASSERT_EQUAL(4, a.size());
 
   Data_Object<Season> enum_0(a[0]);
   ASSERT_EQUAL(Season::Spring, *enum_0);
@@ -198,8 +198,33 @@ TESTCASE(eql)
   Module m = define_module("Testing");
 
   Enum<Color> colorEnum = define_color_enum();
-  ASSERT_EQUAL(detail::to_ruby(false), m.module_eval("Color::RED == Color::BLACK").value());
-  ASSERT_EQUAL(detail::to_ruby(true), m.module_eval("Color::GREEN == Color::GREEN").value());
+  ASSERT_EQUAL(Qfalse, m.module_eval("Color::RED == Color::BLACK").value());
+  ASSERT_EQUAL(Qtrue, m.module_eval("Color::GREEN == Color::GREEN").value());
+}
+
+TESTCASE(case_eql)
+{
+  Module m = define_module("Testing");
+
+  Enum<Color> colorEnum = define_color_enum();
+
+ /* Object result = m.module_eval("Color::RED === Color::BLACK");
+  ASSERT_EQUAL(Qfalse, result.value());
+
+  result = m.module_eval("Color::GREEN === Color::GREEN");
+  ASSERT_EQUAL(Qtrue, result.value());*/
+
+  Object result = m.module_eval("Color::RED === 0");
+  ASSERT_EQUAL(Qtrue, result.value());
+  
+  result = m.module_eval("0 == Color::RED");
+  ASSERT_EQUAL(Qtrue, result.value());
+
+  result = m.module_eval("Color::RED === 1");
+  ASSERT_EQUAL(Qfalse, result.value());
+
+  result = m.module_eval("1 == Color::RED");
+  ASSERT_EQUAL(Qfalse, result.value());
 }
 
 TESTCASE(compare_equal)
@@ -207,8 +232,12 @@ TESTCASE(compare_equal)
   Enum<Color> colorEnum = define_color_enum();
   Object color1 = colorEnum.const_get("RED");
   Object color2 = colorEnum.const_get("RED");
+
   Object result = color1.call("<=>", color2);
   ASSERT_EQUAL(0, detail::From_Ruby<int>().convert(result));
+
+  result = color1.call("<=>", 0);
+  ASSERT_EQUAL(0, detail::From_Ruby<int>().convert(result));
 }
 
 TESTCASE(compare_less)
@@ -398,7 +427,7 @@ namespace
 {
   enum class Undefined { A, B, C };
 
-  void undefinedArg(Undefined undefined)
+  void undefinedArg(Undefined)
   {
   }
 

data/test/test_File.cpp

@@ -26,6 +26,12 @@ namespace
   {
     std::filesystem::path path = __FILE__;
     FILE* fptr = fopen(path.string().c_str(), "rb");
+    if (!fptr)
+    {
+      int err = errno;
+      throw std::runtime_error("Failed to open file '" + path.string() + "': " +
+        std::strerror(err) + " (errno=" + std::to_string(err) + ")");
+    }
     return fptr;
   }
 
@@ -41,12 +47,10 @@ namespace
     return result.str();
   }
 
-  bool closeFile(FILE* fptr)
+  bool closeFile(FILE*)
   {
-    // Ruby override fclose and replaces it with rb_w32_fclose which causes a segementation fault. Oy!
-#ifndef _MSC_VER
-    fclose(fptr);
-#endif
+    // crashes on windows due to Ruby overriding and mixing UCRTs
+    //fclose(fptr);
     return true;
   }
 }

data/test/test_From_Ruby.cpp

@@ -83,7 +83,7 @@ TESTCASE(bool)
 {
   ASSERT_EQUAL(detail::Convertible::Exact, detail::From_Ruby<bool>().is_convertible(Qfalse));
   ASSERT_EQUAL(detail::Convertible::Exact, detail::From_Ruby<bool>().is_convertible(Qtrue));
-  ASSERT_EQUAL(detail::Convertible::Cast, detail::From_Ruby<bool>().is_convertible(Qnil));
+  ASSERT_EQUAL(detail::Convertible::Exact, detail::From_Ruby<bool>().is_convertible(Qnil));
   ASSERT_EQUAL(detail::Convertible::None, detail::From_Ruby<bool>().is_convertible(INT2NUM(3)));
   ASSERT_EQUAL(detail::Convertible::None, detail::From_Ruby<bool>().is_convertible(rb_float_new(3.33)));
   ASSERT_EQUAL(detail::Convertible::None, detail::From_Ruby<bool>().is_convertible(rb_str_new2("some string")));
@@ -327,6 +327,7 @@ TESTCASE(unsigned_char_pointer_array)
 
 TESTCASE(double)
 {
+#undef min
   ASSERT_EQUAL(0.0, detail::From_Ruby<double>().convert(rb_float_new(0.0)));
   ASSERT_EQUAL(-1.0, detail::From_Ruby<double>().convert(rb_float_new(-1.0)));
   ASSERT_EQUAL(1.0, detail::From_Ruby<double>().convert(rb_float_new(1.0)));
@@ -414,7 +415,7 @@ TESTCASE(float_array_array)
 {
   Module m = define_module("Testing");
 
-  m.define_singleton_function("array_array_to_string", &arrayofArraysToString<float>, Arg("buffer").setBuffer());
+  m.define_singleton_function("array_array_to_string", &arrayofArraysToString<float>, ArgBuffer("buffer"));
 
   std::string code = R"(buffer = Rice::Buffer≺float∗≻.new([[1.1, 2.2], [3.3, 4.4], [5.5, 6.6]])
                         array_array_to_string(buffer.data, buffer.size, 2))";
@@ -517,7 +518,7 @@ TESTCASE(unsigned_long)
 {
   ASSERT_EQUAL(0u, detail::From_Ruby<unsigned long>().convert(ULONG2NUM(0)));
   ASSERT_EQUAL(1u, detail::From_Ruby<unsigned long>().convert(ULONG2NUM(1)));
-  ASSERT_EQUAL(static_cast<unsigned long>(FIXNUM_MIN),
+  ASSERT_EQUAL((unsigned long)(FIXNUM_MIN),
     detail::From_Ruby<unsigned long>().convert(ULONG2NUM(FIXNUM_MIN)));
   ASSERT_EQUAL(std::numeric_limits<unsigned long>::min(),
     detail::From_Ruby<unsigned long>().convert(ULONG2NUM(std::numeric_limits<unsigned long>::min())));

data/test/test_GVL.cpp

@@ -44,7 +44,7 @@ namespace
       {
       }
 
-      int run(bool arg1)
+      int run(bool)
       {
         std::this_thread::sleep_for(std::chrono::milliseconds(100));
         return this->id_;
@@ -64,7 +64,7 @@ TESTCASE(Function)
 TESTCASE(FunctionViaRuby)
 {
   Module m = define_module("Testing");
-  m.define_module_function("slow_function_1", &slowFunction1, Function().setNoGvl());
+  m.define_module_function("slow_function_1", &slowFunction1, NoGVL());
   
   std::string code = R"(slow_function_1)";
   Object result = m.module_eval(code);
@@ -99,7 +99,7 @@ TESTCASE(MemberFunctionNoGvl)
 
   Class task = define_class_under<Task>(m, "Task")
     .define_constructor(Constructor<Task, int>())
-    .define_method("run", &Task::run, Function().setNoGvl());
+    .define_method("run", &Task::run, NoGVL());
 
   std::string code = R"(task = Task.new(85)
                         task.run(true))";

data/test/test_Hash.cpp

@@ -210,7 +210,7 @@ TESTCASE(iterate_and_change)
  */
 
 namespace {
-  void testHashArg(Object self, Hash string) {
+  void testHashArg(Object, Hash) {
   }
 }
 

data/test/test_Inheritance.cpp

@@ -128,12 +128,12 @@ TESTCASE(base_pointer_method_call)
 
   Module m = define_module("Testing");
 
-  Object message = m.module_eval(R"EOS(notification = EmailNotification.new
-                                         notification.message)EOS");
+  Object message = m.module_eval(R"(notification = EmailNotification.new
+                                    notification.message)");
   ASSERT_EQUAL("Email", detail::From_Ruby<std::string>().convert(message));
 
-  message = m.module_eval(R"EOS(notification = PushNotification.new
-                                  notification.message)EOS");
+  message = m.module_eval(R"(notification = PushNotification.new
+                             notification.message)");
   ASSERT_EQUAL("Push", detail::From_Ruby<std::string>().convert(message));
 }
 
@@ -151,12 +151,12 @@ TESTCASE(base_pointer_function_argument)
   define_global_function("process_notification", &processNotification);
 
   Module m = define_module("Testing");
-  Object message = m.module_eval(R"EOS(notification = EmailNotification.new
-                                         process_notification(notification))EOS");
+  Object message = m.module_eval(R"(notification = EmailNotification.new
+                                    process_notification(notification))");
   ASSERT_EQUAL("Email", detail::From_Ruby<std::string>().convert(message));
 
-  message = m.module_eval(R"EOS(notification = PushNotification.new
-                                  process_notification(notification))EOS");
+  message = m.module_eval(R"(notification = PushNotification.new
+                             process_notification(notification))");
   ASSERT_EQUAL("Push", detail::From_Ruby<std::string>().convert(message));
 }
 
@@ -175,12 +175,12 @@ TESTCASE(module_base_pointer_method_call)
 
   Module m = define_module("Testing");
 
-  Object message = m.module_eval(R"EOS(notification = Inheritance::EmailNotification.new
-                                       notification.message)EOS");
+  Object message = m.module_eval(R"(notification = Inheritance::EmailNotification.new
+                                    notification.message)");
   ASSERT_EQUAL("Email", detail::From_Ruby<std::string>().convert(message));
 
-  message = m.module_eval(R"EOS(notification = Inheritance::PushNotification.new
-                                  notification.message)EOS");
+  message = m.module_eval(R"(notification = Inheritance::PushNotification.new
+                             notification.message)");
   ASSERT_EQUAL("Push", detail::From_Ruby<std::string>().convert(message));
 }
 
@@ -219,8 +219,8 @@ TESTCASE(base_pointer_constructor)
 
   Module m = define_module("Testing");
 
-  Object result = m.module_eval(R"EOS(notification = PushNotification.new
+  Object result = m.module_eval(R"(notification = PushNotification.new
                                         processor = Processor.new(notification)
-                                        processor.process)EOS");
+                                        processor.process)");
   ASSERT_EQUAL("Push", detail::From_Ruby<std::string>().convert(result));
 }