#### SMD ####

# SMD - standard analysis
test_that(".meta_gen correctly estimates the pooled effect size for d values with raw information", {
  x <- subset(df.SMD, factor == "Pharmacological",
              select = -c(value, se, ci_lo, ci_up))
  res = umbrella(x, verbose=FALSE, method.var = "REML")
  umb <- res[[1]]$ma_results
  dat <- res[[1]]$x

  df_mfr = metafor::escalc(m1i = mean_cases, m2i = mean_controls,
                           sd1i = sd_cases, sd2i = sd_controls,
                           n1i = n_cases, n2i = n_controls,
                           data = dat, measure = "SMD", vtype = "LS2")

  meta <- metafor::rma.uni(yi = yi, vi = vi, data = df_mfr, method = "REML")

  expect_equal(as.numeric(as.character(umb$value)),
               as.numeric(as.character(meta$beta)), tolerance = 1e-10)
  expect_equal(as.numeric(as.character(umb$p.value)),
               as.numeric(as.character(meta$pval)), tolerance = 1e-10)
})

test_that(".meta_gen correctly estimates the pooled effect size for d values with raw information", {
  df <- subset(df.SMD, factor == "Pharmacological", select = -c(value, se, ci_lo, ci_up))

  umb <- umbrella(df, verbose=FALSE, method.var = "FE")[[1]]$ma_results

  df_mfr = metafor::escalc(m1i = mean_cases, m2i = mean_controls,
     sd1i = sd_cases, sd2i = sd_controls,
     n1i = n_cases, n2i = n_controls,
     data = df, measure = "SMD", vtype = "LS2")

  # m = meta::metagen(TE = df_mfr$yi,
  #               seTE = sqrt(df_mfr$vi),
  #               method.tau = "DL")
  meta <- metafor::rma.uni(yi = yi, vi = vi, data = df_mfr, method = "FE")
  meta2 <- metafor::rma.uni(yi = yi, vi = vi, data = df_mfr, method = "REML")

  expect_equal(as.numeric(as.character(umb$value)),
               as.numeric(as.character(meta$beta)), tolerance = 1e-10)
  expect_equal(as.numeric(as.character(umb$p.value)),
               as.numeric(as.character(meta$pval)), tolerance = 1e-10)
})



# SMD - hksj estimator
test_that(".meta_gen correctly estimates the pooled effect size for d values and hksj estimator", {

  df <- subset(df.SMD, factor == "Pharmacological")

  meta_umb <- umbrella(df, verbose=FALSE, method.var = "hksj")
  meta <- meta::metagen(TE = meta_umb[[1]]$x$value, seTE = meta_umb[[1]]$x$se,
                        method.random.ci = "HK", method.tau = "DL")

  expect_equal(meta_umb[[1]]$ma_results$value, as.numeric(as.character(meta$TE.random)), tolerance = 1e-10)
  expect_equal(meta_umb[[1]]$ma_results$p.value, as.numeric(as.character(meta$pval.random)), tolerance = 1e-10)
})

#### MD ####

test_that(".meta_gen correctly estimates the pooled effect size for md values with raw information", {
  x <- subset(df.MD, factor == "Pharmacological",
              select = -c(value, ci_lo, ci_up))

  res = umbrella(x, verbose=FALSE, method.var = "REML")

  df_mfr = metafor::escalc(
    m1i = mean_cases,
    m2i = mean_controls,
   sd1i = sd_cases, sd2i = sd_controls,
   n1i = n_cases, n2i = n_controls,
   data = x, measure = "MD", digits=12)

  all(round(res[[1]]$x_md$value, 10) == round(df_mfr$yi, 10))
  all(round(res[[1]]$x_md$se^2, 10) == round(df_mfr$vi, 10))
  meta <- metafor::rma.uni(yi = yi, vi = vi,
                           data = df_mfr, method = "REML",
                           digits=12)

  expect_equal(as.numeric(as.character(
    summary.umbrella(res, digits=11, raw_md=TRUE)$value)),
    as.numeric(as.character(meta$beta)), tolerance = 1e-10)
  expect_equal(as.numeric(as.character(
    4.50169675247)),
    as.numeric(as.character(meta$ci.lb)), tolerance = 1e-10)
  expect_equal(as.numeric(as.character(
    10.79598745857)),
    as.numeric(as.character(meta$ci.ub)), tolerance = 1e-10)
})

