test_that(".meta_to_umbrella_x correctly extracts information and produces appropriate error message when being called with inappropriate inputs", {
  df <- df.SMD
  # standard smd
  mcv = metaConvert::es_from_means_sd(
    mean_exp = df$mean_cases, mean_nexp = df$mean_controls,
    mean_sd_exp = df$sd_cases, mean_sd_nexp = df$sd_controls,
    n_exp = df$n_cases, n_nexp = df$n_controls,
  )
  df$value = mcv$g
  df$se = mcv$g_se

  metasmd <- meta::metacont(n_cases, mean_cases, sd_cases,
                             n_controls, mean_controls, sd_controls,
                             method.tau = "REML", data = df,
                             sm = "SMD", method.smd = "Hedges")

  res_metasmd <- .meta_to_umbrella_x(metasmd, n_cases = NULL, n_controls = NULL, measure = "SMD")
  expect_equal(metasmd$TE, res_metasmd$value,
               tolerance = 1e-10)
  expect_equal(metasmd$seTE, res_metasmd$se,
               tolerance = 1e-10)
  expect_equal(df$n_cases, res_metasmd$n_cases, tolerance = 1e-10)
  expect_equal(df$n_controls, res_metasmd$n_controls, tolerance = 1e-10)

  metasmd.C <- meta::metacont(n_cases, mean_cases, sd_cases,
                             n_controls, mean_controls, sd_controls,
                             method.tau = "REML", data = df,
                             sm = "SMD", method.smd = "Cohen")

  res_metasmd.C <- .meta_to_umbrella_x(metasmd.C, n_cases = NULL, n_controls = NULL, measure = "SMD")
  expect_equal(df$value, res_metasmd.C$value, tolerance = 1e-10)
  expect_equal(df$se, res_metasmd.C$se, tolerance = 1e-3)
  expect_equal(df$n_cases, res_metasmd.C$n_cases, tolerance = 1e-10)
  expect_equal(df$n_controls, res_metasmd.C$n_controls, tolerance = 1e-10)

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

  # standard OR
  metaor <- meta::metabin(event.e = n_cases_exp, n.e = n_exp,
                          event.c = n_cases_nexp, n.c = n_nexp,
                          data = dfor, sm = "OR", method.tau = "REML")

  res_metaor <- .meta_to_umbrella_x(metaor, n_cases = NULL, n_controls = NULL, measure = "OR")

  expect_equal(log(dfor$value), res_metaor$value, tolerance = 1e-10)
  expect_equal(dfor$se, res_metaor$se, tolerance = 1e-10)
  expect_equal(dfor$n_cases, res_metaor$n_cases, tolerance = 1e-10)
  expect_equal(dfor$n_controls, res_metaor$n_controls, tolerance = 1e-10)

  # unsupported measure
  metarr <- meta::metabin(event.e = n_cases_exp, n.e = n_exp,
                          event.c = n_cases_nexp, n.c = n_nexp,
                          data = df.RR, sm = "RR", method.tau = "REML")
  expect_error(.meta_to_umbrella_x(metarr, n_cases = NULL, n_controls = NULL, measure = "RR"),
               "The esb.test function can be called from a 'meta' object only with 'G', 'SMD' or 'OR' as effect size measures.",
               fixed = TRUE)

  # missing measure
  metagenor <- meta::metagen(TE = log(value), seTE = se, data = dfor, method.tau = "REML")
  expect_error(.meta_to_umbrella_x(metagenor,
                                   n_cases = df$n_cases,
                                   n_controls = df$n_controls,
                                   measure = NULL
                                   ),
               "The effect size measure should be indicated when calling the esb.test function from a meta object (via the 'sm' argument in the meta function or via the 'measure' argument of the esb.test function)",
               fixed = TRUE)

  # missing sample sizes
  metagenor <- meta::metagen(TE = log(value), seTE = se, data = dfor, sm = "OR", method.tau = "REML")
  #n_controls
  expect_error(.meta_to_umbrella_x(metagenor,
                                   n_cases = df$n_cases,
                                   n_controls = NULL
                                   ), "The number of controls should be indicated. You can do it when calling the meta function or when calling the esb.test function (via 'n_controls' argument)", fixed = TRUE)
  #n_cases
  expect_error(.meta_to_umbrella_x(metagenor,
                                   n_cases = NULL,
                                   n_controls = df$n_controls
                                   ), "The number of cases should be indicated. You can do it when calling the meta function or when calling the esb.test function (via 'n_cases' argument)", fixed = TRUE)
})

