test_that("measures are correct", {
  skip_on_cran()
  smd = summary(umbrella(df.SMD))
  md = summary(umbrella(df.MD), raw_md=TRUE)
  md_smd = summary(umbrella(df.MD), raw_md=FALSE)
  smc = summary(umbrella(df.SMC))
  mc = summary(umbrella(df.MC), raw_md=TRUE)
  mc_smd = summary(umbrella(df.MC), raw_md=FALSE)

  expect_equal(unique(smd$measure), "G")
  expect_equal(unique(md$measure), "MD")
  expect_equal(unique(md_smd$measure), "G")

  expect_equal(unique(smc$measure), "G")
  expect_equal(unique(mc$measure), "MC")
  expect_equal(unique(mc_smd$measure), "G")

  or = summary(umbrella(df.OR))
  rr = summary(umbrella(df.RR))
  irr = summary(umbrella(df.IRR))
  hr = summary(umbrella(df.HR))
  expect_equal(unique(or$measure), "OR")
  expect_equal(unique(rr$measure), "RR")
  expect_equal(unique(irr$measure), "IRR")
  expect_equal(unique(hr$measure), "HR")

  cor = summary(umbrella(df.R))
  expect_equal(unique(cor$measure), "R")
})


test_that("mult.level creates message for multilevel studies", {
  skip_on_cran()
  df <- df.OR.multi
  expect_message(umbrella(df, mult.level = TRUE),
                 "contains multiple outcomes")
  expect_message(umbrella(df, mult.level = TRUE),
                 "contains multiple groups")
})

test_that("error: mult.level = FALSE", {
  skip_on_cran()
  expect_error(.quiet(umbrella(df.OR.multi)),
               "Please, check that it is not a repeated entry. If not, indicate that you have multivariate data by specfying 'mult.level = TRUE' as an argument of the 'umbrella' function.")
})

##########################
#### different inputs ####
##########################

##### SMD -----------------
test_that("smd wth / wthout n_cases", {
  dfwoN<- subset(df.SMD, select=-c(n_cases, n_controls))

  umb1 <- umbrella(df.SMD, verbose=FALSE, seed = 4321)
  umb2 <- umbrella(dfwoN, verbose=FALSE, seed = 4321)
  expect_equal(umb1[[1]]$ma_results[, c("value", "p.value", "ci_lo", "ci_up", "pi_lo", "pi_up")],
               umb2[[1]]$ma_results[, c("value", "p.value", "ci_lo", "ci_up", "pi_lo", "pi_up")],
               tolerance = 1e-3)
  expect_equal(umb1[[1]]$heterogeneity$i2,
               umb2[[1]]$heterogeneity$i2, tolerance = 1e-3)
  expect_equal(umb1[[1]]$esb$p.value,
               umb2[[1]]$esb$p.value, tolerance = 1e-2)
  expect_equal(umb1[[1]]$egger$p.value, umb2[[1]]$egger$p.value,
               tolerance = 1e-3)
  expect_true(abs(umb1[[1]]$n$cases - umb2[[1]]$n$cases) < 200)
})

test_that("value + SE vs means/SD", {
  dfsmd <- subset(df.SMD, select=-c(mean_cases, mean_controls, sd_cases, sd_controls))
  dfwomean <- subset(df.SMD, select=-c(value, se, ci_lo, ci_up))

  umb1 <- umbrella(dfsmd, verbose=FALSE, seed = 4321)
  umb2 <- umbrella(dfwomean, verbose=FALSE, seed = 4321)
  expect_equal(umb1[[1]]$ma_results[, c("value", "p.value", "ci_lo", "ci_up", "pi_lo", "pi_up")], umb2[[1]]$ma_results[, c("value", "p.value", "ci_lo", "ci_up", "pi_lo", "pi_up")], tolerance = 1e-10)
  expect_equal(umb1[[1]]$heterogeneity$i2, umb2[[1]]$heterogeneity$i2, tolerance = 1e-10)
  expect_equal(umb1[[1]]$esb$p.value, umb2[[1]]$esb$p.value, tolerance = 1e-10)
  expect_equal(umb1[[1]]$egger$p.value, umb2[[1]]$egger$p.value, tolerance = 1e-10)
})

test_that("different measures lead to similar results: SMD + var vs means/SD", {
  skip_on_cran()
  dfsmd <- df.SMD
  dfwomean <- subset(df.SMD, select = -c(se, ci_lo, ci_up, mean_cases, mean_controls, sd_cases, sd_controls))

  dfwomean$var <- df.SMD$se^2
  umb1 <- umbrella(dfsmd, seed = 4321, verbose=FALSE)
  umb2 <- umbrella(dfwomean, seed = 4321, verbose=FALSE)
  expect_equal(umb1[[1]]$ma_results[, c("value", "p.value", "ci_lo", "ci_up", "pi_lo", "pi_up")], umb2[[1]]$ma_results[, c("value", "p.value", "ci_lo", "ci_up", "pi_lo", "pi_up")], tolerance = 1e-10)
  expect_equal(umb1[[1]]$heterogeneity$i2, umb2[[1]]$heterogeneity$i2, tolerance = 1e-10)
  expect_equal(umb1[[1]]$esb$p.value, umb2[[1]]$esb$p.value, tolerance = 1e-10)
  expect_equal(umb1[[1]]$egger$p.value, umb2[[1]]$egger$p.value, tolerance = 1e-10)
})

test_that("different measures lead to similar results: CI vs means/SD", {
  skip_on_cran()
  dfsmd <- subset(df.SMD, select=-c(mean_cases, mean_controls, sd_cases, sd_controls,
                                    value, se))
  dfwoVAL <- subset(df.SMD, select=-c(value, se, ci_lo, ci_up))

  umb1 <- umbrella(dfsmd, seed = 4321, verbose = FALSE)
  umb2 <- umbrella(dfwoVAL, seed = 4321, verbose = FALSE)
  expect_equal(umb1[[1]]$ma_results[, c("value", "p.value", "ci_lo", "ci_up", "pi_lo", "pi_up")],
               umb2[[1]]$ma_results[, c("value", "p.value", "ci_lo", "ci_up", "pi_lo", "pi_up")],
               tolerance = 1e-10)
  expect_equal(umb1[[1]]$heterogeneity$i2,
               umb2[[1]]$heterogeneity$i2, tolerance = 1e-10)
  expect_equal(umb1[[1]]$esb$p.value, umb2[[1]]$esb$p.value,
               tolerance = 1e-10)
  expect_equal(umb1[[1]]$egger$p.value,
               umb2[[1]]$egger$p.value, tolerance = 1e-10)
})

test_that("different measures lead to similar results: SMD w/o CI vs means/SD", {
  skip_on_cran()
  dfsmd <- subset(df.SMD, select=-c(se, ci_lo, ci_up, mean_cases, mean_controls, sd_cases, sd_controls))
  dfwoCI <- subset(df.SMD, select=-c(value, se, ci_lo, ci_up))

  umb1 <- umbrella(dfsmd, seed = 4321, verbose = FALSE)
  umb2 <- umbrella(dfwoCI, seed = 4321, verbose = FALSE)
  expect_equal(umb1[[1]]$ma_results[, c("value", "p.value", "ci_lo", "ci_up", "pi_lo", "pi_up")], umb2[[1]]$ma_results[, c("value", "p.value", "ci_lo", "ci_up", "pi_lo", "pi_up")],
               tolerance = 1e-10)
  expect_equal(umb1[[1]]$heterogeneity$i2, umb2[[1]]$heterogeneity$i2,
               tolerance = 1e-10)
  expect_equal(umb1[[1]]$esb$p.value, umb2[[1]]$esb$p.value, tolerance = 1e-10)
  expect_equal(umb1[[1]]$egger$p.value, umb2[[1]]$egger$p.value, tolerance = 1e-10)
})

