// Return a TensorProto mangled as a string.
string MangleTensor(const TensorProto& tensor);
// Demangle a string mangled with MangleTensor.
Status DemangleTensor(absl::string_view str, TensorProto* proto);

// Return a DataType mangled as a string.
string MangleDataType(const DataType& dtype);
// Demangle a string mangled with MangleDataType.
Status DemangleDataType(absl::string_view str, DataType* proto);

	testenv.MustHaveExec(t)

	const input = "pä世🜃"
	tests := []struct {
		env     string
		fail    bool
		mangled string
	}{
		{
			env:     "v1",
			mangled: "p___",
		},
		{
			env:     "v2",
			mangled: "p..u00e4..u4e16..U0001f703",
		},
		{
			env:     "v3",
			mangled: "p_u00e4_u4e16_U0001f703",
		},
		{
			env:  "error",
			fail: true,
		},
	}

	cmd := os.Args[0]

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package a

type ATypeWithALoooooongName interface { // a long name, so the type descriptor symbol name is mangled
	M()

// Copyright 2018 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// cgo should reject the use of mangled C names.

package main

/*
typedef struct a {
	int i;
} a;
void fn(void) {}
*/
import "C"

type B _Ctype_struct_a // ERROR HERE

var a _Ctype_struct_a // ERROR HERE

type A struct {
	a *_Ctype_struct_a // ERROR HERE

package main

import (
	"fmt"
	"strings"
)

// Issue 58800:
// Instantiated function name may contain weird characters
// that confuse the external linker, so it needs to be
// mangled.
type S struct {
	X int `parser:"|@@)"`
}

//go:noinline
func F[T any]() {}

func P() {
	F[S]()
}

// Issue 62098: the name mangling code doesn't handle some string
// symbols correctly.

			}
		}
		if !found {
			log.Fatalf("%s emit to bad dir: got error:\n  %v\nwanted error with one of:\n  %+v", which, got, want)
		}
	}

	// Mangle the output directory to produce something nonexistent.
	mangled := *outdirflag + "_MANGLED"
	if err := coverage.WriteMetaDir(mangled); err == nil {
		log.Fatal("expected error from WriteMetaDir to nonexistent dir")
	} else {
		got := fmt.Sprintf("%v", err)
		checkWant("meta data", got)

	defer func() {
		recover()
		done <- true
		runtime.Goexit()
	}()
	time.Sleep(10 * time.Millisecond) // overwrote Panic struct with Timer struct
	runtime.GC()                      // walked gp->panic list, found mangled Panic struct, crashed
	panic("p")

      content.assign(reinterpret_cast<const char*>(&complex_value),
                     sizeof(complex_value));
      repr.set_tensor_content(content);
      std::string mangled = tensorflow::mangling_util::MangleTensor(repr);

      return mlir::TF::TensorProtoAttr::get(shaped_type, mangled);
    } else {
      return tensorflow::Status(absl::StatusCode::kInvalidArgument,
                                "Unsupported type");
    }

	var u = "\xab\x00\xfc"

	if len(s) != 2 || s[0] != 0xc2 || s[1] != 0xff ||
		len(t) != 2 || t[0] != 0xd0 || t[1] != 0xfe ||
		len(u) != 3 || u[0] != 0xab || u[1] != 0x00 || u[2] != 0xfc {
		println("BUG: non-UTF-8 string mangled")
		os.Exit(2)
	}

	fmt.Print(`
package main

var x = "in string ` + "\x00" + `"	// ERROR "NUL"

var y = ` + "`in raw string \x00 foo`" + `  // ERROR "NUL"

// in comment ` + "\x00" + `  // ERROR "NUL"

  absl::string_view pbtxt;
  TF_RETURN_IF_ERROR(ConsumePrefix(str, kDataTypePrefix, &pbtxt));
  if (!DataType_Parse(string(pbtxt), proto)) {
    return errors::FailedPrecondition(
        "Could not parse TFDataType mangled proto");
  }
  return absl::OkStatus();
}

}  // namespace mangling_util