test_that(".meta_to_umbrella_x correctly extracts information from generic inputs: OR", {

  df <- subset(df.OR, factor == "ADHD")
  df$value <- with(df, .estimate_or_from_n(n_cases_exp, n_cases_nexp,
                                           n_controls_exp, n_controls_nexp)$value)
  df$se <- with(df, .estimate_or_from_n(n_cases_exp, n_cases_nexp,
                                        n_controls_exp, n_controls_nexp)$se)

  metagenor <- meta::metagen(TE = log(value), seTE = se, data = df, method.tau = "REML")

  resgen <- .meta_to_umbrella_x(metagenor,
                                n_cases = df$n_cases,
                                n_controls = df$n_controls,
                                measure = "OR")

  expect_equal(log(df$value), resgen$value)
  expect_equal(df$se,resgen$se)
  expect_equal(df$n_cases,resgen$n_cases)
  expect_equal(df$n_controls,resgen$n_controls)
  expect_equal(df$n_cases_exp,resgen$n_cases_exp)
  expect_equal(df$n_cases_nexp,resgen$n_cases_nexp)
  expect_equal(df$n_controls_exp,resgen$n_controls_exp)
  expect_equal(df$n_controls_nexp,resgen$n_controls_nexp)
})


###########
### RMA ###
###########

test_that(".rma_to_umbrella_x correctly extracts information and produces appropriate error message when being called with inappropriate inputs: SMD", {

  df <- df.SMD
  mcv = metaConvert::es_from_means_sd(
    mean_exp = df$mean_cases, mean_nexp = df$mean_controls,
    mean_sd_exp = df$sd_cases, mean_sd_nexp = df$sd_controls,
    n_exp = df$n_cases, n_nexp = df$n_controls,
  )
  df$value = mcv$g
  df$se = mcv$g_se
  es = metafor::escalc(
    m1i = mean_cases, m2i = mean_controls,
    sd1i = sd_cases, sd2i = sd_controls,
    n1i = n_cases, n2i = n_controls,
    data = df.SMD,
    vtype = "LS2", measure = "SMD",
    digits=11
  )
  # standard smd
  metasmd <- metafor::rma.uni(yi = es$yi, vi = es$vi, method = "REML")

  expect_error(.rma_to_umbrella_x(metasmd, n_cases = NULL, n_controls = NULL), "The number of cases or the number of controls should be indicated when calling the esb.test function from an 'rma' object. You can do it via the 'n_cases' or 'n_controls' arguments of the esb.test function.", fixed = TRUE)

  res_metasmd_ca <- .rma_to_umbrella_x(metasmd, n_cases = df$n_cases, n_controls = NULL, measure = "SMD")
  res_metasmd_co <- .rma_to_umbrella_x(metasmd, n_cases = NULL, n_controls = df$n_controls, measure = "SMD")

  expect_equal(df$value, res_metasmd_ca$value, tolerance = 1e-10)
  expect_equal(df$n_cases, res_metasmd_ca$n_cases, tolerance = 1e-10)
  expect_equal(df$n_controls, res_metasmd_ca$n_controls, tolerance = 1e-10)
  expect_equal(df$value, res_metasmd_co$value, tolerance = 1e-10)
  expect_equal(df$n_cases, res_metasmd_co$n_cases, tolerance = 1e-10)
  expect_equal(df$n_controls, res_metasmd_co$n_controls, tolerance = 1e-10)
  expect_equal(df$se, res_metasmd_ca$se, tolerance = 1e-10)
  expect_equal(df$se, res_metasmd_co$se, tolerance = 1e-10)
})

