then:
        assert mappedFailure.causes.size() == 3
        assert mappedFailure.rawFailure instanceof MultipleAssertionsError
    }

    def "maps inner assertion failures correctly"() {
        when:
        def innerErrors = mapper.mapInnerFailures(error, rootMapper)

        then:
        innerErrors.eachWithIndex { tf, i ->
            assert tf.causes.size() == 0

    /**
     * Asserts that exactly the given set of tasks have been executed in any order.
     */
    ExecutionResult assertTasksExecuted(Object... taskPaths);

    /**
     * Asserts that the given task has been executed.
     */
    ExecutionResult assertTaskExecuted(String taskPath);

    /**

from tensorflow.python.saved_model import loader_impl
from tensorflow.python.trackable import autotrackable
from tensorflow.python.types import core


# Name of the saved model assets directory.
_ASSETS_DIR = 'assets'
_ASSETS_EXTRA_DIR = 'assets.extra'

# Type variable for a type that is not `None`. This represents a return value of
# methods in `PyFunctionLibrary` that should not be `None`, as `None` represents

            assert startEvent instanceof FileDownloadStartEvent
            assert finishEvent instanceof FileDownloadFinishEvent
            assert descriptor instanceof FileDownloadOperationDescriptor
            assert descriptor.uri == uri
            assert descriptor.displayName == "Download " + uri
            assert finishEvent.result instanceof FileDownloadResult
            assert finishEvent.result.bytesDownloaded == size

 * limitations under the License.
 */
package mockwebserver3.junit4

import assertk.assertThat
import assertk.assertions.isTrue
import java.net.ConnectException
import java.util.concurrent.atomic.AtomicBoolean
import org.junit.Assert.fail
import org.junit.Test
import org.junit.runner.Description
import org.junit.runners.model.Statement

class MockWebServerRuleTest {

            import org.junit.Test;
            import static org.junit.Assert.*;

            public class FailingTest {

                @Test
                public void pass() {
                }

                @Test
                public void failWithAssertStatement() {
                    assert false;
                }

                @Test

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package okhttp3.internal.http2

import assertk.assertThat
import assertk.assertions.isEqualTo
import okhttp3.internal.http2.hpackjson.HpackJsonUtil
import okhttp3.internal.http2.hpackjson.Story
import okio.Buffer

/**

            )
        }

        // Assert that same IDs were used for all builds in build
        def allScopeIds = ids.values()
        def buildInvocationIds = allScopeIds*.buildInvocation

        assert buildInvocationIds.unique(false).size() == 1

        if (!disableConsistentWorkspaceIdCheck) {
            def workspaceIds = allScopeIds*.workspace
            assert workspaceIds.unique(false).size() == 1
        }

        }

        @Override
        public boolean contains(Object o) {
            return asSet.contains(o);
        }

        @Override
        public boolean containsAll(Collection<?> c) {
            return asSet.containsAll(c);
        }

        @Override
        public int size() {
            return size;
        }
    }

// Simplified test case from issue

type Matcher[T any] func(T) bool

func Produces[T any](T) Matcher[<-chan T] { return nil }

func Assert1[T any](Matcher[T], T) {}
func Assert2[T any](T, Matcher[T]) {}

func _() {
	var ch chan string
	Assert1(Produces(""), ch)
	Assert2(ch, Produces(""))