t.Fatalf("no view should be created, got %v", err)
	}

	query := DB.Model(&User{}).
		Select("users.id as users_id, users.name as users_name, pets.id as pets_id, pets.name as pets_name").
		Joins("inner join pets on pets.user_id = users.id")

	if err := DB.Migrator().CreateView("users_pets", gorm.ViewOption{Query: query}); err != nil {
		t.Fatalf("Failed to crate view, got %v", err)
	}

mkdir -p "${OUTPUT_DIR}"

# Cleanup function
cleanup() {
    rm -rf "${OUTPUT_DIR}"
}
trap cleanup EXIT

# Test function
run_test() {
    local test_name="$1"
    local expected_result="$2"
    shift 2
    local cmd=("$@")

    echo -n "Testing: ${test_name}... "

    # Run the command
    "${cmd[@]}" >/dev/null 2>&1
    local actual_result=$?

    if [[ "${actual_result}" -eq "${expected_result}" ]]; then

        assertEquals(expectedString, packet.toString());
    }

    public void test_ordinal() {
        assertEquals(0, StorageType.S3.ordinal());
        assertEquals(1, StorageType.GCS.ordinal());
        assertEquals(2, StorageType.S3_COMPAT.ordinal());
    }

    public void test_name() {
        assertEquals("S3", StorageType.S3.name());
        assertEquals("GCS", StorageType.GCS.name());
        assertEquals("S3_COMPAT", StorageType.S3_COMPAT.name());
    }

            fail("Expected NullPointerException");
        } catch (NullPointerException e) {
            // Expected exception
        }
    }

    @Test
    public void test_name() {
        // Test name() method returns correct string representation
        assertEquals("METADATA", SsoResponseType.METADATA.name());
        assertEquals("LOGOUT", SsoResponseType.LOGOUT.name());
    }

    @Test

  server_def.set_job_name(job_name);
  server_def.set_task_index(0);
  tensorflow::ClusterDef* cluster_def = server_def.mutable_cluster();
  tensorflow::JobDef* job_def = cluster_def->add_job();
  job_def->set_name(job_name);
  for (int i = 0; i < num_tasks; i++) {
    int port = tensorflow::testing::PickUnusedPortOrDie();
    job_def->mutable_tasks()->insert({i, absl::StrCat("localhost:", port)});

  }
  absl::Status SetAttrFunctionName(const char* attr_name, const char* value,
                                   size_t length) override {
    tensorflow::NameAttrList func_name;
    func_name.set_name(string(value, value + length));
    op_->node_builder.Attr(attr_name, func_name);
    return absl::OkStatus();
  }
  absl::Status SetAttrTensor(const char* attr_name,

  using tensorflow::shape_inference::ShapeHandle;

  const int num_inputs = input_shapes->num_items;
  NodeDef node_def;
  tensorflow::ImmediateExecutionOperation* op = tensorflow::unwrap(tfe_op);
  node_def.set_name(op->Name());
  node_def.set_op(op->Name());
  for (int i = 0; i < num_inputs; ++i) {
    node_def.add_input("dummy_input");
  }
  OperationFromInterface(op)->Attrs().FillAttrValueMap(node_def.mutable_attr());

  // Another renaming of local device
  const string second_name = "def";
  server_def.set_job_name(second_name);
  server_def.mutable_cluster()->mutable_job(0)->set_name(second_name);
  (*server_def.mutable_cluster()->mutable_job(0)->mutable_tasks())[0] =
      absl::StrCat(second_name, ":",
                   tensorflow::testing::PickUnusedPortOrDie());

  EXPECT_EQ(TF_GetCode(status), TF_OK) << TF_Message(status);

  server_def.set_task_index(0);
  auto cluster = server_def.mutable_cluster();
  auto client_job = cluster->add_job();
  client_job->set_name("localhost");
  int client_port = tensorflow::testing::PickUnusedPortOrDie();
  client_job->mutable_tasks()->insert(
      {0, absl::StrCat("localhost:", client_port)});
  server_def.set_job_name("localhost");