def modifying_method_test(tests, verbose=True):
    """
    Runs tests for modifying methods, checks if the string corresponding
    to the modified object corresponds to the expected string representation.

    Args:
        tests (list[(expected_str, function_to_call, *args)]): The list of tests to
            run in the form of a list of tuples containing in order:
                - expected_str: The expected string representation of the object after modification;
                - function_to_call: The function to call, should be bound to an object;
                - *args: The arguments for the function.

            Calls ``object.function_to_call(*args)``.
            
            Do not forget that the methods here modify the object, thus, if you always
            provide the same object to all tests, you have to take into account the
            modification made by each call.
        verbose (bool): If ``True``, prints results in the console, prints nothing
            otherwise.

    Returns:
        list[(function_called, str_failure_description, exception)] -- The list of
        failures that occurred within the conducted tests.
    """
    failed = []

    for test in tests:
        expected_str = test[0]
        function = test[1]
        if not hasattr(function, '__call__'):
            raise ValueError("The second object in the provided test tuples should be callable!")
        obj = function.__self__
        args = test[2:]
        s = ""
        try:
            s += str(function.__self__) + "."
        except:
            pass
        try:
            s += function.__name__ + "("
        except:
            s += str(function).split(' ')[1][1:-2] + "("
        for arg in args:
            s += str(arg) + ", "
        s = s[:-2] + ")"
        try:
            if verbose:
                print(" ... " + s)
                print(" - Expected str(object) = " + expected_str)
            function(*args)
            assert str(obj) == expected_str, ("Resulted in " + str(obj) +
                                               " instead of the expected " + expected_str + "!")
            if verbose:
                print(" - Resulting str(object) = " + str(obj))
                print("  ... SUCCESS.")
        except AssertionError as e:
            if verbose:
                print("  ... FAILED: not the expected output value!")
            failed.append((s, "Not the expected value!", e))
        except Exception as e:
            if verbose:
                print("  ... FAILED: raised an unexpected exception!")
            failed.append((s, "Raised an unexpected exception!", e))

    if verbose:
        print("... done: %i/%i tests were successful!" % (len(tests)-len(failed), len(tests)))
    
    return failed