test_that(".rma_to_umbrella_x correctly extracts information and produces appropriate error message when being called with inappropriate inputs: OR", {
  df <- df.OR
  df$value <- with(df, .estimate_or_from_n(n_cases_exp, n_cases_nexp,
                                           n_controls_exp, n_controls_nexp)$value)
  df$se <- with(df, .estimate_or_from_n(n_cases_exp, n_cases_nexp,
                                        n_controls_exp, n_controls_nexp)$se)

  # standard OR
  metaor <- metafor::rma.uni(ai = n_cases_exp, bi = n_cases_nexp,
                             ci = n_controls_exp, di = n_controls_nexp,
                             data = df, method = "DL", measure = "OR")


  # unsupported measure
  metarr <- metafor::rma.uni(ai = n_cases_exp, bi = n_cases_nexp,
                             ci = n_controls_exp, di = n_controls_nexp,
                             data = df, method = "DL", measure = "RR")

  expect_error(.rma_to_umbrella_x(metarr, n_cases = df$n_cases, n_controls = df$n_controls, measure = "RR"),
               "The esb.test function can be called from an 'rma' or 'meta' object only with 'G', 'SMD' or 'OR' as effect size measure",
               fixed = TRUE)

  # missing measure
  metagenor <- metafor::rma.uni(yi = log(value), vi = se^2, data = df)
  expect_error(.rma_to_umbrella_x(metagenor,
                                   n_cases = df$n_cases,
                                   n_controls = df$n_controls,
                                  measure = NULL
  ), "The effect size measure should be indicated when calling the esb.test function from a rma object (via the 'measure' argument in the rma function or via the 'measure' argument of the esb.test function)",
  fixed = TRUE)

  # missing sample sizes
  metagenor <- metafor::rma.uni(yi = log(value), vi = se^2, data = df, measure = "OR")
  #n_controls
  expect_error(.meta_to_umbrella_x(metagenor,
                                   n_cases = df$n_cases,
                                   n_controls = NULL, measure = "OR"
  ), "The number of controls should be indicated. You can do it when calling the meta function or when calling the esb.test function (via 'n_controls' argument)", fixed = TRUE)
  #n_cases
  expect_error(.meta_to_umbrella_x(metagenor,
                                   n_cases = NULL,
                                   n_controls = df$n_controls, measure = "OR"
  ), "The number of cases should be indicated. You can do it when calling the meta function or when calling the esb.test function (via 'n_cases' argument)", fixed = TRUE)

  # missing sample sizes
  metagenor <- metafor::rma.uni(yi = log(value), vi = se^2, ni = df$n_cases + df$n_controls, data = df, measure = "OR")
  res_metaor_co <- .rma_to_umbrella_x(metaor,
               n_cases = NULL,
               n_controls = df$n_controls, measure = "OR")
  res_metaor_ca <- .rma_to_umbrella_x(metaor,
    n_controls = NULL,
    n_cases = df$n_cases, measure = "OR")
  res_metagenor_co <- .rma_to_umbrella_x(metagenor,
     n_cases = NULL,
     n_controls = df$n_controls, measure = "OR")
  res_metagenor_ca <- .rma_to_umbrella_x(metagenor,
       n_controls = NULL,
       n_cases = df$n_cases, measure = "OR")

  expect_equal(log(df$value), res_metaor_co$value, tolerance = 1e-10)
  expect_equal(df$se, res_metaor_co$se, tolerance = 1e-10)
  expect_equal(df$n_cases, res_metaor_co$n_cases, tolerance = 1e-10)
  expect_equal(df$n_controls, res_metaor_co$n_controls, tolerance = 1e-10)
  expect_equal(log(df$value), res_metaor_ca$value, tolerance = 1e-10)
  expect_equal(df$se, res_metaor_ca$se, tolerance = 1e-10)
  expect_equal(df$n_cases, res_metaor_ca$n_cases, tolerance = 1e-10)
  expect_equal(df$n_controls, res_metaor_ca$n_controls, tolerance = 1e-10)

  expect_equal(log(df$value), res_metagenor_co$value, tolerance = 1e-10)
  expect_equal(df$se, res_metagenor_co$se, tolerance = 1e-10)
  expect_equal(df$n_cases, res_metagenor_co$n_cases, tolerance = 1e-10)
  expect_equal(df$n_controls, res_metagenor_co$n_controls, tolerance = 1e-10)
  expect_equal(log(df$value), res_metagenor_ca$value, tolerance = 1e-10)
  expect_equal(df$se, res_metagenor_ca$se, tolerance = 1e-10)
  expect_equal(df$n_cases, res_metagenor_ca$n_cases, tolerance = 1e-10)
  expect_equal(df$n_controls, res_metagenor_ca$n_controls, tolerance = 1e-10)
})