test_that("different measures lead to similar results: SMD v MD+CI", {
  skip_on_cran()
  dfsmd <- df.SMD;
  dfmd = subset(df.MD, select=-c(mean_cases, mean_controls))
  umb1 <-  umbrella(dfsmd, seed = 4321, verbose = FALSE)
  umb2 <- umbrella(dfmd, seed = 4321, verbose = FALSE)

  expect_equal(umb1[[1]]$ma_results[, c("value", "p.value")],
               umb2[[1]]$ma_results[, c("value", "p.value")],
               tolerance = 3e-3)
  expect_equal(umb1[[1]]$ma_results[, c("value", "p.value", "ci_lo", "ci_up", "pi_lo", "pi_up")], umb2[[1]]$ma_results[, c("value", "p.value", "ci_lo", "ci_up", "pi_lo", "pi_up")],
               tolerance = 5e-2)
  expect_equal(umb1[[1]]$heterogeneity$i2, umb2[[1]]$heterogeneity$i2,
               tolerance = 1e-3)
  expect_equal(umb1[[1]]$esb$p.value, umb2[[1]]$esb$p.value,
               tolerance = 5e-2)
  expect_equal(umb1[[1]]$egger$p.value, umb2[[1]]$egger$p.value, tolerance = 5e-2)
})

test_that("different measures lead to similar results: SMD v MD+SE", {
  skip_on_cran()
  df.MD$se = with(df.MD, (ci_up - ci_lo) / (2*qt(.975, n_cases + n_controls - 2)))
  dfmd_se = subset(df.MD, select=-c(mean_cases, mean_controls,
                                    ci_lo, ci_up, sd_cases, sd_controls))
  dfmd_ci = subset(df.MD, select=-c(mean_cases, mean_controls,
                                    sd_cases, sd_controls))

  umb1 <- umbrella(df.SMD, seed = 4321, verbose = FALSE)
  umb2 <- umbrella(dfmd_se, seed = 4321, verbose = FALSE)
  expect_equal(umb1[[1]]$ma_results[, c("value", "p.value")],
               umb2[[1]]$ma_results[, c("value", "p.value")],
               tolerance = 3e-3)
  expect_equal(umb1[[1]]$ma_results[, c("value", "p.value", "ci_lo", "ci_up", "pi_lo", "pi_up")], umb2[[1]]$ma_results[, c("value", "p.value", "ci_lo", "ci_up", "pi_lo", "pi_up")],
               tolerance = 5e-2)
  expect_equal(umb1[[1]]$heterogeneity$i2, umb2[[1]]$heterogeneity$i2,
               tolerance = 1e-3)
  expect_equal(umb1[[1]]$esb$p.value, umb2[[1]]$esb$p.value,
               tolerance = 5e-2)
  expect_equal(umb1[[1]]$egger$p.value, umb2[[1]]$egger$p.value, tolerance = 5e-2)
})


test_that("different measures lead to similar results: means/SD v G+SE", {
  skip_on_cran()
  dfsmd <- df.SMD; dfsmd$measure <- "SMD"

  dfg <- dfsmd; dfg$measure <- "G"

  dfg$value = .estimate_g_from_d(d = dfsmd$value, n_cases = dfsmd$n_cases, n_controls = dfsmd$n_controls)$value
  dfg$se = .estimate_g_from_d(d = dfsmd$value, n_cases = dfsmd$n_cases, n_controls = dfsmd$n_controls)$se

  dfg <- subset(dfsmd, select = -c(ci_lo, ci_up, mean_cases, mean_controls, sd_cases, sd_controls))

  umb1 <- umbrella(dfsmd, seed = 4321, verbose = FALSE)
  umb2 <- umbrella(dfg, seed = 4321, verbose = FALSE)
  expect_equal(umb1[[1]]$ma_results[, c("value", "p.value", "ci_lo", "ci_up", "pi_lo", "pi_up")], umb2[[1]]$ma_results[, c("value", "p.value", "ci_lo", "ci_up", "pi_lo", "pi_up")], tolerance = 1e-10)
  expect_equal(umb1[[1]]$heterogeneity$i2, umb2[[1]]$heterogeneity$i2, tolerance = 1e-10)
  expect_equal(umb1[[1]]$esb$p.value, umb2[[1]]$esb$p.value, tolerance = 1e-10)
  expect_equal(umb1[[1]]$egger$p.value, umb2[[1]]$egger$p.value, tolerance = 1e-10)
})

test_that("different measures lead to similar results: means/SD v value G", {
  skip_on_cran()
  dfsmd <- df.SMD; dfsmd$measure <- "SMD"

  dfg <- dfsmd; dfg$measure <- "G"

  dfg$value = .estimate_g_from_d(d = dfsmd$value, n_cases = dfsmd$n_cases, n_controls = dfsmd$n_controls)$value
  dfg$se = .estimate_g_from_d(d = dfsmd$value, n_cases = dfsmd$n_cases, n_controls = dfsmd$n_controls)$se

  dfg <- subset(dfsmd, select = -c(se, ci_lo, ci_up, mean_cases, mean_controls, sd_cases, sd_controls))

  umb1 <- umbrella(dfsmd, seed = 4321, verbose = FALSE)
  umb2 <- umbrella(dfg, seed = 4321, verbose = FALSE)
  expect_equal(umb1[[1]]$ma_results[, c("value", "p.value", "ci_lo", "ci_up", "pi_lo", "pi_up")], umb2[[1]]$ma_results[, c("value", "p.value", "ci_lo", "ci_up", "pi_lo", "pi_up")], tolerance = 1e-10)
  expect_equal(umb1[[1]]$heterogeneity$i2, umb2[[1]]$heterogeneity$i2, tolerance = 1e-10)
  expect_equal(umb1[[1]]$esb$p.value, umb2[[1]]$esb$p.value, tolerance = 1e-10)
  expect_equal(umb1[[1]]$egger$p.value, umb2[[1]]$egger$p.value, tolerance = 1e-10)
})

test_that("different measures lead to similar results: G with / without CI", {
  skip_on_cran()
  dfsmd = subset(df.SMD, select=-c(se, mean_cases, mean_controls))
  dfsmd$measure <- "SMD"
  dfg <- dfsmd;
  dfg$measure <- "G"

  dfg$value = metaConvert::es_from_cohen_d(
    cohen_d = dfsmd$value, n_exp = dfsmd$n_cases, n_nexp = dfsmd$n_controls)$g
  dfg$se = metaConvert::es_from_cohen_d(
    cohen_d = dfsmd$value, n_exp = dfsmd$n_cases, n_nexp = dfsmd$n_controls)$g_se
  dfg$ci_lo = metaConvert::es_from_cohen_d(
    cohen_d = dfsmd$value, n_exp = dfsmd$n_cases, n_nexp = dfsmd$n_controls)$g_ci_lo
  dfg$ci_up = metaConvert::es_from_cohen_d(
    cohen_d = dfsmd$value, n_exp = dfsmd$n_cases, n_nexp = dfsmd$n_controls)$g_ci_up

  umb1 <- umbrella(dfsmd, seed = 4321, verbose = FALSE)
  umb2 <- umbrella(dfg, seed = 4321, verbose = FALSE)
  expect_equal(umb1[[1]]$ma_results[, c("value", "p.value", "ci_lo", "ci_up", "pi_lo", "pi_up")],
               umb2[[1]]$ma_results[, c("value", "p.value", "ci_lo", "ci_up", "pi_lo", "pi_up")],
               tolerance = 1e-10)
  expect_equal(umb1[[1]]$heterogeneity$i2, umb2[[1]]$heterogeneity$i2, tolerance = 1e-10)
  expect_equal(umb1[[1]]$esb$p.value, umb2[[1]]$esb$p.value, tolerance = 1e-10)
  expect_equal(umb1[[1]]$egger$p.value, umb2[[1]]$egger$p.value, tolerance = 1e-10)
})

