// This is done after the first round of optimization to make sure all the
  // min/max operands of the tf.FakeQuant* are constants to be matched. The
  // following round of optimization will folding the unwrapped
  // tf.FakeQuant* ops with the weight constants.
  if (failed(ConvertFakeQuantOps(func, ctx, use_fake_quant_num_bits_))) {
    signalPassFailure();
    return;
  }

   * {@code o} is an instance of {@code Entry}, it is wrapped using {@link #unmodifiableEntry} to
   * protect against a possible nefarious equals method.
   *
   * <p>Note that {@code c} is the backing (delegate) collection, rather than the forwarding
   * collection.
   *
   * @param c the delegate (unwrapped) collection of map entries
   * @param o the object that might be contained in {@code c}

   * {@code o} is an instance of {@code Entry}, it is wrapped using {@link #unmodifiableEntry} to
   * protect against a possible nefarious equals method.
   *
   * <p>Note that {@code c} is the backing (delegate) collection, rather than the forwarding
   * collection.
   *
   * @param c the delegate (unwrapped) collection of map entries
   * @param o the object that might be contained in {@code c}

  // CHECK: "tf.opA"
  "tf.opA"() {device = ""} : () -> tensor<i1>
  func.return
}

// Tests that an op not in tf dialect (tf_device.launch) with device attribute is not wrapped in `tf_device.launch`.
// Also tests that a `tf_device.launch` is not rewrapped.
// CHECK-LABEL: func @non_tf_op
func.func @non_tf_op() {
  // CHECK: "tf_device.launch"
  // CHECK-NOT "tf_device.launch"
  // CHECK: "tf.opA"
  "tf_device.launch"() ({

// After [Server.Shutdown] or [Server.Close], the returned error is [ErrServerClosed].
func (srv *Server) Serve(l net.Listener) error {
	if fn := testHookServerServe; fn != nil {
		fn(srv, l) // call hook with unwrapped listener
	}

	origListener := l
	l = &onceCloseListener{Listener: l}
	defer l.Close()

	if err := srv.setupHTTP2_Serve(); err != nil {
		return err
	}

				if len(errs) != 0 {
					t.Errorf("expected no errors, but got: %v", errs)
				}
			})
		})
	}
}

// Show that we cant just use oldSelf as if it was unwrapped
func TestOptionalOldSelfIsOptionalType(t *testing.T) {
	featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, apiextensionsfeatures.CRDValidationRatcheting, true)

	cases := []struct {

		wantText:   "inner error with added context",
		wantUnwrap: wrapped,
	}, {
		err:        fmt.Errorf("%s %w %v", "prefix", wrapped, "suffix"),
		wantText:   "prefix inner error suffix",
		wantUnwrap: wrapped,
	}, {
		err:        fmt.Errorf("%[2]s: %[1]w", wrapped, "positional verb"),
		wantText:   "positional verb: inner error",
		wantUnwrap: wrapped,
	}, {

	"fmt"
	"testing"
)

type errWrapper struct {
	wrapped error
}

func (w errWrapper) Unwrap() error {
	return w.wrapped
}
func (w errWrapper) Error() string {
	return fmt.Sprintf("wrapped: %v", w.wrapped)
}

type errNotWrapper struct {
	wrapped error
}

func (w errNotWrapper) Error() string {
	return fmt.Sprintf("wrapped: %v", w.wrapped)
}

func TestInterrupted(t *testing.T) {

        collector.failures.size() == 1
        collector.failures[0] instanceof TestAssertionFailure

        TestAssertionFailure failure = collector.failures[0]
        failure.message == "This is a wrapped assertion error"
    }

    def "Wrapped assertion errors are emitted as test failure events using JUnit 5"() {
        given:
        setupJUnit5()
        file('src/test/java/org/gradle/JUnitTest.java') << '''
            package org.gradle;

// WRAPPED-NEXT: tf_executor.graph {
// WRAPPED-NEXT:   tf_executor.island wraps "tf.Const"() <{value = dense<1.000000e+00> : tensor<186xf32>}> {device = ""} : () -> tensor<186xf32>
// WRAPPED-NEXT:   tf_executor.island wraps "tf.Const"() <{value = dense<2.000000e+00> : tensor<186xf32>}> {device = ""} : () -> tensor<186xf32>
// WRAPPED-NEXT:   tf_executor.island wraps "tfl.custom_tf"