#### SMC ####

# SMC - standard analysis
test_that(".meta_gen correctly estimates the pooled effect size for d values with change information", {
  df_mean_pre_post <- subset(df.SMC, factor == "Physically_active",
                             select = -c(value, se))
  df_value_pre_post <- subset(df.SMC, factor == "Physically_active",
                             select = -c(mean_pre_cases, mean_cases,
                                         mean_pre_controls, mean_controls))
  df_mean_pre_post$pre_post_cor = 0.8
  umb1 <- umbrella(df_mean_pre_post, pre_post_cor = 0.8,
                   verbose=FALSE, method.var = "REML")
  umb2 <- umbrella(df_value_pre_post, pre_post_cor = 0.8,
                   verbose=FALSE, method.var = "REML")

  res_smc = metaConvert::es_from_means_sd_pre_post(
    n_exp = df_mean_pre_post$n_cases,
    n_nexp = df_mean_pre_post$n_controls,
    mean_pre_exp = df_mean_pre_post$mean_pre_cases,
    mean_exp = df_mean_pre_post$mean_cases,
    mean_pre_sd_exp = df_mean_pre_post$sd_pre_cases,
    mean_sd_exp = df_mean_pre_post$sd_cases,
    mean_pre_nexp = df_mean_pre_post$mean_pre_controls,
    mean_nexp = df_mean_pre_post$mean_controls,
    mean_pre_sd_nexp = df_mean_pre_post$sd_pre_controls,
    mean_sd_nexp = df_mean_pre_post$sd_controls,
    r_pre_post_exp = df_mean_pre_post$pre_post_cor,
    r_pre_post_nexp = df_mean_pre_post$pre_post_cor)

  expect_equal(as.numeric(as.character(summary(umb1)$value)),
               as.numeric(as.character(summary(umb2)$value)),
               tolerance = 5e-2)
  expect_equal(as.numeric(as.character(umb1$p.value)),
               as.numeric(as.character(umb2$pval)),
               tolerance = 1e-10)
})

test_that(".meta_gen correctly estimates the pooled effect size for d values with raw information", {
  dat <- subset(df.SMC, factor == "Physically_active",
               select = -c(value, se))
  dat$pre_post_cor = 0.8

  res = umbrella(dat, verbose=FALSE, method.var = "REML",
                 pre_post_cor = 0.8)[[1]]
  umb = res$ma_results

  smc_cases <- metafor::escalc(m2i = dat$mean_cases,
                               sd2i = dat$sd_cases,
                               ni = dat$n_cases,
                               m1i = dat$mean_pre_cases,
                               sd1i = dat$sd_pre_cases,
                               ri = dat$pre_post_cor,
                               measure = "SMCRH", digits=12)
  smc_controls <- metafor::escalc(m2i = dat$mean_controls,
                                  sd2i = dat$sd_controls,
                                  ni = dat$n_controls,
                                  m1i = dat$mean_pre_controls,
                                  sd1i = dat$sd_pre_controls,
                                  ri = dat$pre_post_cor,
                                  measure = "SMCRH", digits=12)

  smcc = smc_cases$yi - smc_controls$yi
  se = sqrt(smc_cases$vi + smc_controls$vi)
  round(res$x$value[1], 11)
  res$x$se[1]
  round(smcc[1], 11)
  se[1]
  ### COOPER vs SMCRH,

  meta <- metafor::rma.uni(
    yi = smcc, sei = se, method = "REML", digits=12)

  expect_equal(as.numeric(as.character(umb$value)),
               as.numeric(as.character(meta$beta)),
               tolerance =2e-1)
  expect_equal(as.numeric(as.character(umb$p.value)),
               as.numeric(as.character(meta$pval)),
               tolerance = 1e-3)
})