### SMC ----------------------------------------------------------------
test_that("smc wth / wthout n_cases", {
  dfwoN<- subset(df.SMC, select=-c(n_cases, n_controls))
  umb1 <- umbrella(df.SMC, verbose=FALSE, seed = 4321)
  umb2 <- umbrella(dfwoN, verbose=FALSE, seed = 4321)
  expect_equal(umb1[[1]]$ma_results[, c("value", "p.value", "ci_lo", "ci_up", "pi_lo", "pi_up")],
               umb2[[1]]$ma_results[, c("value", "p.value", "ci_lo", "ci_up", "pi_lo", "pi_up")],
               tolerance = 5e-2)
  expect_equal(umb1[[1]]$heterogeneity$i2,
               umb2[[1]]$heterogeneity$i2, tolerance = 5e-3)
  expect_equal(umb1[[1]]$esb$p.value,
               umb2[[1]]$esb$p.value, tolerance = 1e-2)
  expect_equal(umb1[[1]]$egger$p.value, umb2[[1]]$egger$p.value,
               tolerance = 1e-2)
  expect_true(is.na(umb2[[1]]$n$cases))
})

test_that("SMC: means pre-post vs value + se", {
  ## slight diff because correction for G is not estimated the same
  df_means <- subset(df.SMC,
                select = -c(
     value, se))

  df_values <- subset(df.SMC, select = -c(
      mean_cases, mean_controls,
      sd_cases, sd_controls,
      mean_pre_cases, mean_pre_controls,
      sd_pre_cases, sd_pre_controls
  ))

  umb1 <- umbrella(df_means, verbose=FALSE, seed = 4321)
  umb2 <- umbrella(df_values, verbose=FALSE, seed = 4321)
  expect_equal(umb1[[1]]$ma_results[, c("value", "p.value", "ci_lo", "ci_up", "pi_lo", "pi_up")],
               umb2[[1]]$ma_results[, c("value", "p.value", "ci_lo", "ci_up", "pi_lo", "pi_up")],
               tolerance = 5e-2)
  expect_equal(umb1[[1]]$heterogeneity$i2, umb2[[1]]$heterogeneity$i2, tolerance = 1e-3)
  expect_equal(umb1[[1]]$esb$p.value, umb2[[1]]$esb$p.value, tolerance = 1e-3)
  expect_equal(umb1[[1]]$egger$p.value, umb2[[1]]$egger$p.value, tolerance = 1e-2)
})


test_that("SMC: different measures lead to similar results: value + SE vs mean change", {
  df1 <- subset(df.MC, select = -c(value, se
                                    # ci_lo, ci_up,
                                    #mean_change_cases, mean_change_controls, sd_change_cases, sd_change_controls,
                                    ))

  df2 <- subset(df.MC, select = -c(#value, se,
                                    # ci_lo, ci_up,
                                    mean_change_cases, mean_change_controls, sd_change_cases, sd_change_controls
  ))

  umb1 <- umbrella(df1, verbose=FALSE, seed = 4321)
  umb2 <- umbrella(df2, verbose=FALSE, seed = 4321)

  expect_equal(umb1[[1]]$pooled_md,
               umb2[[1]]$pooled_md,
               tolerance = 1e-10)

  expect_equal(umb1[[1]]$ma_results[, c("value", "p.value", "ci_lo", "ci_up", "pi_lo", "pi_up")],
               umb2[[1]]$ma_results[, c("value", "p.value", "ci_lo", "ci_up", "pi_lo", "pi_up")],
               tolerance = 1)
  expect_equal(umb1[[1]]$heterogeneity$i2,
               umb2[[1]]$heterogeneity$i2,
               tolerance = 1)
  expect_equal(umb1[[1]]$esb$p.value,
               umb2[[1]]$esb$p.value, tolerance = 1e-3)
  expect_equal(umb1[[1]]$egger$p.value,
               umb2[[1]]$egger$p.value, tolerance = 1)
})


test_that("SMC: change + pre/post", {
  df1 <- subset(df.MC, select = -c(
    value, se
  ))

  df2 <- subset(df.SMC, select = -c(value, se
  ))
  # df1$pre_post_cor = 0.8

  umb1 <- umbrella(df1, seed = 4321, pre_post_cor = 0.8)
  umb2 <- umbrella(df2, seed = 4321, pre_post_cor = 0.8)
  expect_equal(umb1[[1]]$ma_results[, c("value", "p.value", "ci_lo", "ci_up", "pi_lo", "pi_up")], umb2[[1]]$ma_results[, c("value", "p.value", "ci_lo", "ci_up", "pi_lo", "pi_up")],
               tolerance = 1e-10)
  expect_equal(umb1[[1]]$heterogeneity$i2, umb2[[1]]$heterogeneity$i2,
               tolerance = 1e-10)
  expect_equal(umb1[[1]]$esb$p.value, umb2[[1]]$esb$p.value,
               tolerance = 1e-10)
  expect_equal(umb1[[1]]$egger$p.value, umb2[[1]]$egger$p.value,
               tolerance = 1e-10)
})
##### R ------------------
test_that("R wth / wthout n_sample", {
  dfwoN<- subset(df.R, select=-c(n_sample))
  es_r = metaConvert::es_from_pearson_r(
    pearson_r = df.R$value, n_sample = df.R$n_sample
  )

  dfwoN$ci_lo = es_r$r_ci_lo
  dfwoN$ci_up = es_r$r_ci_up

  umb1 <- umbrella(df.R, verbose=FALSE, seed = 4321)
  umb2 <- umbrella(dfwoN, verbose=FALSE, seed = 4321)

  # view.errors.umbrella(dfwoN, "message")
  expect_equal(umb1[[1]]$ma_results[, c("value", "p.value", "ci_lo", "ci_up", "pi_lo", "pi_up")],
               umb2[[1]]$ma_results[, c("value", "p.value", "ci_lo", "ci_up", "pi_lo", "pi_up")],
               tolerance = 1e-2)
  expect_equal(umb1[[1]]$heterogeneity$i2,
               umb2[[1]]$heterogeneity$i2, tolerance = 5e-3)
  expect_equal(umb1[[1]]$esb$p.value,
               umb2[[1]]$esb$p.value, tolerance = 1e-2)
  expect_equal(umb1[[1]]$egger$p.value, umb2[[1]]$egger$p.value,
               tolerance = 1e-2)
  expect_true(abs(umb1[[1]]$n$total_n -
                  umb2[[1]]$n$total_n) < 100)
})
test_that("Z wth / wthout n_sample", {
  df.Z = df.R
  df.Z$measure = "Z"
  dfwoN<- subset(df.Z, select=-c(n_sample))

  es_z = metaConvert::es_from_fisher_z(
    fisher_z = df.Z$value, n_sample = df.Z$n_sample
  )

  dfwoN$ci_lo = es_z$z_ci_lo
  dfwoN$ci_up = es_z$z_ci_up

  umb1 <- umbrella(df.Z, verbose=FALSE, seed = 4321)
  umb2 <- umbrella(dfwoN, verbose=FALSE, seed = 4321)

  # view.errors.umbrella(dfwoN, "message")
  expect_equal(umb1[[1]]$ma_results[, c("value", "p.value", "ci_lo", "ci_up", "pi_lo", "pi_up")],
               umb2[[1]]$ma_results[, c("value", "p.value", "ci_lo", "ci_up", "pi_lo", "pi_up")],
               tolerance = 1e-10)
  expect_equal(umb1[[1]]$heterogeneity$i2,
               umb2[[1]]$heterogeneity$i2, tolerance = 1e-10)
  expect_equal(umb1[[1]]$esb$p.value,
               umb2[[1]]$esb$p.value, tolerance = 1e-10)
  expect_equal(umb1[[1]]$egger$p.value, umb2[[1]]$egger$p.value,
               tolerance = 1e-10)
  expect_true(abs(umb1[[1]]$n$total_n -
                    umb2[[1]]$n$total_n) < 100)
})

