#include "tensorflow/core/util/device_name_utils.h"

namespace mlir {
namespace TF {
namespace {

using DeviceNameUtils = ::tensorflow::DeviceNameUtils;
using ParsedName = ::tensorflow::DeviceNameUtils::ParsedName;

constexpr const char *kHostAttr = "host";
constexpr const char *kDeviceAttr = "device";
constexpr const char *kTFDeviceAttr = "tf.device";

        if (value == null) {
            return null;
        }
        return new Date(value);
    }

    public static Date parseDate(final String value) {
        return parseDate(value, Constants.DATE_OPTIONAL_TIME);
    }

    public static Date parseDate(final String value, final String format) {
        if (value == null) {
            return null;
        }

        try {

  Status Sync() override { return errors::Unimplemented("FakeDevice::Sync()"); }

  static std::unique_ptr<Device> Make(const string& name,
                                      const string& desc = "") {
    DeviceNameUtils::ParsedName parsed_name;
    DeviceNameUtils::ParseFullName(name, &parsed_name);

    DeviceAttributes device_attributes;
    device_attributes.set_name(name);
    device_attributes.set_device_type(parsed_name.type);

            final Date lastModified = FessFunctions.parseDate(lastModifiedObj.toString());
            if (lastModified != null) {
                return lastModified;
            }
        } else if ((lastModifiedObj instanceof final String[] lastModifieds) && (lastModifieds.length > 0)) {
            final Date lastModified = FessFunctions.parseDate(lastModifieds[0]);
            if (lastModified != null) {

        String responseHeader = response.getHeader(HttpHeaders.LAST_MODIFIED);
        if (responseHeader == null) {
            return new Date(0);
        }
        try {
            return DateUtils.parseDate(responseHeader);
        } catch (Exception e) {
            return new Date(0);
        }
    }

    private String getFilename() {
        String disposition = response.getHeader("Content-Disposition");

  // LINT.IfChange
  auto device_id = StringAttr::get(call->getContext(), "device");
  auto caller_device = call->getAttrOfType<StringAttr>(device_id);
  if (!caller_device) return;

  DeviceNameUtils::ParsedName caller_parsed_device;
  if (!DeviceNameUtils::ParseFullName(caller_device.getValue().str(),
                                      &caller_parsed_device))
    return;

  MLIRContext *context = call->getContext();

        }
        if (clazz.isAssignableFrom(Date.class)) {
            if (value instanceof Date) {
                return (T) value;
            }
            return (T) FessFunctions.parseDate(value.toString());
        }
        if (clazz.isAssignableFrom(Long.class)) {
            if (value instanceof Long) {
                return (T) value;
            }

    if (auto attr = func.getArgAttrOfType<StringAttr>(arg.getArgNumber(),
                                                      kFuncDeviceAttr)) {
      std::string device = attr.getValue().str();
      tensorflow::DeviceNameUtils::ParsedName parsed_name;
      if (!tensorflow::DeviceNameUtils::ParseFullName(device, &parsed_name)) {
        return read->emitOpError() << "invalid device '" << device << "'";
      }

	dialect := os.Getenv("GORM_DIALECT")
	if dialect != "mysql" {
		t.SkipNow()
	}

	dbDSN := os.Getenv("GORM_DSN")
	if dbDSN == "" {
		dbDSN = "gorm:gorm@tcp(localhost:9910)/gorm?charset=utf8&parseTime=True&loc=Local"
	}
	nativeDB, err := sql.Open("mysql", dbDSN)
	if err != nil {
		t.Fatalf("Should open db success, but got %v", err)
	}

	conn := &wrapperConnPool{
		db: nativeDB,
		expect: []string{

// of a language tag.
type Base struct {
	langID language.Language
}

// ParseBase parses a 2- or 3-letter ISO 639 code.
// It returns a ValueError if s is a well-formed but unknown language identifier
// or another error if another error occurred.
func ParseBase(s string) (Base, error) {
	l, err := language.ParseBase(s)
	return Base{l}, err
}

// String returns the BCP 47 representation of the base language.