# SMC - hksj estimator
test_that(".meta_gen correctly estimates the pooled effect size for d values and hksj estimator", {

  df <- subset(df.SMC, factor == "Physically_active")

  meta_umb <- umbrella(df, verbose=FALSE, method.var = "hksj")
  meta <- meta::metagen(TE = meta_umb[[1]]$x$value, seTE = meta_umb[[1]]$x$se,
                        method.random.ci = "HK", method.tau = "DL")

  expect_equal(meta_umb[[1]]$ma_results$value, as.numeric(as.character(meta$TE.random)), tolerance = 1e-10)
  expect_equal(meta_umb[[1]]$ma_results$p.value, as.numeric(as.character(meta$pval.random)), tolerance = 1e-10)
})


#### MC ####
test_that(".meta_gen correctly estimates the pooled effect size for MC values with raw information", {
  dfmc <- subset(df.MC, factor == "Physically_active",
               select = -c(value, se))

  dfsmc <- subset(df.SMC, factor == "Physically_active",
               select = -c(value, se))

  resmc = umbrella(dfmc, verbose=FALSE, method.var = "REML",
                 pre_post_cor = 0.8)
  resmc[[1]]$x$info_used

  ressmc = umbrella(dfsmc, verbose=FALSE, method.var = "REML",
                 pre_post_cor = 0.8)
  ressmc[[1]]$x$info_used

  x_mc_sd = metaConvert::es_from_mean_change_sd(
    mean_change_exp = dfmc$mean_change_cases,
    mean_change_nexp = dfmc$mean_change_controls,
    mean_change_sd_exp = dfmc$sd_change_cases,
    mean_change_sd_nexp = dfmc$sd_change_controls,
    n_exp = dfmc$n_cases, n_nexp = dfmc$n_controls,
    r_pre_post_exp = dfmc$pre_post_cor,
    r_pre_post_nexp = dfmc$pre_post_cor)

  summc = summary.umbrella(resmc, raw_md=FALSE, digits=11)
  sumsmc = summary.umbrella(ressmc, digits=11)
  expect_equal(as.numeric(as.character(summc$value)),
               as.numeric(as.character(sumsmc$value)),
               tolerance = 1e-10)
  expect_equal(as.numeric(as.character(summc$p_value)),
               as.numeric(as.character(sumsmc$p_value)),
               tolerance = 1e-10)
})
test_that(".meta_gen MC values with mean values", {
  dfmc <- subset(df.MC, factor == "Physically_active",
                 select = -c(mean_change_cases, mean_change_controls))
  dfsmc <- subset(df.SMC, factor == "Physically_active",
                  select = -c(mean_cases, mean_controls,
                              mean_pre_controls,
                              mean_pre_cases))
  resmc = umbrella(dfmc, verbose=FALSE, method.var = "REML",
                   pre_post_cor = 0.8)

  ressmc = umbrella(dfsmc, verbose=FALSE, method.var = "REML",
                    pre_post_cor = 0.8)
  summc = summary.umbrella(resmc,digits=11)
  sumsmc = summary.umbrella(ressmc,digits=11)
  expect_equal(as.numeric(as.character(summc$value)),
               as.numeric(as.character(sumsmc$value)),
               tolerance = 9e-1)
  expect_equal(as.numeric(as.character(summc$p_value)),
               as.numeric(as.character(sumsmc$p_value)),
               tolerance = 1e-3)
})

#### OR ####

# OR - standard analysis
test_that("meta_gen_log correctly estimates the pooled effect size from 2x2 table", {

  dfOR <- subset(df.OR, factor == "ASD", select = -c(value, ci_lo, ci_up))
  # x = dfOR
  umb <- umbrella(dfOR, verbose=FALSE, method.var = "REML")[[1]]$ma_results
  meta <- metafor::rma.uni(ai = n_cases_exp, bi = n_cases_nexp,
                           ci = n_controls_exp, di = n_controls_nexp,
                           data = dfOR, method = "REML", measure = "OR")

  expect_equal(as.numeric(as.character(umb$value)), as.numeric(as.character(meta$beta)), tolerance = 1e-10)
  expect_equal(as.numeric(as.character(umb$p.value)), as.numeric(as.character(meta$pval)), tolerance = 1e-10)
})