test_that("R: value se + CI vs value", {
  df.R <- subset(df.R, factor == "Gestational_hypertension")
  df.R = df.R[-c(1, 7, 8, 9, 12), ]
  res = metaConvert::es_from_pearson_r(
    pearson_r=df.R$value, n_sample = df.R$n_sample)

  df.Z = df.R
  df.R$ci_lo = res$r_ci_lo
  df.R$ci_up = res$r_ci_up
  df.Z$se = res$r_se
  umb1 <- umbrella(df.R, seed = 4321)
  umb2 <- umbrella(df.Z, seed = 4321)
  expect_equal(umb1[[1]]$ma_results[, c("value", "p.value", "ci_lo", "ci_up", "pi_lo", "pi_up")], umb2[[1]]$ma_results[, c("value", "p.value", "ci_lo", "ci_up", "pi_lo", "pi_up")],
               tolerance = 5e-2)
  expect_equal(umb1[[1]]$heterogeneity$i2, umb2[[1]]$heterogeneity$i2,
               tolerance = 2e-2)
  expect_equal(umb1[[1]]$esb$p.value, umb2[[1]]$esb$p.value,
               tolerance = 5e-2)
  expect_equal(umb1[[1]]$egger$p.value, umb2[[1]]$egger$p.value,
               tolerance = 5e-2)
})


test_that("R: value + CI vs value", {
  # Because we take the 95% CI to estimate se
  df.R <- subset(df.R, factor == "Gestational_hypertension")
  df.R = df.R[-c(1, 7, 8, 9, 12), ]
  res = metaConvert::es_from_pearson_r(
    pearson_r=df.R$value, n_sample = df.R$n_sample)

  df.Z = df.R
  df.R$ci_lo = res$r_ci_lo
  df.R$ci_up = res$r_ci_up
  umb1 <- umbrella(df.R, seed = 4321)
  umb2 <- umbrella(df.Z, seed = 4321)
  # umb1[[1]]$x$ci_lo
  # umb2[[1]]$x$ci_lo

  expect_equal(umb1[[1]]$ma_results[, c("value", "p.value", "ci_lo", "ci_up", "pi_lo", "pi_up")],
               umb2[[1]]$ma_results[, c("value", "p.value", "ci_lo", "ci_up", "pi_lo", "pi_up")],
               tolerance = 5e-2)
  expect_equal(umb1[[1]]$heterogeneity$i2, umb2[[1]]$heterogeneity$i2,
               tolerance = 1e-2)
  expect_equal(umb1[[1]]$esb$p.value, umb2[[1]]$esb$p.value,
               tolerance = 5e-1)
  expect_equal(umb1[[1]]$egger$p.value, umb2[[1]]$egger$p.value,
               tolerance = 1)
})
test_that("Z: value + SE vs value", {
  df.R <- subset(df.R,
                 factor == "Gestational_hypertension"
  )
  df.R = df.R[-c(1, 7, 8, 9, 12), ]
  df.R$measure = "Z"
  res = metaConvert::es_from_pearson_r(
    pearson_r=df.R$value, n_sample = df.R$n_sample)
  df.R$value = res$z

  df.Z = df.R
  df.Z$se = res$z_se

  umb1 <- umbrella(df.R, seed = 4321)
  umb2 <- umbrella(df.Z, seed = 4321)

  expect_equal(umb1[[1]]$ma_results[, c("value", "p.value", "ci_lo", "ci_up", "pi_lo", "pi_up")],
               umb2[[1]]$ma_results[, c("value", "p.value", "ci_lo", "ci_up", "pi_lo", "pi_up")],
               tolerance = 1e-10)
  expect_equal(umb1[[1]]$heterogeneity$i2, umb2[[1]]$heterogeneity$i2,
               tolerance = 1e-10)
  expect_equal(umb1[[1]]$esb$p.value, umb2[[1]]$esb$p.value,
               tolerance = 1e-10)
  expect_equal(umb1[[1]]$egger$p.value, umb2[[1]]$egger$p.value,
               tolerance = 1e-10)
})
test_that("Z: value + CI vs value", {
  df.R <- subset(df.R,
                 factor == "Gestational_hypertension"
                 )
  df.R = df.R[-c(1, 7, 8, 9, 12), ]
  df.R$measure = "Z"
  res = metaConvert::es_from_pearson_r(
    pearson_r=df.R$value, n_sample = df.R$n_sample)
  df.R$value = res$z

  df.Z = df.R
  df.Z$ci_lo = res$z_ci_lo
  df.Z$ci_up = res$z_ci_up

  umb1 <- umbrella(df.R, seed = 4321)
  umb2 <- umbrella(df.Z, seed = 4321)

  expect_equal(umb1[[1]]$ma_results[, c("value", "p.value", "ci_lo", "ci_up", "pi_lo", "pi_up")],
               umb2[[1]]$ma_results[, c("value", "p.value", "ci_lo", "ci_up", "pi_lo", "pi_up")],
               tolerance = 1e-10)
  expect_equal(umb1[[1]]$heterogeneity$i2, umb2[[1]]$heterogeneity$i2,
               tolerance = 1e-10)
  expect_equal(umb1[[1]]$esb$p.value, umb2[[1]]$esb$p.value,
               tolerance = 1e-10)
  expect_equal(umb1[[1]]$egger$p.value, umb2[[1]]$egger$p.value,
               tolerance = 1e-10)
})
test_that("Z: value + CI vs value + se", {
  df.R <- subset(df.R,
                 factor == "Gestational_hypertension"
  )
  df.R = df.R[-c(1, 7, 8, 9, 12), ]
  df.R$measure = "Z"
  res = metaConvert::es_from_pearson_r(
    pearson_r=df.R$value, n_sample = df.R$n_sample)
  df.R$value = res$z

  df.Z = df.R
  df.Z$ci_lo = res$z_ci_lo
  df.Z$ci_up = res$z_ci_up

  df.R$se = res$z_se

  umb1 <- umbrella(df.R, seed = 4321)
  umb2 <- umbrella(df.Z, seed = 4321)

  expect_equal(umb1[[1]]$ma_results[, c("value", "p.value", "ci_lo", "ci_up", "pi_lo", "pi_up")],
               umb2[[1]]$ma_results[, c("value", "p.value", "ci_lo", "ci_up", "pi_lo", "pi_up")],
               tolerance = 1e-10)
  expect_equal(umb1[[1]]$heterogeneity$i2, umb2[[1]]$heterogeneity$i2,
               tolerance = 1e-10)
  expect_equal(umb1[[1]]$esb$p.value, umb2[[1]]$esb$p.value,
               tolerance = 1e-10)
  expect_equal(umb1[[1]]$egger$p.value, umb2[[1]]$egger$p.value,
               tolerance = 1e-10)
})

##### OR -----------------

test_that("OR wth / wthout n", {
  skip_on_cran()
  dforwoN <- subset(df.OR, select = -c(n_exp, n_nexp, n_cases, n_controls,
                                     n_cases_exp, n_cases_nexp, n_controls_exp,
                                     n_controls_nexp))

  umb1 <- umbrella(dforwoN, seed = 4321, verbose = FALSE)
  umb2 <- umbrella(df.OR, seed = 4321, verbose = FALSE)
  expect_equal(umb1[[1]]$ma_results[, c("value", "p.value", "ci_lo", "ci_up", "pi_lo", "pi_up")],
               umb2[[1]]$ma_results[, c("value", "p.value", "ci_lo", "ci_up", "pi_lo", "pi_up")],
               tolerance = 1e-10)
  expect_equal(umb1[[1]]$heterogeneity$i2, umb2[[1]]$heterogeneity$i2, tolerance = 1e-10)
  expect_equal(umb1[[1]]$esb$p.value, umb2[[1]]$esb$p.value, tolerance = 1e-10)
  expect_equal(umb1[[1]]$egger$p.value, umb2[[1]]$egger$p.value, tolerance = 1e-10)
})