test_that(".rma_to_umbrella_x correctly extracts information from generic inputs: OR", {

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

  metagenor <- metafor::rma(yi = log(value), sei = se, data = df)

  resgen <- .rma_to_umbrella_x(metagenor,
                                n_cases = df$n_cases,
                                n_controls = df$n_controls,
                                measure = "OR")

  expect_equal(log(df$value), resgen$value)
  expect_equal(df$se,resgen$se)
  expect_equal(df$n_cases,resgen$n_cases)
  expect_equal(df$n_controls,resgen$n_controls)

  expect_equal(df$n_cases,resgen$n_cases_nexp + resgen$n_cases_exp)
  expect_equal(df$n_controls,resgen$n_controls_nexp + resgen$n_controls_exp)
})

# select largest
test_that(".largest_smd wth N", {

  dfLARG <- df.SMD[1:5,]
  dfLARG$n_cases[1] <- dfLARG$n_cases[4]
  dfLARG$n_controls[1] <- dfLARG$n_controls[4]
  dfLARG$measure = "G"

  res = umbrella(dfLARG)[[1]]
  res$largest

  expect_equal(dfLARG$ci_lo[1], .as_numeric(res$largest[1]))
  expect_equal(dfLARG$ci_up[1], .as_numeric(res$largest[2]))
})

test_that("largest or with N", {
  dfOR <- df.OR[1:5,]

  res = umbrella(dfOR)[[1]]
  expect_equal(dfOR$ci_lo[2], exp(.as_numeric(res$largest[1])))
  expect_equal(dfOR$ci_up[2], exp(.as_numeric(res$largest[2])))
})



# CONVERSIONS BETWEEN MEASURES

# r to d

## R to SMD
test_that("correctly detects: R to SMD", {
  df.full.smd <- subset(df.SMD, factor == "Surgical")
  df.SMD.R <- subset(df.SMD, factor == "Surgical")
  df.5 <- df.full.smd[1:5,]

  df.SMD.R$value[1:5] = .d_to_r(df.5$value, n_cases = df.5$n_cases, n_controls = df.5$n_controls)
  df.SMD.R$se[1:5] = with(df.full.smd, (((n_cases[1:5]+n_controls[1:5])^2/(n_cases[1:5]*n_controls[1:5]))^2 * se[1:5]^2) / ((value[1:5]^2 + ((n_cases[1:5]+n_controls[1:5])^2/(n_cases[1:5]*n_controls[1:5])))^3))
  df.SMD.R$n_sample = NA
  df.SMD.R$n_sample[1:5] = with(df.full.smd, n_cases[1:5] + n_controls[1:5])

  df.SMD.R$measure[1:5] <- "R"
  expect_error(umbrella(df.SMD.R, seed = 4321),
               "'R' & 'Z' cannot be combined with other effect size measures within the same factor, and 'IRR'",
               fixed = TRUE)
})