# OR - hksj estimator
test_that("meta_gen_log correctly estimates the pooled effect size from 2x2 table and hksj estimator", {

  df <- subset(df.OR, factor == "ASD")

  meta_umb <- umbrella(df, verbose=FALSE, method.var = "hksj")
  meta <- meta::metagen(TE = meta_umb[[1]]$x$value,
                        seTE = meta_umb[[1]]$x$se,
                        method.random.ci = "HK", method.tau = "DL")

  expect_equal(meta_umb[[1]]$ma_results$value, as.numeric(as.character(meta$TE.random)), tolerance = 1e-10)
  expect_equal(meta_umb[[1]]$ma_results$p.value, as.numeric(as.character(meta$pval.random)), tolerance = 1e-10)
})

# OR - generic
test_that(".meta_gen_log correctly estimates the pooled effect size for OR values", {

  se <- with(df.OR, .estimate_or_from_n(n_cases_exp,n_cases_nexp,
                            n_controls_exp, n_controls_nexp))$se

  df <- subset(df.OR, factor == "ASD", select = -c(n_cases_exp, n_cases_nexp,
                                                   n_controls_exp, n_controls_nexp))
  df$se <- se[which(df.OR$factor=="ASD")]

  umb <- umbrella(df, verbose=FALSE, method.var = "REML")[[1]]$ma_results

  meta <- metafor::rma.uni(yi = log(value), sei = se,
                           data = df, method = "REML", measure = "OR")

  expect_equal(as.numeric(as.character(umb$value)), as.numeric(as.character(meta$beta)), tolerance = 1e-10)
  expect_equal(as.numeric(as.character(umb$p.value)), as.numeric(as.character(meta$pval)), tolerance = 1e-10)
})

#### RR ####

# RR - standard analysis
test_that(".meta_gen_log correctly estimates the pooled effect size", {

  df <- subset(df.RR, select = -c(value, ci_lo, ci_up))

  umb <- umbrella(df, verbose=FALSE, method.var = "REML")[[1]]$ma_results

  meta <- metafor::rma.uni(ai = n_cases_exp, n1i = n_exp,
                           ci = n_cases_nexp, n2i = n_nexp,
                           data = df, method = "REML", measure = "RR")

  expect_equal(as.numeric(as.character(umb$value)), as.numeric(as.character(meta$beta)), tolerance = 1e-10)
  expect_equal(as.numeric(as.character(umb$p.value)), as.numeric(as.character(meta$pval)), tolerance = 1e-10)
})

test_that(".meta_gen_log correctly estimates the pooled effect size", {
  meta <- metafor::escalc(ai = n_cases_exp, n1i = n_exp,
                           ci = n_cases_nexp, n2i = n_nexp,
                           data = df.RR, measure = "RR")

  all(round(meta$yi,10) == round(log(df.RR$value), 10))
  all(round(meta$vi,10) == round(df.RR$se^2, 10))
  df.RR$n_cases = df.RR$n_cases_nexp + df.RR$n_cases_exp
  df.RR$n_controls = df.RR$n_exp + df.RR$n_nexp - df.RR$n_cases

  df <- subset(df.RR, select = -c(n_cases_exp, n_cases_nexp))
  umb <- umbrella(df, verbose=FALSE, method.var = "REML")

  res = umb[[1]]$ma_results
  rma = metafor::rma(yi=meta$yi, vi=meta$vi,
                     method="REML")

  expect_equal(as.numeric(as.character(res$value)),
               as.numeric(as.character(rma$beta)), tolerance = 1e-10)
  expect_equal(as.numeric(as.character(umb$p.value)), as.numeric(as.character(meta$pval)), tolerance = 1e-10)
})