test_that("OR n_cases/controls vs. n_exp/n_nexp", {
  skip_on_cran()
  dfor1 <- subset(df.OR, select = -c(n_exp, n_nexp, n_cases_exp, n_cases_nexp, n_controls_exp, n_controls_nexp))
  dfor2 <- subset(df.OR, select = -c(n_cases, n_controls, n_cases_exp, n_cases_nexp, n_controls_exp, n_controls_nexp))

  umb1 <- umbrella(dfor1, seed = 4321, verbose = FALSE)
  umb2 <- umbrella(dfor2, seed = 4321, verbose = FALSE)
  expect_equal(umb1[[1]]$ma_results[, c("value", "p.value", "ci_lo", "ci_up", "pi_lo", "pi_up")],
               umb2[[1]]$ma_results[, c("value", "p.value", "ci_lo", "ci_up", "pi_lo", "pi_up")],
               tolerance = 1e-10)
  expect_equal(umb1[[1]]$heterogeneity$i2, umb2[[1]]$heterogeneity$i2, tolerance = 1e-10)
  expect_equal(umb1[[1]]$esb$p.value, umb2[[1]]$esb$p.value, tolerance = 1e-10)
  expect_equal(umb1[[1]]$egger$p.value, umb2[[1]]$egger$p.value, tolerance = 1e-10)
})

test_that("OR + CI n_cases/controls vs. 2x2 table", {
  skip_on_cran()

  dfor1 <- subset(df.OR, select = -c(n_exp, n_nexp, n_cases_exp, n_cases_nexp, n_controls_exp, n_controls_nexp))
  dfor2 <- subset(df.OR, select = -c(value, ci_lo, ci_up, n_cases, n_controls, n_exp, n_nexp))
  se =   with(df.OR, sqrt(1 / n_cases_exp +
                            1 / n_cases_nexp +
                            1 / n_controls_exp +
                            1 / n_controls_nexp))
  dfor1$ci_lo = dfor1$value / exp(qnorm(0.975) * se)
  dfor1$ci_up = dfor1$value * exp(qnorm(0.975) * se)

  umb1 <- umbrella(dfor1, seed = 4321, verbose = FALSE)
  umb2 <- umbrella(dfor2, seed = 4321, verbose = FALSE)
  expect_equal(umb1[[1]]$ma_results[, c("value", "p.value", "ci_lo", "ci_up", "pi_lo", "pi_up")],
               umb2[[1]]$ma_results[, c("value", "p.value", "ci_lo", "ci_up", "pi_lo", "pi_up")],
               tolerance = 1e-10)
  expect_equal(umb1[[1]]$heterogeneity$i2, umb2[[1]]$heterogeneity$i2, tolerance = 1e-10)
  expect_equal(umb1[[1]]$esb$p.value, umb2[[1]]$esb$p.value, tolerance = 1e-10)
  expect_equal(umb1[[1]]$egger$p.value, umb2[[1]]$egger$p.value, tolerance = 1e-10)
})

test_that("OR n_cases/controls SE vs. 2x2 table", {
  skip_on_cran()
  dfor1 <- subset(df.OR, select = -c(ci_lo, ci_up, n_exp, n_nexp, n_cases_exp, n_cases_nexp, n_controls_exp, n_controls_nexp))
  dfor2 <- subset(df.OR, select = -c(value, ci_lo, ci_up, n_cases, n_controls, n_exp, n_nexp))

  dfor1$se <- with(df.OR, sqrt(1 / n_cases_exp +
                                 1 / n_cases_nexp +
                                 1 / n_controls_exp +
                                 1 / n_controls_nexp))

  umb1 <- umbrella(dfor1, seed = 4321, verbose = FALSE)
  umb2 <- umbrella(dfor2, seed = 4321, verbose = FALSE)
  expect_equal(umb1[[1]]$ma_results[, c("value", "p.value", "ci_lo", "ci_up", "pi_lo", "pi_up")],
               umb2[[1]]$ma_results[, c("value", "p.value", "ci_lo", "ci_up", "pi_lo", "pi_up")],
               tolerance = 1e-10)
  expect_equal(umb1[[1]]$heterogeneity$i2, umb2[[1]]$heterogeneity$i2, tolerance = 1e-10)
  expect_equal(umb1[[1]]$esb$p.value, umb2[[1]]$esb$p.value, tolerance = 1e-10)
  expect_equal(umb1[[1]]$egger$p.value, umb2[[1]]$egger$p.value, tolerance = 1e-10)
})

test_that("OR n_exp/n_nexp vs. 2x2 table", {
  skip_on_cran()
  dfor1 <- subset(df.OR, select = -c(n_cases, n_controls, n_cases_exp, n_cases_nexp, n_controls_exp, n_controls_nexp))
  dfor2 <- subset(df.OR, select = -c(value, ci_lo, ci_up, n_cases, n_controls, n_exp, n_nexp))
  se = with(df.OR, sqrt(1 / n_cases_exp + 1 / n_cases_nexp + 1 / n_controls_exp + 1 / n_controls_nexp))
  dfor1$ci_lo = dfor1$value / exp(qnorm(0.975) * se)
  dfor1$ci_up = dfor1$value * exp(qnorm(0.975) * se)

  umb1 <- umbrella(dfor1, seed = 4321, verbose = FALSE)
  umb2 <- umbrella(dfor2, seed = 4321, verbose = FALSE)
  expect_equal(umb1[[1]]$ma_results[, c("value", "p.value", "ci_lo", "ci_up", "pi_lo", "pi_up")],
               umb2[[1]]$ma_results[, c("value", "p.value", "ci_lo", "ci_up", "pi_lo", "pi_up")],
               tolerance = 1e-10)
  expect_equal(umb1[[1]]$heterogeneity$i2, umb2[[1]]$heterogeneity$i2, tolerance = 1e-10)
  expect_equal(umb1[[1]]$esb$p.value, umb2[[1]]$esb$p.value, tolerance = 1e-10)
  expect_equal(umb1[[1]]$egger$p.value, umb2[[1]]$egger$p.value, tolerance = 1e-10)
})

test_that("OR n_exp/n_nexp SE vs. 2x2 table", {
  skip_on_cran()
  dfor1 <- subset(df.OR, select = -c(ci_lo, ci_up, n_controls, n_cases, n_cases_exp, n_cases_nexp, n_controls_exp, n_controls_nexp))
  dfor2 <- subset(df.OR, select = -c(value, ci_lo, ci_up, n_cases, n_controls, n_exp, n_nexp))

  dfor1$se <- with(dfor2, sqrt(1 / n_cases_exp + 1 / n_cases_nexp + 1 / n_controls_exp + 1 / n_controls_nexp))
  umb1 <- umbrella(dfor1, seed = 4321, verbose = FALSE)
  umb2 <- umbrella(dfor2, seed = 4321, verbose = FALSE)
  expect_equal(umb1[[1]]$ma_results[, c("value", "p.value", "ci_lo", "ci_up", "pi_lo", "pi_up")], umb2[[1]]$ma_results[, c("value", "p.value", "ci_lo", "ci_up", "pi_lo", "pi_up")], tolerance = 1e-10)
  expect_equal(umb1[[1]]$heterogeneity$i2, umb2[[1]]$heterogeneity$i2, tolerance = 1e-10)
  expect_equal(umb1[[1]]$esb$p.value, umb2[[1]]$esb$p.value, tolerance = 1e-10)
  expect_equal(umb1[[1]]$egger$p.value, umb2[[1]]$egger$p.value, tolerance = 1e-10)
})

test_that("OR n_cases/controls with / without CI", {
  skip_on_cran()
  dfor1 <- subset(df.OR, select = -c(n_exp, n_nexp, n_cases_exp, n_cases_nexp, n_controls_exp, n_controls_nexp))
  dfor2 <- subset(df.OR, select = -c(ci_lo, ci_up, n_exp, n_nexp, n_cases_exp, n_cases_nexp, n_controls_exp, n_controls_nexp))

  se = with(df.OR, sqrt(1 / n_cases_exp + 1 / n_cases_nexp + 1 / n_controls_exp + 1 / n_controls_nexp))
  dfor1$ci_lo = dfor1$value / exp(qnorm(0.975) * se)
  dfor1$ci_up = dfor1$value * exp(qnorm(0.975) * se)

  umb1 <- umbrella(dfor1, seed = 4321, verbose = FALSE)
  umb2 <- umbrella(dfor2, seed = 4321, verbose = FALSE)

  expect_equal(umb1[[1]]$ma_results[, c("value", "p.value", "ci_lo", "ci_up", "pi_lo", "pi_up")],
               umb2[[1]]$ma_results[, c("value", "p.value", "ci_lo", "ci_up", "pi_lo", "pi_up")],
               tolerance = 5e-1)
  expect_equal(umb1[[1]]$esb$p.value, umb2[[1]]$esb$p.value, tolerance = 5e-1)
  expect_equal(umb1[[1]]$egger$p.value, umb2[[1]]$egger$p.value, tolerance = 5e-1)
})

