// runtime_SemacquireMutex's caller.
// The different forms of this function just tell the runtime how to present
// the reason for waiting in a backtrace, and is used to compute some metrics.
// Otherwise they're functionally identical.
func runtime_SemacquireMutex(s *uint32, lifo bool, skipframes int)
func runtime_SemacquireRWMutexR(s *uint32, lifo bool, skipframes int)
func runtime_SemacquireRWMutex(s *uint32, lifo bool, skipframes int)

var xint T[int]
var xbool T[bool]

// Are these two variables of the same type? After all, their underlying
// types are identical. We consider them to be different because each type
// instantiation creates a new named type, in this case T<int> and T<bool>
// even if their underlying types are identical. This is sensible because
// we might still have methods that have different signatures or behave

			}
			cmpFunc := func(a, b *myStruct) int {
				if n := strings.Compare(a.a, b.a); n != 0 {
					return n
				}
				return cmp.Compare(a.n, b.n)
			}
			// Presort the slice so all benchmark iterations are identical.
			slices.SortFunc(structs, cmpFunc)
			b.ResetTimer()
			for i := 0; i < b.N; i++ {
				// Sort the slice twice because slices.SortFunc modifies the slice in place.

#ifdef __cplusplus
extern "C" {
#endif

// --------------------------------------------------------------------------
// TF_DataType holds the type for a scalar value.  E.g., one slot in a tensor.
// The enum values here are identical to corresponding values in types.proto.
typedef enum TF_DataType {
  TF_FLOAT = 1,
  TF_DOUBLE = 2,
  TF_INT32 = 3,  // Int32 tensors are always in 'host' memory.
  TF_UINT8 = 4,
  TF_INT16 = 5,
  TF_INT8 = 6,

	"go/token"
)

const isTypes2 = false

// cmpPos compares the positions p and q and returns a result r as follows:
//
// r <  0: p is before q
// r == 0: p and q are the same position (but may not be identical)
// r >  0: p is after q
//
// If p and q are in different files, p is before q if the filename
// of p sorts lexicographically before the filename of q.
func cmpPos(p, q token.Pos) int { return int(p - q) }

	// Force type conversion from *struct to the func type.
	cfn := typecheck.ConvNop(addr, clo.Type())

	// non-escaping temp to use, if any.
	if x := clo.Prealloc; x != nil {
		if !types.Identical(typ, x.Type()) {
			panic("closure type does not match order's assigned type")
		}
		addr.Prealloc = x
		clo.Prealloc = nil
	}

	return walkExpr(cfn, init)
}

        facet.load(customFacetReader)
        def roundTripped = tmpDir.file("facet.xml")
        facet.store(roundTripped)

        then:
        XMLUnit.compareXML(customFacetReader.text, roundTripped.text).identical()
    }

    private InputStream getCustomFacetReader() {
        getClass().getResourceAsStream('customOrgEclipseWstCommonProjectFacetCoreXml.xml')
    }

    private Facet createSomeFacet() {

		t.Errorf("JSON after_roundtrip file is identical and should be removed")
		jsonNeedsRemove = true
	}
	if len(expectedYAMLAfterRoundTrip) == 0 {
		expectedYAMLAfterRoundTrip = yamlBeforeRoundTrip
	} else if bytes.Equal(yamlBeforeRoundTrip, expectedYAMLAfterRoundTrip) {
		t.Errorf("YAML after_roundtrip file is identical and should be removed")
		yamlNeedsRemove = true
	}

		// information further down the call chain to know if we
		// were testing a method receiver for unexported fields.
		// It isn't necessary, so just do a sanity check.
		tp := t.Recv().Type

		if l.X == nil || !types.Identical(l.X.Type(), tp) {
			base.Fatalf("method receiver")
		}

	default:
		n.SetOp(ir.OCALLFUNC)
		if t.Kind() != types.TFUNC {
			if o := l; o.Name() != nil && types.BuiltinPkg.Lookup(o.Sym().Name).Def != nil {

		t.Fatalf("error should not be wrapped twice")
	}

	internalErr = errInterrupted{errInterrupted{}}
	if ErrorInterrupted(internalErr) != internalErr {
		t.Fatalf("object should be identical")
	}

	in := errors.New("test")
	actual, expected := ErrorInterrupted(in), (errInterrupted{in})
	if actual != expected {
		t.Fatalf("did not wrap error")
	}
	if !errors.Is(actual, errWaitTimeout) {