## RR to OR: full information
test_that("RR to OR: full information", {
  df.save <- subset(df.OR, factor == "ASD")
  df <- subset(df.OR, factor == "ASD")

  mcv = metaConvert::es_from_2x2_sum(
    n_cases_exp = df$n_cases_exp[1:5], n_exp = df$n_exp[1:5],
    n_cases_nexp = df$n_cases_nexp[1:5], n_nexp = df$n_nexp[1:5]
  )
  df$value[1:5] <- exp(mcv$logrr)
  df$ci_lo[1:5] <- exp(mcv$logrr_ci_lo)
  df$ci_up[1:5] <- exp(mcv$logrr_ci_up)
  df$measure[1:5] <- "RR"

  umb1 <- umbrella(df, seed = 4321)
  umb2 <- umbrella(df.save, seed = 4321)
  expect_equal(umb1[[1]]$x$value[1:5], umb2[[1]]$x$value[1:5],
               tolerance = 1e-10)
  expect_equal(umb1$ASD$ma_results, umb2$ASD$ma_results,
               tolerance = 1e-10)
  expect_equal(umb1$ASD$esb$p.value, umb2$ASD$esb$p.value,
               tolerance = 1e-10)
})

## RR to OR: ES CI N_cases
test_that("RR to OR: ES CI N_cases", {
  df.full.OR <- subset(df.OR, factor == "ASD")
  df.OR.RR <- subset(df.OR, factor == "ASD")
  mcv = metaConvert::es_from_2x2_sum(
    n_cases_exp = df.full.OR$n_cases_exp[1:5], n_exp = df.full.OR$n_exp[1:5],
    n_cases_nexp = df.full.OR$n_cases_nexp[1:5], n_nexp = df.full.OR$n_nexp[1:5]
  )
  df.OR.RR$value[1:5] <- exp(mcv$logrr)
  df.OR.RR$ci_lo[1:5] <- exp(mcv$logrr_ci_lo)
  df.OR.RR$ci_up[1:5] <- exp(mcv$logrr_ci_up)
  df.OR.RR$measure[1:5] <- "RR"

  df.full.OR <- subset(df.full.OR, select = -c(n_exp, n_nexp, n_cases_exp, n_cases_nexp, n_controls_exp, n_controls_nexp))
  df.OR.RR <- subset(df.OR.RR, select = -c(n_exp, n_nexp, n_cases_exp, n_cases_nexp, n_controls_exp, n_controls_nexp))

  umb1 <- umbrella(df.full.OR, seed = 4321)
  umb2 <- umbrella(df.OR.RR, seed = 4321)
  expect_equal(umb1[[1]]$x$value[1:5],
               umb2[[1]]$x$value[1:5],
               tolerance = 5e-1)
  expect_equal(umb1$ASD$ma_results, umb2$ASD$ma_results, tolerance = 2e-1)
  expect_equal(umb1$ASD$esb$p.value, umb2$ASD$esb$p.value, tolerance = 2e-1)
})


## HR to OR
test_that("HR to OR", {
  df.save <- subset(df.OR, factor == "ASD")
  df <- subset(df.OR, factor == "ASD")
  df$measure[1:5] <- "HR"

  umb1 <- umbrella(df, seed = 4321)
  umb2 <- umbrella(df.save, seed = 4321)
  expect_equal(umb1[[1]]$x$value[1:5], umb2[[1]]$x$value[1:5], tolerance = 1e-10)
  expect_equal(umb1$ASD$ma_results, umb2$ASD$ma_results, tolerance = 1e-10)
  expect_equal(umb1$ASD$egger$p.value, umb2$ASD$egger$p.value, tolerance = 1e-10)
  expect_equal(umb1$ASD$esb$p.value, umb2$ASD$esb$p.value, tolerance = 1e-10)
})

