Python Test for overloaded functions

Author: konn

examples/pure/pure.pyi

@@ -44,16 +44,28 @@ class B(A):
 
 class Incrementer:
     @typing.overload
-    def increment_1(self, x:builtins.int) -> builtins.int: ...
+    def increment_1(self, x:builtins.int) -> builtins.int:
+        r"""
+        And this is for the second comment
+        """
     @typing.overload
-    def increment_1(self, x:builtins.float) -> builtins.float: ...
+    def increment_1(self, x:builtins.float) -> builtins.float:
+        r"""
+        This is the original doc comment
+        """
     def new(self) -> Incrementer: ...
 
 class Incrementer2:
     @typing.overload
-    def increment_2(self, x:builtins.int) -> builtins.int: ...
+    def increment_2(self, x:builtins.int) -> builtins.int:
+        r"""
+        increment_2 for integers, submitted by hands
+        """
     @typing.overload
-    def increment_2(self, x:builtins.float) -> builtins.float: ...
+    def increment_2(self, x:builtins.float) -> builtins.float:
+        r"""
+        increment_2 for floats, submitted by hands
+        """
     def __new__(cls) -> Incrementer2:
         r"""
         Constructor for Incrementer2
@@ -199,12 +211,15 @@ def overload_example_1(x:builtins.float) -> builtins.float:
     """
 
 @typing.overload
-def overload_example_2(x:builtins.int) -> builtins.int: ...
+def overload_example_2(x:builtins.int) -> builtins.int:
+    r"""
+    Increments integer by 1
+    """
 
 @typing.overload
 def overload_example_2(x:builtins.float) -> builtins.float:
     r"""
-    Increments float or integer by 1
+    Increments float by 1
     """
 
 def print_c(c:typing.Optional[builtins.int]=None) -> None: ...

examples/pure/src/lib.rs

@@ -296,7 +296,7 @@ submit! {
         }],
         r#return: || f64::type_output(),
         module: None,
-        doc: "Increments float or integer by 1",
+        doc: "Increments float by 1",
     }
 }
 
@@ -310,7 +310,7 @@ submit! {
         }],
         r#return: || i64::type_output(),
         module: None,
-        doc: "",
+        doc: "Increments integer by 1",
     }
 }
 
@@ -327,6 +327,7 @@ impl Incrementer {
         Incrementer {}
     }
 
+    /// This is the original doc comment
     fn increment_1(&self, x: f64) -> f64 {
         x + 1.0
     }
@@ -350,7 +351,7 @@ submit! {
                 ],
                 r#type: MethodType::Instance,
                 r#return: || i64::type_output(),
-                doc: "",
+                doc: "And this is for the second comment",
             }
         ],
     }
@@ -392,7 +393,7 @@ submit! {
                 ],
                 r#type: MethodType::Instance,
                 r#return: || i64::type_output(),
-                doc: "",
+                doc: "increment_2 for integers, submitted by hands",
             },
             MethodInfo {
                 name: "__new__",
@@ -412,7 +413,7 @@ submit! {
                 ],
                 r#type: MethodType::Instance,
                 r#return: || f64::type_output(),
-                doc: "",
+                doc: "increment_2 for floats, submitted by hands",
             },
         ],
     }

examples/pure/tests/test_python.py

@@ -112,3 +112,35 @@ def test_path():
 
     out = echo_path("test")
     assert out == pathlib.Path("test")
+
+
+def test_overload_example_1():
+    from pure import overload_example_1
+
+    assert overload_example_1(1) == 2
+    assert overload_example_1(1.5) == 2.5
+
+
+def test_overload_example_2():
+    from pure import overload_example_2
+
+    assert overload_example_2(1) == 2
+    assert overload_example_2(1.5) == 2.5
+
+
+def test_overload_incrementer():
+    from pure import Incrementer
+
+    incr = Incrementer()
+
+    assert incr.increment_1(1.5) == 2.5
+    assert incr.increment_1(1) == 2
+
+
+def test_overload_incrementer_2():
+    from pure import Incrementer2
+
+    incr = Incrementer2()
+
+    assert incr.increment_2(1.5) == 2.5
+    assert incr.increment_2(1) == 2