# RR - hksj estimator
test_that(".meta_gen_log correctly estimates the pooled effect size with hksj estimator", {

  df <- df.RR

  meta_umb <- umbrella(df, verbose=FALSE, method.var = "hksj")
  meta <- meta::metagen(
    TE = log(df.RR$value),
    seTE = (log(df.RR$ci_up) - log(df.RR$ci_lo))/(2*qnorm(.975)),
    method.random.ci = "HK", method.tau = "DL",
    digits = 12)

  expect_equal(meta_umb[[1]]$ma_results$value,
               as.numeric(as.character(meta$TE.random)),
               tolerance = 1e-10)
  expect_equal(as.numeric(meta_umb[[1]]$ma_results$p.value),
               as.numeric(as.character(meta$pval.random)),
               tolerance = 1e-8)
})

# RR - generic for multilevel
test_that(".meta_gen_log correctly estimates the pooled effect size for RR values", {

  se <- with(df.RR, .estimate_rr_from_n(n_cases_exp,n_exp,
                                        n_cases_nexp, n_nexp))$se

  df.RR$n_cases = df.RR$n_cases_exp + df.RR$n_cases_nexp
  df.RR$n_controls = with(df.RR, n_exp + n_nexp - n_cases_exp - n_cases_nexp)

  df <- subset(df.RR, select = -c(n_cases_exp, n_cases_nexp,
                                  n_exp, n_nexp))
  df$se <- se

  x = df
  umb <- umbrella(df, verbose=FALSE, method.var = "REML")[[1]]$ma_results

  meta <- metafor::rma.uni(yi = log(value), sei = se,
                           data = df, method = "REML", measure = "RR")

  expect_equal(as.numeric(as.character(umb$value)), as.numeric(as.character(meta$beta)), tolerance = 1e-10)
  expect_equal(as.numeric(as.character(umb$p.value)), as.numeric(as.character(meta$pval)), tolerance = 1e-10)
})

#### IRR ####

# IRR - standard analysis
test_that(".meta_gen_log correctly estimates the pooled effect size", {

  df <- subset(df.IRR, select=-c(ci_lo, ci_up))

  umb <- umbrella(df, verbose=FALSE, method.var = "REML")
  umb2 <- umbrella(df, verbose=FALSE, method.var = "hksj")

  res1 = metaConvert::es_from_cases_time(n_cases_exp = df$n_cases_exp,
                                  n_cases_nexp = df$n_cases_nexp,
                                  time_exp = df$time_exp,
                                  time_nexp = df$time_nexp)

  res2 = metafor::escalc(x1i = n_cases_exp, t1i = time_exp,
                         x2i = n_cases_nexp, t2i = time_nexp,
                         measure = "IRR",
                         data = df)
  DATA = umb[[1]]$x
  # DATA = umb
  expect_equal(as.numeric(as.character(res1$logirr)),
               as.numeric(as.character(DATA$value)), tolerance = 1e-10)
  expect_equal(as.numeric(as.character(res1$logirr_se)),
               as.numeric(as.character(DATA$se)), tolerance = 1e-10)

  expect_equal(as.numeric(as.character(res1$logirr)),
               as.numeric(as.character(res2$yi)), tolerance = 1e-10)
  expect_equal(as.numeric(as.character(res1$logirr_se))^2,
               as.numeric(as.character(res2$vi)), tolerance = 1e-10)
  meta <- metafor::rma.uni(x1i = n_cases_exp, t1i = time_exp,
                           x2i = n_cases_nexp, t2i = time_nexp,
                           data = df, method = "REML",
                           measure = "IRR", digits=12)

  expect_equal(as.numeric(as.character(umb[[1]]$ma_results$value)),
               as.numeric(as.character(meta$beta)), tolerance = 1e-10)
  expect_equal(as.numeric(as.character(umb[[1]]$ma_results$p.value)),
               as.numeric(as.character(meta$pval)), tolerance = 1e-10)
})


