code: def repeat_with_success_at_least(times, min_success):
      """Decorator for multiple trial of the test case.
  
      The decorated test case is launched multiple times.
      The case is judged as passed at least specified number of trials.
      If the number of successful trials exceeds `min_success`,
      the remaining trials are skipped.
  
      Args:
          times(int): The number of trials.
          min_success(int): Threshold that the decorated test
              case is regarded as passed.
  
      """
  
      assert times >= min_success
  
      def _repeat_with_success_at_least(f):
          @functools.wraps(f)
          def wrapper(*args, **kwargs):
              assert len(args) > 0
              instance = args[0]
              assert isinstance(instance, unittest.TestCase)
              success_counter = 0
              failure_counter = 0
              results = []
  
              def fail():
                  msg = "\nFail: {0}, Success: {1}".format(
                      failure_counter, success_counter
                  )
                  if results:
                      first = results[0]
                      errs = first.failures + first.errors
                      if errs:
                          err_msg = "\n".join(fail[1] for fail in errs)
                          msg += (
                              "\n\nThe first error message:\n" + err_msg
                          )
                  instance.fail(msg)
  
              # Wrapper to convert pytest.skip() to unittest.SkipTest
              def f_wrap(ins, args, kwargs):
                  try:
                      f(ins, *args[1:], **kwargs)
                  except _pytest.outcomes.Skipped as e:
                      ins.skipTest(e.msg)
  
              for _ in six.moves.range(times):
                  suite = unittest.TestSuite()
                  # Create new instance to call the setup and the teardown only
                  # once.
                  ins = type(instance)(instance._testMethodName)
                  suite.addTest(
                      unittest.FunctionTestCase(
                          lambda: f_wrap(ins, args, kwargs),
                          setUp=ins.setUp,
                          tearDown=ins.tearDown,
                      )
                  )
  
                  result = QuietTestRunner().run(suite)
                  if len(result.skipped) == 1:
                      # "Skipped" is a special case of "Successful".
                      # When the test has been skipped, immediately quit the
                      # test regardless of `times` and `min_success` by raising
                      # SkipTest exception using the original reason.
                      instance.skipTest(result.skipped[0][1])
                  elif result.wasSuccessful():
                      success_counter += 1
                  else:
                      results.append(result)
                      failure_counter += 1
                  if success_counter >= min_success:
                      instance.assertTrue(True)
                      return
                  if failure_counter > times - min_success:
                      fail()
                      return
              fail()
  
          return wrapper
  
      return _repeat_with_success_at_least
  
file_path: chainer/chainer/testing/condition.py
imports: import functools
  import unittest
  import six
label_desc: Use image node_id 1 for calling a global function with example usage: repeat_with_success_at_least(times, min_success) and returns: _repeat_with_success_at_least, wrapper