platform.value()->Name(), ": ",
                                   status.ToString());
    }
  }

  xla::LocalClientOptions client_options;
  client_options.set_platform(platform.value());
  if (device != nullptr) {
    client_options.set_intra_op_parallelism_threads(
        device->tensorflow_cpu_worker_threads()->num_threads);
  }

  if (flr != nullptr) {

  // details of the host hardware when the client is created, so we
  // don't want to do it until we get a chance to hook the platform up
  // to a simulator.

  xla::LocalClientOptions options;
  options.set_platform(platform_)
      .set_allowed_devices(allowed_devices_)
      .set_intra_op_parallelism_threads(intra_op_parallelism_threads_);
  return xla::ClientLibrary::GetOrCreateLocalClient(options);
}

using OwnedTFStatus = tensorflow::TF_StatusPtr;

namespace {
absl::Status ValidateSPPlatform(const SP_Platform& platform) {
  TF_VALIDATE_STRUCT_SIZE(SP_Platform, platform, SP_PLATFORM_STRUCT_SIZE);
  TF_VALIDATE_NOT_NULL(SP_Platform, platform, name);
  TF_VALIDATE_NOT_NULL(SP_Platform, platform, type);
  TF_RETURN_IF_ERROR(
      tensorflow::device_utils::ValidateDeviceType(platform.name));
  TF_RETURN_IF_ERROR(

  // allow_growth is ignored.
  TF_Bool force_memory_growth;
} SP_Platform;

#define SP_PLATFORM_STRUCT_SIZE \
  TF_OFFSET_OF_END(SP_Platform, force_memory_growth)

typedef struct SP_PlatformFns {
  size_t struct_size;

  void* ext;  // reserved for future use

  // Callbacks for getting device count
  void (*get_device_count)(const SP_Platform* platform, int* device_count,

  absl::Status status =
      InitStreamExecutorPlugin(plugin_init, &device_type, &platform_name);
  ASSERT_EQ(status.code(), tensorflow::error::FAILED_PRECONDITION);
  ASSERT_EQ(status.message(), "'name' field in SP_Platform must be set.");
}

TEST(StreamExecutor, InvalidNameWithSemicolon) {
  auto plugin_init = [](SE_PlatformRegistrationParams* const params,
                        TF_Status* const status) -> void {

  ) : BeforeEachCallback, AfterEachCallback, InvocationInterceptor {
    private val versionChecks = mutableListOf<Pair<Matcher<out Any>, Matcher<out Any>>>()

    override fun beforeEach(context: ExtensionContext) {
      setupPlatform()
    }

    override fun afterEach(context: ExtensionContext) {
      resetPlatform()
    }

    override fun interceptTestMethod(
      invocation: InvocationInterceptor.Invocation<Void>,

                && targetPlatform.getArchitecture().isAmd64();
        }

        @Override
        public void apply(DefaultGccPlatformToolChain gccToolChain) {
            boolean isMacOsX = gccToolChain.getPlatform().getOperatingSystem().isMacOsX();
            final String[] compilerArgs;
            if (isMacOsX) {
                compilerArgs = new String[]{"-arch", "x86_64"};
            } else {

	pairs := sysauxv(auxvp[:])
	auxv = auxvp[: pairs*2 : pairs*2]
}

const (
	_AT_NULL     = 0  // Terminates the vector
	_AT_PAGESZ   = 6  // Page size in bytes
	_AT_PLATFORM = 15 // string identifying platform
	_AT_TIMEKEEP = 22 // Pointer to timehands.
	_AT_HWCAP    = 25 // CPU feature flags
	_AT_HWCAP2   = 26 // CPU feature flags 2
)

func sysauxv(auxv []uintptr) (pairs int) {

  output_tensor_shapes.reserve(ctx->num_outputs());
  if (output.on_host_shape().is_dynamic()) {
    const se::Platform* platform = nullptr;
    if (stream != nullptr) {
      platform = stream->parent()->GetPlatform();
    } else {
      // Stream is not set for the host platform.
      TF_ASSIGN_OR_RETURN(platform,
                          se::PlatformManager::PlatformWithId(

	if ret < 0 {
		writeErrStr(failthreadcreate)
		exit(1)
	}
}

const (
	_AT_NULL     = 0  // End of vector
	_AT_PAGESZ   = 6  // System physical page size
	_AT_PLATFORM = 15 // string identifying platform
	_AT_HWCAP    = 16 // hardware capability bit vector
	_AT_SECURE   = 23 // secure mode boolean
	_AT_RANDOM   = 25 // introduced in 2.6.29