# irr - hksj estimator
test_that(".meta_irr correctly estimates the pooled effect size with hksj estimator", {
  dfirr <- subset(df.IRR, select=-c(value, ci_lo, ci_up))

  meta_umb <- umbrella(dfirr, verbose=FALSE, method.var = "hksj")
  meta <- meta::metagen(TE = meta_umb[[1]]$x$value,
                        seTE = meta_umb[[1]]$x$se,
                        sm = "IRR", method.random.ci = "HK", method.tau = "DL")

  expect_equal(meta_umb[[1]]$ma_results$value,
               as.numeric(as.character(meta$TE.random)), tolerance = 1e-10)

  expect_equal(meta_umb[[1]]$ma_results$p.value, as.numeric(as.character(meta$pval.random)), tolerance = 1e-10)
})

# IRR - standard analysis
test_that(".meta_irr correctly estimates the pooled effect size", {

  df <- subset(df.IRR, select = -c(value, ci_lo, ci_up))

  umb <- umbrella(df, verbose=FALSE, method.var = "REML")[[1]]$ma_results

  meta <- metafor::rma.uni(x1i = n_cases_exp, t1i = time_exp,
                           x2i = n_cases_nexp, t2i = time_nexp,
                           data = df, method = "REML", measure = "IRR")

  expect_equal(as.numeric(as.character(umb$value)),
               as.numeric(as.character(meta$beta)), tolerance = 1e-10)
  expect_equal(as.numeric(as.character(umb$p.value)),
               as.numeric(as.character(meta$pval)), tolerance = 1e-10)
})


# IRR - hksj estimator
test_that(".meta_irr correctly estimates the pooled effect size with hksj estimator", {

  df <- subset(df.IRR, select = -c(value, ci_lo, ci_up))

  meta_umb <- umbrella(df, verbose=FALSE, method.var = "hksj")
  meta <- meta::metagen(TE = meta_umb[[1]]$x$value,
                        seTE = meta_umb[[1]]$x$se,
                        sm = "IRR", method.random.ci = "HK", method.tau = "DL")

  expect_equal(as.numeric(as.character(meta_umb[[1]]$ma_results$value)), as.numeric(as.character(meta$TE.random)), tolerance = 1e-10)
  expect_equal(as.numeric(as.character(meta_umb[[1]]$ma_results$p.value)), as.numeric(as.character(meta$pval.random)), tolerance = 1e-10)
})

# IRR - generic for multilevel
test_that(".meta_gen_log correctly estimates the pooled effect size for IRR values", {

  se <- with(df.IRR, sqrt(1/n_cases_exp + 1/n_cases_nexp))

  df <- subset(df.IRR, select = -c(n_cases_exp, n_cases_nexp,
                                  time_exp, time_nexp))
  df$se <- se

  umb <- .quiet(umbrella(df, verbose=FALSE, method.var = "REML")[[1]]$ma_results)

  meta <- metafor::rma.uni(yi = log(value), sei = se,
                           data = df, method = "REML")

  #
  expect_equal(as.numeric(as.character(umb$value)), as.numeric(as.character(meta$beta)), tolerance = 1e-10)
  expect_equal(as.numeric(as.character(umb$p.value)), as.numeric(as.character(meta$pval)), tolerance = 1e-10)
})

#### HR ####
# HR - generic for multilevel
test_that(".meta_gen_log correctly estimates the pooled effect size for HR values", {

  se <- with(df.HR, ((log(ci_up) - log(ci_lo))/3.92))
  df <- subset(df.HR, factor == "Yoga")
  df$se <- se[which(df.HR$factor == "Yoga")]

  umb <- umbrella(df, method.var = "REML", verbose = FALSE)[[1]]$ma_results

  meta <- metafor::rma.uni(yi = log(value), sei = se,
                           data = df, method = "REML")

  #
  expect_equal(as.numeric(as.character(umb$value)), as.numeric(as.character(meta$beta)), tolerance = 1e-10)
  expect_equal(as.numeric(as.character(umb$p.value)), as.numeric(as.character(meta$pval)), tolerance = 1e-10)
})

#### R ####

