new_contents: import unittest
  
  # The test cases here cover several paths through the function calling
  # code.  They depend on the METH_XXX flag that is used to define a C
  # function, which can't be verified from Python.  If the METH_XXX decl
  # for a C function changes, these tests may not cover the right paths.
  
  class CFunctionCalls(unittest.TestCase):
  
      def test_varargs0(self):
          self.assertRaises(TypeError, {}.__contains__)
  
      def test_varargs1(self):
          {}.__contains__(0)
  
      def test_varargs2(self):
          self.assertRaises(TypeError, {}.__contains__, 0, 1)
  
      def test_varargs0_ext(self):
          try:
              {}.__contains__(*())
          except TypeError:
              pass
  
      def test_varargs1_ext(self):
          {}.__contains__(*(0,))
  
      def test_varargs2_ext(self):
          try:
              {}.__contains__(*(1, 2))
          except TypeError:
              pass
          else:
              raise RuntimeError
  
      def test_varargs0_kw(self):
          self.assertRaises(TypeError, {}.__contains__, x=2)
  
      def test_varargs1_kw(self):
          self.assertRaises(TypeError, {}.__contains__, x=2)
  
      def test_varargs2_kw(self):
          self.assertRaises(TypeError, {}.__contains__, x=2, y=2)
  
      def test_oldargs0_0(self):
          {}.keys()
  
      def test_oldargs0_1(self):
          self.assertRaises(TypeError, {}.keys, 0)
  
      def test_oldargs0_2(self):
          self.assertRaises(TypeError, {}.keys, 0, 1)
  
      def test_oldargs0_0_ext(self):
          {}.keys(*())
  
      def test_oldargs0_1_ext(self):
          try:
              {}.keys(*(0,))
          except TypeError:
              pass
          else:
              raise RuntimeError
  
      def test_oldargs0_2_ext(self):
          try:
              {}.keys(*(1, 2))
          except TypeError:
              pass
          else:
              raise RuntimeError
  
      ### Cython makes this a compile time error
      # def test_oldargs0_0_kw(self):
      #     try:
      #         {}.keys(x=2)
      #     except TypeError:
      #         pass
      #     else:
      #         raise RuntimeError
  
      def test_oldargs0_1_kw(self):
          self.assertRaises(TypeError, {}.keys, x=2)
  
      def test_oldargs0_2_kw(self):
          self.assertRaises(TypeError, {}.keys, x=2, y=2)
  
      def test_oldargs1_0(self):
          self.assertRaises(TypeError, [].count)
  
      def test_oldargs1_1(self):
          [].count(1)
  
      def test_oldargs1_2(self):
          self.assertRaises(TypeError, [].count, 1, 2)
  
      def test_oldargs1_0_ext(self):
          try:
              [].count(*())
          except TypeError:
              pass
          else:
              raise RuntimeError
  
      def test_oldargs1_1_ext(self):
          [].count(*(1,))
  
      def test_oldargs1_2_ext(self):
          try:
              [].count(*(1, 2))
          except TypeError:
              pass
          else:
              raise RuntimeError
  
      def test_oldargs1_0_kw(self):
          self.assertRaises(TypeError, [].count, x=2)
  
      def test_oldargs1_1_kw(self):
          self.assertRaises(TypeError, [].count, {}, x=2)
  
      def test_oldargs1_2_kw(self):
          self.assertRaises(TypeError, [].count, x=2, y=2)
  
  
  if __name__ == "__main__":
      unittest.main()
  
subject: copy over "test_call.py" test from CPython 3.5+ to disable an error test that prevents it from building in Cython