##### RR -----------------
test_that("RR wth wthout N", {
  skip_on_cran()
  dfrr1 <- subset(df.RR, select = -c(n_exp, n_nexp, n_cases_exp, n_cases_nexp))
  umb1 <- umbrella(dfrr1, seed = 4321, verbose = FALSE)
  umb2 <- umbrella(df.RR, seed = 4321, verbose = FALSE)
  expect_equal(umb1[[1]]$ma_results[, c("value", "p.value", "ci_lo", "ci_up", "pi_lo", "pi_up")],
               umb2[[1]]$ma_results[, c("value", "p.value", "ci_lo", "ci_up", "pi_lo", "pi_up")], tolerance = 1e-10)
  expect_equal(umb1[[1]]$heterogeneity$i2,
               umb2[[1]]$heterogeneity$i2, tolerance = 1e-10)
  expect_equal(umb1[[1]]$esb$p.value, umb2[[1]]$esb$p.value,
               tolerance = 1e-10)
  expect_equal(umb1[[1]]$egger$p.value, umb2[[1]]$egger$p.value,
               tolerance = 1e-10)
})


test_that("RR + CI n_cases/controls vs. 2x2 table", {
  skip_on_cran()
  dfrr1 <- df.RR
  dfrr1$n_cases = dfrr1$n_cases_exp + dfrr1$n_cases_nexp
  dfrr1$n_controls = dfrr1$n_exp + dfrr1$n_nexp - dfrr1$n_cases
  dfrr1 <- subset(dfrr1, select = -c(n_exp, n_nexp, n_cases_exp, n_cases_nexp))
  se = with(df.RR, sqrt(1 / n_cases_exp - 1 / n_exp + 1 / n_cases_nexp - 1 / n_nexp))
  dfrr1$ci_lo = dfrr1$value / exp(qnorm(0.975) * se)
  dfrr1$ci_up = dfrr1$value * exp(qnorm(0.975) * se)

  dfrr2 <- df.RR

  umb1 <- umbrella(dfrr1, seed = 4321, verbose = FALSE)
  umb2 <- umbrella(dfrr2, seed = 4321, verbose = FALSE)
  expect_equal(umb1[[1]]$ma_results[, c("value", "p.value", "ci_lo", "ci_up", "pi_lo", "pi_up")],
               umb2[[1]]$ma_results[, c("value", "p.value", "ci_lo", "ci_up", "pi_lo", "pi_up")], tolerance = 1e-10)
  expect_equal(umb1[[1]]$heterogeneity$i2, umb2[[1]]$heterogeneity$i2, tolerance = 1e-10)
  expect_equal(umb1[[1]]$esb$p.value, umb2[[1]]$esb$p.value, tolerance = 1e-10)
  expect_equal(umb1[[1]]$egger$p.value, umb2[[1]]$egger$p.value, tolerance = 1e-10)
})
test_that("RR + SE n_cases/controls vs. 2x2 table", {
  skip_on_cran()
  dfrr1 <- df.RR
  dfrr1$n_cases = dfrr1$n_cases_exp + dfrr1$n_cases_nexp
  dfrr1$n_controls = dfrr1$n_exp + dfrr1$n_nexp - dfrr1$n_cases
  dfrr1 <- subset(dfrr1, select = -c(n_exp, n_nexp, n_cases_exp, n_cases_nexp))
  dfrr1$se = with(df.RR, sqrt(1 / n_cases_exp - 1 / n_exp + 1 / n_cases_nexp - 1 / n_nexp))
  dfrr1$ci_lo = dfrr1$ci_up = NA

  dfrr2 <- df.RR

  umb1 <- umbrella(dfrr1, seed = 4321, verbose = FALSE)
  umb2 <- umbrella(dfrr2, seed = 4321, verbose = FALSE)
  expect_equal(umb1[[1]]$ma_results[, c("value", "p.value", "ci_lo", "ci_up", "pi_lo", "pi_up")], umb2[[1]]$ma_results[, c("value", "p.value", "ci_lo", "ci_up", "pi_lo", "pi_up")], tolerance = 1e-10)
  expect_equal(umb1[[1]]$heterogeneity$i2, umb2[[1]]$heterogeneity$i2, tolerance = 1e-10)
  expect_equal(umb1[[1]]$esb$p.value, umb2[[1]]$esb$p.value, tolerance = 1e-10)
  expect_equal(umb1[[1]]$egger$p.value, umb2[[1]]$egger$p.value, tolerance = 1e-10)
})
test_that("RR n_cases/controls SE vs. RR n_cases/controls CI", {
  skip_on_cran()

  dfrr1 <- df.RR

  dfrr1$n_cases = dfrr1$n_cases_exp + dfrr1$n_cases_nexp
  dfrr1$n_controls = dfrr1$n_exp + dfrr1$n_nexp - dfrr1$n_cases

  dfrr1$se = with(dfrr1, sqrt(1 / n_cases_exp - 1 / n_exp + 1 / n_cases_nexp - 1 / n_nexp))
  dfrr1$ci_lo = with(dfrr1, value / exp(qnorm(0.975) * se))
  dfrr1$ci_up = with(dfrr1, value * exp(qnorm(0.975) * se))

  dfrr2 <- subset(dfrr1, select = -c(se, n_exp, n_nexp, n_cases_exp, n_cases_nexp))
  dfrr3 <- subset(dfrr1, select = -c(ci_lo, ci_up, n_exp, n_nexp, n_cases_exp, n_cases_nexp))

  umb1 <- umbrella(dfrr2, seed = 4321, verbose = FALSE)
  umb2 <- umbrella(dfrr3, seed = 4321, verbose = FALSE)
  expect_equal(umb1[[1]]$ma_results[, c("value", "p.value", "ci_lo", "ci_up", "pi_lo", "pi_up")], umb2[[1]]$ma_results[, c("value", "p.value", "ci_lo", "ci_up", "pi_lo", "pi_up")], tolerance = 1e-10)
  expect_equal(umb1[[1]]$heterogeneity$i2, umb2[[1]]$heterogeneity$i2, tolerance = 1e-10)
  expect_equal(umb1[[1]]$esb$p.value, umb2[[1]]$esb$p.value, tolerance = 1e-10)
  expect_equal(umb1[[1]]$egger$p.value, umb2[[1]]$egger$p.value, tolerance = 1e-10)
})

##### IRR -----------------
test_that("IRR wth wthout N", {
  skip_on_cran()
  dfirr1 <- subset(df.IRR, select = -c(n_cases_exp, n_cases_nexp, time_exp, time_nexp))
  umb1 <- umbrella(dfirr1, seed = 4321)
  umb2 <- umbrella(df.IRR, seed = 4321)
  expect_equal(umb1[[1]]$ma_results[, c("value", "p.value", "ci_lo", "ci_up", "pi_lo", "pi_up")], umb2[[1]]$ma_results[, c("value", "p.value", "ci_lo", "ci_up", "pi_lo", "pi_up")],
               tolerance = 1e-10)
  expect_equal(umb1[[1]]$heterogeneity$i2, umb2[[1]]$heterogeneity$i2,
               tolerance = 1e-10)
  expect_equal(umb1[[1]]$esb$p.value, umb2[[1]]$esb$p.value,
               tolerance = 1e-10)
  expect_equal(umb1[[1]]$egger$p.value, umb2[[1]]$egger$p.value,
               tolerance = 1e-10)
})