## OR to SMD
test_that("OR to SMD correctly converted when value + CI", {
  df.full.smd <- subset(df.SMD, factor == "Surgical")
  df.mix.OR.SMD <- subset(df.SMD, factor == "Surgical")

  df.mix.OR.SMD$measure[1:5] <- "OR"

  mcv = metaConvert::es_from_cohen_d(
    cohen_d = df.full.smd$value,
    n_exp = df.full.smd$n_cases,
    n_nexp = df.full.smd$n_controls)

  mcv2 = metaConvert::es_from_or_ci(
    logor = mcv$logor,
    logor_ci_lo = mcv$logor_ci_lo,
    logor_ci_up = mcv$logor_ci_up,
    n_exp = df.full.smd$n_cases,
    n_nexp = df.full.smd$n_controls)


  df.mix.OR.SMD$value[1:5] <- exp(mcv$logor[1:5])
  df.mix.OR.SMD$ci_lo[1:5] <- exp(mcv$logor_ci_lo[1:5])
  df.mix.OR.SMD$ci_up[1:5] <- exp(mcv$logor_ci_up[1:5])
  df.mix.OR.SMD <- subset(df.mix.OR.SMD, select = -c(se, mean_cases, sd_cases, mean_controls, sd_controls))
  df.full.smd <- subset(df.full.smd, select = -c(se, mean_cases, sd_cases, mean_controls, sd_controls))
  x = df.mix.OR.SMD
  umb.mix.OR.SMD <- umbrella(df.mix.OR.SMD, seed = 4321)
  umb.full.smd <- umbrella(df.full.smd, seed = 4321)
  expect_equal(umb.mix.OR.SMD[[1]]$x$value[1:5],
               umb.full.smd[[1]]$x$value[1:5], tolerance = 1e-6)
  expect_equal(umb.mix.OR.SMD[[1]]$x$se[1:5],
               umb.full.smd[[1]]$x$se[1:5], tolerance = 1e-6)
  expect_equal(umb.mix.OR.SMD[[1]]$ma_results,
               umb.full.smd[[1]]$ma_results, tolerance = 1e-6)
  expect_equal(umb.mix.OR.SMD[[1]]$egger$p.value, umb.full.smd[[1]]$egger$p.value, tolerance = 0.5)
  expect_equal(umb.mix.OR.SMD[[1]]$esb$p.value, umb.full.smd[[1]]$esb$p.value, tolerance = 1e-3)
})

## OR to SMD
test_that("OR to SMD correctly converted when value + SE", {
  df.full.smd <- subset(df.SMD, factor == "Surgical")
  df.mix.OR.SMD <- subset(df.SMD, factor == "Surgical")


  mcv = metaConvert::es_from_cohen_d(
    cohen_d = df.full.smd$value,
    n_exp = df.full.smd$n_cases,
    n_nexp = df.full.smd$n_controls)

  mcv2 = metaConvert::es_from_or_ci(
    logor = mcv$logor,
    logor_ci_lo = mcv$logor_ci_lo,
    logor_ci_up = mcv$logor_ci_up,
    n_exp = df.full.smd$n_cases,
    n_nexp = df.full.smd$n_controls)

  df.mix.OR.SMD$value[1:5] <- exp(mcv$logor[1:5])
  df.mix.OR.SMD$se[1:5] <- mcv$logor_se[1:5]
  df.mix.OR.SMD$measure[1:5] <- "OR"

  df.mix.OR.SMD <- subset(df.mix.OR.SMD,
                          select = -c(ci_lo, ci_up, mean_cases, sd_cases, mean_controls, sd_controls))
  df.full.smd <- subset(df.full.smd,
                        select = -c(ci_lo, ci_up, mean_cases, sd_cases, mean_controls, sd_controls))
  umb.mix.OR.SMD <- umbrella(df.mix.OR.SMD, seed = 4321)
  umb.full.smd <- umbrella(df.full.smd, seed = 4321)

  expect_equal(umb.mix.OR.SMD[[1]]$x$value[1:5],
               umb.full.smd[[1]]$x$value[1:5], tolerance = 1e-6)
  expect_equal(umb.mix.OR.SMD[[1]]$x$se[1:5],
               umb.full.smd[[1]]$x$se[1:5], tolerance = 1e-6)

  expect_equal(umb.mix.OR.SMD[[1]]$ma_results, umb.full.smd[[1]]$ma_results, tolerance = 1e-10)
  expect_equal(umb.mix.OR.SMD[[1]]$egger$p.value, umb.full.smd[[1]]$egger$p.value, tolerance = 1e-10)
  expect_equal(umb.mix.OR.SMD[[1]]$esb$p.value, umb.full.smd[[1]]$esb$p.value, tolerance = 1e-10)
})

