[GitHub] [incubator-wayang] github-actions[bot] opened a new issue, #203: add the missing test for get_type_bifunction

[GitBox <gi...@apache.org>]

github-actions[bot] opened a new issue, #203:
URL: https://github.com/apache/incubator-wayang/issues/203

   add the missing test for get_type_bifunction
   
   https://github.com/apache/incubator-wayang/blob/4cc0bfdca06dda171b661822daae5fa438d9d475/python/src/pywy/tests/unit/types_test.py#L251
   
   ```python
   
   #
   #  Licensed to the Apache Software Foundation (ASF) under one or more
   #  contributor license agreements.  See the NOTICE file distributed with
   #  this work for additional information regarding copyright ownership.
   #  The ASF licenses this file to You under the Apache License, Version 2.0
   #  (the "License"); you may not use this file except in compliance with
   #  the License.  You may obtain a copy of the License at
   #
   #      http://www.apache.org/licenses/LICENSE-2.0
   #
   #  Unless required by applicable law or agreed to in writing, software
   #  distributed under the License is distributed on an "AS IS" BASIS,
   #  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   #  See the License for the specific language governing permissions and
   #  limitations under the License.
   #
   
   import inspect
   import unittest
   from unittest.mock import Mock
   
   from pywy.exception import PywyException
   from pywy.types import get_type_function, get_type_bifunction, get_type_flatmap_function, get_type_predicate
   
   empty_type = inspect._empty
   
   
   class TestUnitTypesPredicate(unittest.TestCase):
       def setUp(self):
           pass
   
       def test_predicate_without_parameters(self):
           def pred() -> bool:
               return True
   
           try:
               get_type_predicate(pred)
               self.fail("The predicates parameters are mandatory")
           except PywyException as ex:
               self.assertTrue("the parameters for the Predicate are distinct than one," in str(ex))
   
       def test_predicate_with_one_parameter_no_type(self):
           def pred(x) -> bool:
               return True
   
           try:
               pred_type = get_type_predicate(pred)
               self.assertEqual(pred_type, empty_type)
           except PywyException as ex:
               self.fail(str(ex))
   
       def test_predicate_with_one_parameter_with_basic_type(self):
           def pred(x: int) -> bool:
               return True
   
           try:
               pred_type = get_type_predicate(pred)
               self.assertEqual(pred_type, int)
           except PywyException as ex:
               self.fail(str(ex))
   
       def test_predicate_with_one_parameter_with_obe_type(self):
           def pred(x: Mock) -> bool:
               return True
   
           try:
               pred_type = get_type_predicate(pred)
               self.assertEqual(pred_type, Mock)
           except PywyException as ex:
               self.fail(str(ex))
   
       def test_predicate_with_two_parameters(self):
           def pred(x: Mock, y: Mock) -> bool:
               return True
   
           try:
               get_type_predicate(pred)
               self.fail("the predicate can have just one input")
           except PywyException as ex:
               self.assertTrue("the parameters for the Predicate are distinct than one" in str(ex))
   
   
   class TestUnitTypesFunction(unittest.TestCase):
       def setUp(self):
           pass
   
       def test_function_without_parameters_no_return(self):
           def func():
               return
   
           try:
               get_type_function(func)
               self.fail("The function parameters are mandatory")
           except PywyException as ex:
               self.assertTrue("the parameters for the Function are distinct than one," in str(ex))
   
       def test_function_with_one_parameter_no_type_no_return(self):
           def func(x):
               return
   
           try:
               input_type, output_type = get_type_function(func)
               self.assertEqual(input_type, empty_type)
               self.assertEqual(output_type, empty_type)
           except PywyException as ex:
               self.fail(str(ex))
   
       def test_function_with_one_parameter_with_basic_type_no_return(self):
           def func(x: int):
               return
   
           try:
               input_type, output_type = get_type_function(func)
               self.assertEqual(input_type, int)
               self.assertEqual(output_type, empty_type)
           except PywyException as ex:
               self.fail(str(ex))
   
       def test_function_with_one_parameter_with_obj_type_no_return(self):
           def func(x: Mock):
               return
   
           try:
               input_type, output_type = get_type_function(func)
               self.assertEqual(input_type, Mock)
               self.assertEqual(output_type, empty_type)
           except PywyException as ex:
               self.fail(str(ex))
   
       def test_function_with_two_parameters_no_return(self):
           def func(x: Mock, y: Mock):
               return
   
           try:
               get_type_function(func)
               self.fail("the function can have just one input")
           except PywyException as ex:
               self.assertTrue("the parameters for the Function are distinct than one" in str(ex))
   
       def test_function_without_parameters_basic_return(self):
           def func() -> int:
               return 0
   
           try:
               get_type_function(func)
               self.fail("The function parameters are mandatory")
           except PywyException as ex:
               self.assertTrue("the parameters for the Function are distinct than one," in str(ex))
   
       def test_function_with_one_parameter_no_type_basic_return(self):
           def func(x) -> int:
               return 0
   
           try:
               input_type, output_type = get_type_function(func)
               self.assertEqual(input_type, empty_type)
               self.assertEqual(output_type, int)
           except PywyException as ex:
               self.fail(str(ex))
   
       def test_function_with_one_parameter_with_basic_type_basic_return(self):
           def func(x: int) -> int:
               return 0
   
           try:
               input_type, output_type = get_type_function(func)
               self.assertEqual(input_type, int)
               self.assertEqual(output_type, int)
           except PywyException as ex:
               self.fail(str(ex))
   
       def test_function_with_one_parameter_with_obj_type_basic_return(self):
           def func(x: Mock) -> int:
               return 0
   
           try:
               input_type, output_type = get_type_function(func)
               self.assertEqual(input_type, Mock)
               self.assertEqual(output_type, int)
           except PywyException as ex:
               self.fail(str(ex))
   
       def test_function_with_two_parameters_basic_return(self):
           def func(x: Mock, y: Mock) -> int:
               return 0
   
           try:
               get_type_function(func)
               self.fail("the function can have just one input")
           except PywyException as ex:
               self.assertTrue("the parameters for the Function are distinct than one" in str(ex))
   
       def test_function_without_parameters_obj_return(self):
           def func() -> Mock:
               return Mock()
   
           try:
               get_type_function(func)
               self.fail("The function parameters are mandatory")
           except PywyException as ex:
               self.assertTrue("the parameters for the Function are distinct than one," in str(ex))
   
       def test_function_with_one_parameter_no_type_obj_return(self):
           def func(x) -> Mock:
               return Mock()
   
           try:
               input_type, output_type = get_type_function(func)
               self.assertEqual(input_type, empty_type)
               self.assertEqual(output_type, Mock)
           except PywyException as ex:
               self.fail(str(ex))
   
       def test_function_with_one_parameter_with_basic_type_basic_return(self):
           def func(x: int) -> Mock:
               return Mock()
   
           try:
               input_type, output_type = get_type_function(func)
               self.assertEqual(input_type, int)
               self.assertEqual(output_type, Mock)
           except PywyException as ex:
               self.fail(str(ex))
   
       def test_function_with_one_parameter_with_obe_type_basic_return(self):
           def func(x: Mock) -> Mock:
               return Mock()
   
           try:
               input_type, output_type = get_type_function(func)
               self.assertEqual(input_type, Mock)
               self.assertEqual(output_type, Mock)
           except PywyException as ex:
               self.fail(str(ex))
   
       def test_function_with_two_parameters_basic_return(self):
           def func(x: Mock, y: Mock) -> Mock:
               return Mock()
   
           try:
               get_type_function(func)
               self.fail("the function can have just one input")
           except PywyException as ex:
               self.assertTrue("the parameters for the Function are distinct than one" in str(ex))
   
   
   class TestUnitTypesBiFunction(unittest.TestCase):
       def setUp(self):
           pass
   
       # TODO add the missing test for get_type_bifunction
       def test_bifunction_without_parameters_no_return(self):
           def func():
               return
   
           try:
               get_type_bifunction(func)
               self.fail("The bifunction parameters are mandatory")
           except PywyException as ex:
               self.assertTrue("the parameters for the BiFunction are distinct than two," in str(ex))
   
   
   class TestUnitTypesFlatmapFunction(unittest.TestCase):
       def setUp(self):
           pass
   
       # TODO add the missing test for get_type_flatmap_function
       def test_flatmapfunction_without_parameters_no_return(self):
           def func():
               return
   
           try:
               get_type_flatmap_function(func)
               self.fail("The bifunction parameters are mandatory")
           except PywyException as ex:
               self.assertTrue("the parameters for the FlatmapFunction are distinct than one," in str(ex))
   
   ```
   
   7dc2f76a86e926a07b18c116b5637f9cfdf8dda6


-- 
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.

To unsubscribe, e-mail: commits-unsubscribe@wayang.apache.org.apache.org

For queries about this service, please contact Infrastructure at:
users@infra.apache.org

[GitHub] [incubator-wayang] glauesppen closed issue #203: add the missing test for get_type_bifunction

["glauesppen (via GitHub)" <gi...@apache.org>]

glauesppen closed issue #203: add the missing test for get_type_bifunction
URL: https://github.com/apache/incubator-wayang/issues/203


-- 
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.

To unsubscribe, e-mail: commits-unsubscribe@wayang.apache.org

For queries about this service, please contact Infrastructure at:
users@infra.apache.org