test_that("different measures lead to similar results: IRR + CI + n_cases/time vs. n_cases_exp-nexp/time-exp/nexp", {
  skip_on_cran()
  dfirr1 <- subset(df.IRR, select = -c(n_cases_exp, n_cases_nexp, time_exp, time_nexp))
  dfirr2 <- subset(df.IRR, select = -c(n_cases, time))

  se = with(df.IRR, sqrt(1 / n_cases_exp + 1 / n_cases_nexp))
  dfirr1$ci_lo = dfirr1$value / exp(qnorm(0.975) * se)
  dfirr1$ci_up = dfirr1$value * exp(qnorm(0.975) * se)


  umb1 <- umbrella(dfirr1, seed = 4321)
  umb2 <- umbrella(dfirr2, seed = 4321)
  expect_equal(umb1[[1]]$ma_results[, c("value", "p.value", "ci_lo", "ci_up", "pi_lo", "pi_up")], umb2[[1]]$ma_results[, c("value", "p.value", "ci_lo", "ci_up", "pi_lo", "pi_up")],
               tolerance = 1e-3)
  expect_equal(umb1[[1]]$heterogeneity$i2, umb2[[1]]$heterogeneity$i2,
               tolerance = 1e-3)
  expect_equal(umb1[[1]]$esb$p.value, umb2[[1]]$esb$p.value,
               tolerance = 1e-3)
  expect_equal(umb1[[1]]$egger$p.value, umb2[[1]]$egger$p.value,
               tolerance = 1e-3)
})
test_that("IRR + SE + n_cases/time vs. n_cases_exp-nexp/time-exp/nexp", {
  skip_on_cran()
  dfirr1 <- subset(df.IRR, select = -c(ci_lo, ci_up, n_cases_exp, n_cases_nexp, time_exp, time_nexp))
  dfirr2 <- subset(df.IRR, select = -c(n_cases, time))

  dfirr1$se = with(df.IRR, sqrt(1 / n_cases_exp + 1 / n_cases_nexp))

  umb1 <- umbrella(dfirr1, seed = 4321, verbose = FALSE)
  umb2 <- umbrella(dfirr2, seed = 4321, verbose = FALSE)
  expect_equal(umb1[[1]]$ma_results[, c("value", "p.value", "ci_lo", "ci_up", "pi_lo", "pi_up")], umb2[[1]]$ma_results[, c("value", "p.value", "ci_lo", "ci_up", "pi_lo", "pi_up")],
               tolerance = 1e-3)
  expect_equal(umb1[[1]]$heterogeneity$i2,
               umb2[[1]]$heterogeneity$i2, tolerance = 1e-3)
  expect_equal(umb1[[1]]$esb$p.value, umb2[[1]]$esb$p.value,
               tolerance = 1e-3)
  expect_equal(umb1[[1]]$egger$p.value, umb2[[1]]$egger$p.value,
               tolerance = 1e-3)
})

test_that("different measures lead to similar results: IRR + SE + n_cases/time vs. IRR + CI + n_cases/time", {
  skip_on_cran()
  dfirr1 <- subset(df.IRR, select = -c(ci_lo, ci_up, n_cases_exp, n_cases_nexp, time_exp, time_nexp))
  dfirr2 <- subset(df.IRR, select = -c(ci_lo, ci_up, n_cases_exp, n_cases_nexp, time_exp, time_nexp))

  dfirr1$se = with(df.IRR, sqrt(1 / n_cases_exp + 1 / n_cases_nexp))
  dfirr2$ci_lo = dfirr1$value / exp(qnorm(0.975) * dfirr1$se)
  dfirr2$ci_up = dfirr1$value * exp(qnorm(0.975) * dfirr1$se)

  umb1 <- umbrella(dfirr1, seed = 4321, verbose = FALSE)
  umb2 <- umbrella(dfirr2, seed = 4321, verbose = FALSE)
  expect_equal(umb1[[1]]$ma_results[, c("value", "p.value", "ci_lo", "ci_up", "pi_lo", "pi_up")], umb2[[1]]$ma_results[, c("value", "p.value", "ci_lo", "ci_up", "pi_lo", "pi_up")],
               tolerance = 1e-10)
  expect_equal(umb1[[1]]$heterogeneity$i2, umb2[[1]]$heterogeneity$i2,
               tolerance = 1e-10)
  expect_equal(umb1[[1]]$esb$p.value, umb2[[1]]$esb$p.value,
               tolerance = 1e-10)
  expect_equal(umb1[[1]]$egger$p.value, umb2[[1]]$egger$p.value,
               tolerance = 1e-10)
})


### REVERSE ES ####

test_that("reverse : SMD", {
  skip_on_cran()
  dfsmd <- df.SMD; dfsmd$reverse_es <- "reverse"

  umb1 <- umbrella(dfsmd, verbose=FALSE)
  umb2 <- umbrella(df.SMD, verbose=FALSE)
  expect_equal(umb1[[1]]$ma_results[,1], -umb2[[1]]$ma_results[,1], tolerance = 1e-10)
  expect_equal(umb1[[1]]$ma_results[,3], umb2[[1]]$ma_results[,3], tolerance = 1e-10)
  expect_equal(umb1[[1]]$ma_results[,4], -umb2[[1]]$ma_results[,5], tolerance = 1e-10)
  expect_equal(umb1[[1]]$ma_results[,5], -umb2[[1]]$ma_results[,4], tolerance = 1e-10)
  expect_equal(umb1[[1]]$ma_results[,6], -umb2[[1]]$ma_results[,7], tolerance = 1e-10)
  expect_equal(umb1[[1]]$ma_results[,7], -umb2[[1]]$ma_results[,6], tolerance = 1e-10)
  expect_equal(umb1[[1]]$heterogeneity$i2, umb2[[1]]$heterogeneity$i2, tolerance = 1e-10)
  expect_equal(umb1[[1]]$egger$p.value, umb2[[1]]$egger$p.value, tolerance = 1e-10)
  expect_equal(umb1[[1]]$esb$p.value, umb2[[1]]$esb$p.value, tolerance = 1e-10)
})
test_that("reverse : MC", {
  skip_on_cran()
  dfsmd <- df.MC; dfsmd$reverse_es <- "reverse"

  umb1 <- umbrella(dfsmd, verbose=FALSE)
  umb2 <- umbrella(df.MC, verbose=FALSE)
  expect_equal(umb1[[1]]$ma_results[,1], -umb2[[1]]$ma_results[,1], tolerance = 1e-10)
  expect_equal(umb1[[1]]$ma_results[,3], umb2[[1]]$ma_results[,3], tolerance = 1e-10)
  expect_equal(umb1[[1]]$ma_results[,4], -umb2[[1]]$ma_results[,5], tolerance = 1e-10)
  expect_equal(umb1[[1]]$ma_results[,5], -umb2[[1]]$ma_results[,4], tolerance = 1e-10)
  expect_equal(umb1[[1]]$ma_results[,6], -umb2[[1]]$ma_results[,7], tolerance = 1e-10)
  expect_equal(umb1[[1]]$ma_results[,7], -umb2[[1]]$ma_results[,6], tolerance = 1e-10)
  expect_equal(umb1[[1]]$heterogeneity$i2, umb2[[1]]$heterogeneity$i2, tolerance = 1e-10)
  expect_equal(umb1[[1]]$egger$p.value, umb2[[1]]$egger$p.value, tolerance = 1e-10)
  expect_equal(umb1[[1]]$esb$p.value, umb2[[1]]$esb$p.value, tolerance = 1e-10)
})

test_that("reverse : R", {
  skip_on_cran()
  dfR <- df.R; dfR$reverse_es <- "reverse"

  umb1 <- .quiet(umbrella(dfR))
  umb2 <- .quiet(umbrella(df.R))
  expect_equal(umb1[[1]]$ma_results[,1], -umb2[[1]]$ma_results[,1], tolerance = 1e-10)
  expect_equal(umb1[[1]]$ma_results[,3], umb2[[1]]$ma_results[,3], tolerance = 1e-10)
  expect_equal(umb1[[1]]$ma_results[,4], -umb2[[1]]$ma_results[,5], tolerance = 1e-10)
  expect_equal(umb1[[1]]$ma_results[,5], -umb2[[1]]$ma_results[,4], tolerance = 1e-10)
  expect_equal(umb1[[1]]$ma_results[,6], -umb2[[1]]$ma_results[,7], tolerance = 1e-10)
  expect_equal(umb1[[1]]$ma_results[,7], -umb2[[1]]$ma_results[,6], tolerance = 1e-10)
  expect_equal(umb1[[1]]$heterogeneity$i2, umb2[[1]]$heterogeneity$i2, tolerance = 1e-10)
  expect_equal(umb1[[1]]$egger$p.value, umb2[[1]]$egger$p.value, tolerance = 1e-10)
  expect_equal(umb1[[1]]$esb$p.value, umb2[[1]]$esb$p.value, tolerance = 1e-10)
})