## SMD to OR
test_that("SMD to OR  correctly converted when value + CI", {
  df.full.OR <- subset(df.OR, factor == "ADHD")
  df.full.OR$se <- with(df.full.OR, .estimate_or_from_n(n_cases_exp, n_cases_nexp,
                                                        n_controls_exp, n_controls_nexp)$se)

  df.mix.OR.SMD <- subset(df.full.OR, factor == "ADHD")

  df.mix.OR.SMD$measure[1:5] <- "SMD"
  df.mix.OR.SMD$value[1:5] <- .or_to_d(df.mix.OR.SMD$value[1:5])
  df.mix.OR.SMD$se[1:5] = sqrt(df.mix.OR.SMD$se[1:5]^2 * 3 / (pi^2))
  df.mix.OR.SMD <- subset(df.mix.OR.SMD, select = -c(ci_lo, ci_up, n_cases_exp, n_cases_nexp))
  df.full.OR <- subset(df.full.OR, select = -c(ci_lo, ci_up, n_cases_exp, n_cases_nexp))

  x_conv = .convert_SMD_to_OR(attr(.check_data(df.mix.OR.SMD), "data"))

  expect_equal(x_conv$value[1:5], df.full.OR$value[1:5], tolerance = 1e-10)
  expect_equal(x_conv$se[1:5], df.full.OR$se[1:5], tolerance = 1e-10)
})

## SMD to SMC
test_that("SMC to SMC correctly converts: smd raw", {
  df.full.smd <- subset(df.SMD, factor == "Surgical")
  df.mix.SMC.SMD <- subset(df.SMD, factor == "Surgical")

  df.mix.SMC.SMD$measure[1:5] <- "SMC"

  df.mix.SMC.SMD <- subset(df.mix.SMC.SMD, select = -c(mean_cases, mean_controls))

  umb.mix.SMC.SMD <- .quiet(umbrella(df.mix.SMC.SMD, seed = 4321))
  umb.full.smd <- .quiet(umbrella(df.full.smd, seed = 4321))
  expect_equal(umb.mix.SMC.SMD[[1]]$x$value[1:5], umb.full.smd[[1]]$x$value[1:5], tolerance = 1e-10)
  expect_equal(umb.mix.SMC.SMD[[1]]$ma_results, umb.full.smd[[1]]$ma_results, tolerance = 1e-10)
  expect_equal(umb.mix.SMC.SMD[[1]]$egger$p.value, umb.full.smd[[1]]$egger$p.value, tolerance = 1e-10)
  expect_equal(umb.mix.SMC.SMD[[1]]$esb$p.value, umb.full.smd[[1]]$esb$p.value, tolerance = 1e-10)
})

test_that("SMC to SMC correctly converts: smc raw", {
  df.full.smc <- subset(df.SMC, factor == "Prediabetes")
  df.mix.SMC.SMD <- subset(df.SMC, factor == "Prediabetes")

  df.mix.SMC.SMD$measure[1:5] <- "SMD"

  df.mix.SMC.SMD <- subset(df.mix.SMC.SMD, select = -c(mean_cases,
                                                       mean_controls))

  umb.mix.SMC.SMD <- umbrella(df.mix.SMC.SMD, seed = 4321, verbose = FALSE)
  umb.full.smc <- umbrella(df.full.smc, verbose = FALSE, seed = 4321)

  row.names(umb.mix.SMC.SMD[[1]]$ma_results) = "X"
  row.names(umb.full.smc[[1]]$ma_results) = "X"

  expect_equal(umb.mix.SMC.SMD[[1]]$ma_results,
               umb.full.smc[[1]]$ma_results,
               tolerance = 1e-10)
  expect_equal(umb.mix.SMC.SMD[[1]]$egger$p.value,
               umb.full.smc[[1]]$egger$p.value, tolerance = 1e-10)
  ## ESB
  expect_equal(umb.mix.SMC.SMD[[1]]$esb$p.value,
               umb.full.smc[[1]]$esb$p.value, tolerance = 1e-10)
})