# R - standard analysis
test_that("meta_gen correctly estimates the pooled effect size from R", {

  df <- subset(df.R, factor == "Gestational_hypertension")

  umb <- umbrella(df, verbose=FALSE, method.var = "REML")[[1]]$ma_results
  meta <- metafor::rma.uni(ri = value, ni = n_sample,
                           data = df, method = "REML", measure = "ZCOR")

  expect_equal(as.numeric(as.character(umb$value)), as.numeric(as.character(meta$beta)), tolerance = 1e-10)
  expect_equal(as.numeric(as.character(umb$p.value)), as.numeric(as.character(meta$pval)), tolerance = 1e-10)
})

test_that("meta_gen correctly estimates the prediction interval size from R", {

  df <- subset(df.R, factor == "Gestational_hypertension")

  umb <- umbrella(df, verbose=FALSE, method.var = "REML")[[1]]$ma_results
  meta <- meta::metacor(cor = value, n = n_sample,
                           data = df, method.tau = "REML", prediction = TRUE)

  expect_equal(as.numeric(as.character(umb$pi_lo)), as.numeric(as.character(meta$lower.predict)), tolerance = 1e-10)
  expect_equal(as.numeric(as.character(umb$pi_up)), as.numeric(as.character(meta$upper.predict)), tolerance = 1e-10)
})

#### Z ####

test_that(".meta_gen correctly estimates the pooled effect size for z values from r", {
  df <- subset(df.R, factor == "gestational_diabetes")

  umb <- suppressWarnings(umbrella(df, method.var = "REML", verbose=FALSE)[[1]]$ma_results)
  x <- suppressWarnings(umbrella(df, method.var = "REML", verbose=FALSE)[[1]]$x)

  z_mfr <- metafor::escalc(ri = df$value,
                           ni = df$n_sample,
                           measure = "ZCOR")

  meta <- metafor::rma.uni(yi = .as_numeric(z_mfr$yi),
                           sei = sqrt(z_mfr$vi), method = "REML")

  expect_equal(as.numeric(as.character(umb$value)),
               as.numeric(as.character(meta$beta)), tolerance = 1e-10)
  expect_equal(as.numeric(as.character(umb$p.value)),
               as.numeric(as.character(meta$pval)), tolerance = 1e-10)
})


test_that(".meta_gen correctly estimates the pooled effect size for z values from r", {
  df <- subset(df.R, factor == "gestational_diabetes")

  umb <- summary.umbrella(umbrella(df, method.var = "REML", verbose=FALSE), digits=12)
  x <- suppressWarnings(umbrella(df, method.var = "REML", verbose=FALSE)[[1]]$x)

  z_mfr <- metafor::escalc(ri = df$value,
                           ni = df$n_sample,
                           measure = "ZCOR",
                           digits = 11)

  all(round(x$value, 10) == round(z_mfr$yi, 10))
  all(round(x$se^2, 10) == round(z_mfr$vi, 10))
  meta <- metafor::rma.uni(yi = .as_numeric(z_mfr$yi),
                           sei = sqrt(z_mfr$vi), method = "REML",
                           digits = 11)

  expect_equal(as.numeric(as.character(umb$value)),
               metaumbrella:::.z_to_r(as.numeric(as.character(meta$beta))),
               tolerance = 1e-10)
  expect_equal(as.numeric(as.character(umb$p_value)),
               as.numeric(as.character(meta$pval)),
               tolerance = 1e-10)
})

test_that(".meta_gen correctly estimates the pooled effect size for
          z values and hksj estimator", {

            df <- subset(df.R, factor == "gestational_diabetes")

            meta_umb <- suppressWarnings(umbrella(df, verbose=FALSE,
                                                  method.var = "hksj"))
            meta <- meta::metagen(TE = meta_umb[[1]]$x$value, seTE = meta_umb[[1]]$x$se,
                                  method.random.ci = "HK", method.tau = "DL")

            expect_equal(meta_umb[[1]]$ma_results$value, as.numeric(as.character(meta$TE.random)), tolerance = 1e-10)
            expect_equal(meta_umb[[1]]$ma_results$p.value, as.numeric(as.character(meta$pval.random)), tolerance = 1e-10)
          })