test_that("reverse: SMC", {
  skip_on_cran()
  dfsmcR <- df.SMC; dfsmcR$reverse_es <- "reverse"

  umb1 <- .quiet(umbrella(dfsmcR))
  umb2 <- .quiet(umbrella(df.SMC))
  expect_equal(umb1[[1]]$ma_results[,1], -umb2[[1]]$ma_results[,1], tolerance = 1e-10)
  expect_equal(umb1[[1]]$ma_results[,3], umb2[[1]]$ma_results[,3], tolerance = 1e-10)
  expect_equal(umb1[[1]]$ma_results[,4], -umb2[[1]]$ma_results[,5], tolerance = 1e-10)
  expect_equal(umb1[[1]]$ma_results[,5], -umb2[[1]]$ma_results[,4], tolerance = 1e-10)
  expect_equal(umb1[[1]]$ma_results[,6], -umb2[[1]]$ma_results[,7], tolerance = 1e-10)
  expect_equal(umb1[[1]]$ma_results[,7], -umb2[[1]]$ma_results[,6], tolerance = 1e-10)
  expect_equal(umb1[[1]]$heterogeneity$i2, umb2[[1]]$heterogeneity$i2, tolerance = 1e-10)
  expect_equal(umb1[[1]]$egger$p.value, umb2[[1]]$egger$p.value, tolerance = 1e-10)
  expect_equal(umb1[[1]]$esb$p.value, umb2[[1]]$esb$p.value, tolerance = 1e-10)
})

test_that("reverse : OR", {
  skip_on_cran()
  dfor <- df.OR; dfor$reverse_es <- "reverse"

  umb1 <- .quiet(umbrella(dfor, seed = 4321))
  umb2 <- .quiet(umbrella(df.OR, seed = 4321))
  expect_equal(umb1[[1]]$ma_results[,1], -umb2[[1]]$ma_results[,1], tolerance = 1e-10)
  expect_equal(umb1[[1]]$ma_results[,3], umb2[[1]]$ma_results[,3], tolerance = 1e-10)
  expect_equal(umb1[[1]]$ma_results[,4], -umb2[[1]]$ma_results[,5], tolerance = 1e-10)
  expect_equal(umb1[[1]]$ma_results[,5], -umb2[[1]]$ma_results[,4], tolerance = 1e-10)
  expect_equal(umb1[[1]]$ma_results[,6], -umb2[[1]]$ma_results[,7], tolerance = 1e-10)
  expect_equal(umb1[[1]]$ma_results[,7], -umb2[[1]]$ma_results[,6], tolerance = 1e-10)
  expect_equal(umb1[[1]]$heterogeneity$i2, umb2[[1]]$heterogeneity$i2, tolerance = 1e-10)
  expect_equal(umb1[[1]]$egger$p.value, umb2[[1]]$egger$p.value, tolerance = 1e-10)
  expect_equal(umb1[[1]]$esb$p.value, umb2[[1]]$esb$p.value, tolerance = 1e-10)
})

test_that("reverse : RR", {
  skip_on_cran()
  dfrr <- df.RR; dfrr$reverse_es <- "reverse"

  umb1 <- .quiet(umbrella(dfrr, seed = 4321))
  umb2 <- .quiet(umbrella(df.RR, seed = 4321))
  expect_equal(umb1[[1]]$ma_results[,1], -umb2[[1]]$ma_results[,1], tolerance = 1e-10)
  expect_equal(umb1[[1]]$ma_results[,3], umb2[[1]]$ma_results[,3], tolerance = 1e-10)
  expect_equal(umb1[[1]]$ma_results[,4], -umb2[[1]]$ma_results[,5], tolerance = 1e-10)
  expect_equal(umb1[[1]]$ma_results[,5], -umb2[[1]]$ma_results[,4], tolerance = 1e-10)
  expect_equal(umb1[[1]]$ma_results[,6], -umb2[[1]]$ma_results[,7], tolerance = 1e-10)
  expect_equal(umb1[[1]]$ma_results[,7], -umb2[[1]]$ma_results[,6], tolerance = 1e-10)
  expect_equal(umb1[[1]]$heterogeneity$i2, umb2[[1]]$heterogeneity$i2, tolerance = 1e-10)
  expect_equal(umb1[[1]]$egger$p.value, umb2[[1]]$egger$p.value, tolerance = 1e-10)
  expect_equal(umb1[[1]]$esb$p.value, umb2[[1]]$esb$p.value, tolerance = 1e-10)
})

test_that("reverse HR", {
  skip_on_cran()
  dfhr <- df.HR; dfhr$reverse_es <- "reverse"

  umb1 <- .quiet(umbrella(dfhr, seed = 4321))
  umb2 <- .quiet(umbrella(df.HR, seed = 4321))
  expect_equal(umb1[[2]]$ma_results[,1], -umb2[[2]]$ma_results[,1], tolerance = 1e-10)
  expect_equal(umb1[[2]]$ma_results[,3], umb2[[2]]$ma_results[,3], tolerance = 1e-10)
  expect_equal(umb1[[2]]$ma_results[,4], -umb2[[2]]$ma_results[,5], tolerance = 1e-10)
  expect_equal(umb1[[2]]$ma_results[,5], -umb2[[2]]$ma_results[,4], tolerance = 1e-10)
  expect_equal(umb1[[2]]$ma_results[,6], -umb2[[2]]$ma_results[,7], tolerance = 1e-10)
  expect_equal(umb1[[2]]$ma_results[,7], -umb2[[2]]$ma_results[,6], tolerance = 1e-10)
  expect_equal(umb1[[2]]$heterogeneity$i2, umb2[[2]]$heterogeneity$i2, tolerance = 1e-10)
  expect_equal(umb1[[2]]$egger$p.value, umb2[[2]]$egger$p.value, tolerance = 1e-10)
  expect_equal(umb1[[2]]$esb$p.value, umb2[[2]]$esb$p.value, tolerance = 1e-6)
})

test_that("reverse : IRR", {
  skip_on_cran()
  dfirr <- df.IRR; dfirr$reverse_es <- "reverse"

  umb1 <- .quiet(umbrella(dfirr, seed = 4321))
  umb2 <- .quiet(umbrella(df.IRR, seed = 4321))
  expect_equal(umb1[[1]]$ma_results[,1], -umb2[[1]]$ma_results[,1], tolerance = 1e-10)
  expect_equal(umb1[[1]]$ma_results[,3], umb2[[1]]$ma_results[,3], tolerance = 1e-10)
  expect_equal(umb1[[1]]$ma_results[,4], -umb2[[1]]$ma_results[,5], tolerance = 1e-10)
  expect_equal(umb1[[1]]$ma_results[,5], -umb2[[1]]$ma_results[,4], tolerance = 1e-10)
  expect_equal(umb1[[1]]$ma_results[,6], -umb2[[1]]$ma_results[,7], tolerance = 1e-10)
  expect_equal(umb1[[1]]$ma_results[,7], -umb2[[1]]$ma_results[,6], tolerance = 1e-10)
  expect_equal(umb1[[1]]$heterogeneity$i2, umb2[[1]]$heterogeneity$i2, tolerance = 1e-10)
  expect_equal(umb1[[1]]$egger$p.value, umb2[[1]]$egger$p.value, tolerance = 1e-10)
  expect_equal(umb1[[1]]$esb$p.value, umb2[[1]]$esb$p.value, tolerance = 1e-10)
})