## ERREUR IRR
test_that("IRR to SMD", {
  df.save <- subset(df.SMD, factor == "Surgical")

  df.save$measure[1:5] <- "IRR"
  df.save$time <- NA; df.save$time[1:5] <- 1
  df.save$value[1:5] <- abs(df.save$value[1:5])
  df.save$ci_lo[1:5] <- 0.01
  df.save$ci_up[1:5] <- 5



  expect_error(umbrella(df.save))
})
### OVERLAP -------------
# test_that("IRR to SMD", {
#   skip_on_cran()
#   library(tidyverse)
#   dat = .quiet(df.radua2019 %>%
#     rowwise() %>%
#     group_by(factor) %>%
#     mutate(studyid = paste(author, year)) %>%
#     summarise(stud = unique(studyid)))
#
#   dat_age = subset(dat, factor=="Age")
#   dat_cum = subset(dat, factor=="Cumulative trauma")
#   dat_ethn = subset(dat, factor=="Ethnic minority")
#   dat_fem = subset(dat, factor=="Female")
#   dat_low = subset(dat, factor=="Low education")
#   dat_ses = subset(dat, factor=="Low SES")
#   dat_psy = subset(dat, factor=="Psychotic disorder")
#
#   ov = overlap.prim(umbrella(df.radua2019, mult.level=TRUE, verbose=FALSE))
#
#   expect_equal(sum(dat_age$stud %in% dat_cum$stud) / length(dat_age$stud),
#                as.numeric(as.character(ov$`Cumulative trauma`[1])))
#   expect_equal(round(sum(dat_age$stud %in% dat_ethn$stud) / length(dat_age$stud),3),
#                as.numeric(as.character(ov$`Ethnic minority`[1])))
#   expect_equal(round(sum(dat_age$stud %in% dat_fem$stud) / length(dat_age$stud),3),
#                as.numeric(as.character(ov$`Female`[1])))
#   expect_equal(round(sum(dat_age$stud %in% dat_low$stud) / length(dat_age$stud),3),
#                as.numeric(as.character(ov$`Low education`[1])))
#   expect_equal(round(sum(dat_age$stud %in% dat_ses$stud) / length(dat_age$stud),3),
#                as.numeric(as.character(ov$`Low SES`[1])))
#   expect_equal(round(sum(dat_age$stud %in% dat_psy$stud) / length(dat_age$stud),3),
#                as.numeric(as.character(ov$`Psychotic disorder`[1])))
#
#
#   expect_equal(sum(dat_cum$stud %in% dat_age$stud) / length(dat_cum$stud),
#                as.numeric(as.character(ov$`Age`[2])))
#   expect_equal(round(sum(dat_ethn$stud %in% dat_age$stud) / length(dat_ethn$stud),3),
#                as.numeric(as.character(ov$`Age`[3])))
#   expect_equal(round(sum(dat_fem$stud %in% dat_age$stud) / length(dat_fem$stud),3),
#                as.numeric(as.character(ov$`Age`[4])))
#   expect_equal(round(sum(dat_low$stud %in% dat_age$stud) / length(dat_low$stud),3),
#                as.numeric(as.character(ov$`Age`[5])))
#   expect_equal(round(sum(dat_ses$stud %in% dat_age$stud) / length(dat_ses$stud),3),
#                as.numeric(as.character(ov$`Age`[6])))
#   expect_equal(round(sum(dat_psy$stud %in% dat_age$stud) / length(dat_psy$stud),3),
#                as.numeric(as.character(ov$`Age`[7])))
#
# })