R/mts_tests.R

In MultiSEp: Predict Synthetic Lethality and Other Gene Dependency Relationships from Multiomics Data

globalVariables(c("depMapTissue_subset", "depMapMUT_subset", "depMapXPR_subset",
                  "multisepList", "multisepCrisprList", "mixModelClusters_depMapXPR",
                  "MUT_impactMatrix", ".", "mixModelClusters_depMapCRISPR", "depMapCRISPRscores_subset", "depMapXPR_small", "depMapMUT_small", "mRes"))

mts_tests <- function(mode = c("All", "Demo"), cores = 1) {
  if (missing(mode))
    stop("ERROR: please specify the mode ('Demo' or 'All')")
  if (cores < 1)
    stop("cores should be >= 1")

  test_results <- list()
  test_idx <- 1

  capture_test <- function(desc, expr) {
    result <- tryCatch({
      test_that(desc, expr)
      TRUE
    }, error = function(e) {
      FALSE
    })
    test_results[[desc]] <<- ifelse(result, "Passed", "Failed")
  }

  if (mode == "Demo") {
    capture_test("mts_mixModelCluster() returns a vector with the specified length", {
      multisepOutput <- mts_mixModelCluster(dataMatrix = depMapXPR_subset[1:2,], cores = cores)
      expect_length(multisepOutput, 2)
    })

    capture_test("using a gene expression without log2 transformed values gives an output", {
      eDF_inverse <- 2^depMapXPR_subset
      expect_output(mts_mixModelCluster(dataMatrix = depMapXPR_subset[1:5,], cores = cores))
    })

  } else if (mode == "All") {

    # mts_mixModelCluster ------
    capture_test("mts_mixModelCluster() returns a vector with the specified length", {
      multisepOutput <- mts_mixModelCluster(dataMatrix = depMapXPR_subset[1:2,], cores = cores)
      expect_length(multisepOutput, 2)
    })

    capture_test("using a gene expression without log2 transformed values gives an output", {
      eDF_inverse <- 2^depMapXPR_subset
      expect_output(mts_mixModelCluster(dataMatrix = depMapXPR_subset[1:5,], cores = cores))
    })

    capture_test("function an output for negative gene expression values", {
      numeric_cols <- sapply(depMapXPR_subset, is.numeric)
      negative_eDF <- depMapXPR_subset
      negative_eDF[, numeric_cols] <- -negative_eDF[, numeric_cols]
      expect_output(mts_mixModelCluster(dataMatrix = negative_eDF[1:5,], cores = cores))
    })

    capture_test("the mts_mixModelCluster() returns the desired output", {
      multisepOutput <- mts_mixModelCluster(dataMatrix = depMapXPR_subset[1:2,], cores = cores)
      expect_type(multisepOutput[[1]][,1], "character")
      expect_type(multisepOutput[[1]][,2], "double")
      expect_type(multisepOutput[[1]][,3], "integer")
    })


    capture_test("mts_mixModelCluster returns an error when 0 is passed to the cores argument", {
      expect_error(mts_mixModelCluster(dataMatrix = depMapXPR_subset[1:5,], cores = 0), "cores should be >= 1")
    })


    capture_test("mts_mixModelCluster returns an object inherited from the expected base type, list", {
      multisepOutput <- mts_mixModelCluster(dataMatrix = depMapXPR_subset[1:1,], cores = cores)
      expect_type(multisepOutput, "list")
    })

    capture_test("the function gives an error when a gene expression matrix is not provided", {
      expect_error(mts_mixModelCluster())
    })


    capture_test("NA values in gene expression matrix gives an output with mts_mixModelCluster()", {
      df = depMapXPR_subset[1:10,]
      df[df ==0] <- NA
      expect_output(mts_mixModelCluster(dataMatrix = df), cores = cores)
    })

    capture_test("0 values as the gene expression matrix gives an output", {
      df2 <- replace(depMapXPR_subset[1:10,], 1:50, "0")
      expect_output(mts_mixModelCluster(dataMatrix = df2), cores = cores)
    })

    capture_test("mts_mixModelCluster can produce clusters for various data types", {
      expect_no_error(mts_mixModelCluster(dataMatrix = depMapCRISPRscores_subset[1:2,], cores = cores)) # check it can default
      expect_no_error(mts_mixModelCluster(dataMatrix = depMapMUT_subset[1:2,], cores = cores)) # check it can default
      expect_no_error(mts_mixModelCluster(dataMatrix = depMapXPR_subset[1:2,], cores = cores)) # check it can default
    })

    # mts_mixModelCluster_XPR() ------
    capture_test("mts_mixModelCluster_XPR returns an object inherited from the expected base type, list", {
      multisepOutput <- mts_mixModelCluster_XPR(dataMatrix = depMapXPR_subset[1:1,],
                                                GeneXPRthresh = 3.321928,
                                                NumSampleThresh = 20,
                                                cores = cores)
      expect_type(multisepOutput, "list")
    })

    capture_test("NA values in gene expression matrix gives an output with mts_mixModelCluster_XPR", {
      df = depMapXPR_subset[1:10,]
      df[df ==0] <- NA
      expect_output(mts_mixModelCluster_XPR(dataMatrix = df,
                                            GeneXPRthresh = 3.321928,
                                            NumSampleThresh = 20,
                                            cores = cores))
    })

    capture_test("mts_mixModelCluster_XPR() returns a vector with the specified length", {
      multisepOutput <- mts_mixModelCluster_XPR(dataMatrix = depMapXPR_subset[1:2,], cores = cores)
      expect_length(multisepOutput, 2)
    })

    # mts_clusterAvg() ------
    multisepOutputFull <- mts_clusterAvg(exprsMatrix = depMapXPR_subset[1:4,], crisprMatrix = depMapCRISPRscores_subset, cores = cores)

    capture_test("mts_clusterAvg returns an object inherited from the expected base type, list", {
      expect_type(multisepOutputFull, (class = "list"))
    })



    capture_test("an output is given for a crispr score matrix with 0 values", {
      crispr_0value = replace(depMapCRISPRscores_subset, 1:50, 0)
      expect_output(mts_clusterAvg(exprsMatrix = depMapXPR_subset[1:10,], crisprMatrix = crispr_0value, cores = cores))
    })


    capture_test("the code returns an error when a crispr score matrix is not passed to the crisprMatrix argument and matches the error message", {
      expect_error(mts_clusterAvg(exprsMatrix = depMapXPR_subset[1:10,], crisprMatrix = , cores = cores), "No CRISPR Matrix Provided")
    })


    capture_test("the code returns an error when an invalid value is given to cores argument", {
      expect_error(mts_clusterAvg(exprsMatrix = depMapXPR_subset[1:5,], crisprMatrix = depMapCRISPRscores_subset, cores=0), "cores should be >= 1")
    })

    capture_test("the code returns an error when an expression matrix is not provided and matches the error message", {
      expect_error(mts_clusterAvg(crisprMatrix = depMapCRISPRscores_subset), "No Expression Matrix Provided: A gene by sample matrix is required to invoke this function")
    })

    capture_test("mts_clusterAvg gives expected output", {
      expect_no_error(mts_clusterAvg(exprsMatrix = depMapXPR_subset[1:5,], crisprMatrix = depMapCRISPRscores_subset, cores = cores))
    })

    # mts_crisprPartition() ------
    capture_test("function can handle missing values", {
      df <- depMapCRISPRscores_subset[1:5, ]
      df[1, 1] <- NA
      expect_no_error(mts_crisprPartition(dataMatrix = df, cores = cores))
    })

    capture_test("function can handle zero values", {
      df <- depMapCRISPRscores_subset[1:5, ]
      df[,] <- 0
      expect_no_error(mts_crisprPartition(dataMatrix = df, cores = cores))
    })


    capture_test("invalid cores argument gives informative error", {
      expect_error(mts_crisprPartition(dataMatrix = depMapCRISPRscores_subset[1:5, ], cores = 0))
    })

    capture_test("output contains expected column names for a known gene", {
      result <- mts_crisprPartition(dataMatrix = depMapCRISPRscores_subset[1:2, ], cores = 1)
      expect_named(result$EIF1AX, c("Sample", "Values", "Cluster_Assignment"))
    })

    capture_test("missing dataMatrix argument returns an error", {
      expect_error(mts_crisprPartition(), "No Matrix Provided")
    })

    capture_test("returns a list with character and integer types in expected columns", {
      result <- mts_crisprPartition(dataMatrix = depMapCRISPRscores_subset[1:2, ], cores = 1)
      expect_type(result[[1]]$Sample, "character")
      expect_type(result[[1]]$Values, "double")
      expect_type(result[[1]]$Cluster_Assignment, "double")
    })

    # mts_plotCRISPRGeneCluster ------
    clusters_depMapXPR <- mts_mixModelCluster(
      dataMatrix = depMapXPR_subset[1:15,],
      cores = cores
    )
    capture_test("the code returns an error when a crispr score matrix is not provided and matches the error message", {
      expect_error(mts_plotCRISPRGeneCluster(resultList =, plotType = "mrna_only"))
      expect_error(mts_plotCRISPRGeneCluster(resultList = multisepOutputFull, mrna_gene="EIF1A",   crispr_gene = "NMT1",
                                             crisprMatrix= depMapCRISPRscores_subset, tissueMatrix=depMapTissue_subset,
                                             plotType = "Integrated"), "EIF1A is not in supplied result list")
      expect_error(mts_plotCRISPRGeneCluster(resultList = multisepOutputFull, mrna_gene="EIF1AY",   crispr_gene = "NM1",
                                             crisprMatrix= depMapCRISPRscores_subset, tissueMatrix=depMapTissue_subset,
                                             plotType = "Integrated"), "NM1 is not in supplied crispr matrix")
      expect_error(mts_plotCRISPRGeneCluster(resultList = multisepOutputFull, mrna_gene="EIF1AY",   crispr_gene = "NMT1",
                                             crisprMatrix= , tissueMatrix=depMapTissue_subset,
                                             plotType = "Integrated"), "No CRISPR Matrix Provided")
      expect_error(mts_plotCRISPRGeneCluster(resultList = multisepOutputFull, mrna_gene="EIF1AY",   crispr_gene = "NMT1",
                                             crisprMatrix=depMapCRISPRscores_subset,
                                             plotType = "Integrated"))
      expect_error(mts_plotCRISPRGeneCluster(mrna_gene="EIF1AY",   crispr_gene = "NMT1",
                                             crisprMatrix=depMapCRISPRscores_subset, tissueMatrix=depMapTissue_subset,
                                             mixModelClustersXPR = clusters_depMapXPR,
                                             plotType = "integrated"), "Plot type is not recognised, please use 'Integrated', 'mrna_only' or 'crispr_only'")
    })


    capture_test("mts_plotCRISPRGeneCluster output follows no errors for running as intended", {
      expect_no_error(mts_plotCRISPRGeneCluster(resultList = multisepOutputFull, mrna_gene = "EIF1AY", crispr_gene = "NMT1",
                                                crisprMatrix= depMapCRISPRscores_subset, tissueMatrix=depMapTissue_subset,
                                                plotType = "Integrated"))
      expect_no_error(mts_plotCRISPRGeneCluster(resultList = multisepOutputFull, mrna_gene = "EIF1AY", crispr_gene = "NMT1",
                                                crisprMatrix= depMapCRISPRscores_subset, tissueMatrix=depMapTissue_subset,
                                                plotType = "mrna_only"))
      expect_no_error(mts_plotCRISPRGeneCluster(resultList = multisepOutputFull, mrna_gene = "EIF1AY", crispr_gene = "NMT1",
                                                crisprMatrix= depMapCRISPRscores_subset, tissueMatrix=depMapTissue_subset,
                                                plotType = "crispr_only"))
      expect_no_error(mts_plotCRISPRGeneCluster(resultList = multisepOutputFull, mrna_gene = "RPP25", crispr_gene = "DNAJC19",
                                                crisprMatrix= depMapCRISPRscores_subset, tissueMatrix=depMapTissue_subset,
                                                plotType = "crispr_only"))
      expect_no_error(mts_plotCRISPRGeneCluster(resultList = multisepOutputFull, mrna_gene = "EIF1AY", crispr_gene = "EIF1AX",
                                                crisprMatrix= depMapCRISPRscores_subset, tissueMatrix=depMapTissue_subset,
                                                plotType = "mrna_only"))
      expect_no_error(mts_plotCRISPRGeneCluster(resultList = multisepOutputFull, mrna_gene = "EIF1AY", crispr_gene = "EIF1AX",
                                                crisprMatrix= depMapCRISPRscores_subset, tissueMatrix=depMapTissue_subset,
                                                plotType = "Integrated"))
      expect_no_error(mts_plotCRISPRGeneCluster(mrna_gene = "DNAJC15", crispr_gene = "DNAJC19", crisprMatrix = depMapCRISPRscores_subset,
                                                tissueMatrix = depMapTissue_subset, mixModelClustersXPR = clusters_depMapXPR, plotType = "Integrated"
      ))
    })


    capture_test("the object returned by the mts_plotCRISPRGeneCluster() match expected plot attributes", {
      crispr_plot = mts_plotCRISPRGeneCluster(resultList = multisepOutputFull, mrna_gene = "RPP25", crispr_gene = "DNAJC19",
                                              crisprMatrix= depMapCRISPRscores_subset, tissueMatrix=depMapTissue_subset,
                                              plotType = "crispr_only")
      expect_equal(crispr_plot$labels$title, c("DNAJC19 CRISPR score coloured by RPP25 expression cluster"))
      expect_equal(crispr_plot$labels$x, c("Sample"))
      expect_equal(crispr_plot$labels$y, c("DNAJC19 CRISPR Score"))

      mrna_plot = mts_plotCRISPRGeneCluster(resultList = multisepOutputFull, mrna_gene = "RPP25", crispr_gene = "DNAJC19",
                                            crisprMatrix= depMapCRISPRscores_subset, tissueMatrix=depMapTissue_subset,
                                            plotType = "mrna_only")

      expect_equal(mrna_plot$labels$title, c("RPP25 density split by MultiSEp cluster"))
      expect_equal(mrna_plot$labels$x, c("RPP25 log2 mRNA Expression"))
      expect_equal(mrna_plot$labels$y, c("Density"))

    })


    capture_test("mts_plotCRISPRGeneCluster returns an object inherited from the expected base type, list", {
      crispr_plot2 = mts_plotCRISPRGeneCluster(resultList = multisepOutputFull, mrna_gene = "RPP25", crispr_gene = "DNAJC19",
                                               crisprMatrix= depMapCRISPRscores_subset, tissueMatrix=depMapTissue_subset,
                                               plotType = "crispr_only")
      expect_true(inherits(crispr_plot2, "ggplot"))
    })

    # mts_Crispr ------
    capture_test("mts_Crispr returns an object inherited from the expected base type, list", {
      mCrisprOut <- mts_Crispr(resultList = multisepOutputFull,
                               exprsMatrix = depMapXPR_subset[1:5,], crisprMatrix = depMapCRISPRscores_subset, cores = cores)
      expect_type(mCrisprOut, (class = "list"))
    })


    capture_test("mts_Crispr returns informative errors for incorrect input", {
      expect_error(mts_Crispr(resultList = multisepOutputFull,
                              exprsMatrix = depMapXPR_subset[1:10,]), "No CRISPR Matrix Provided")
      expect_error(mts_Crispr(exprsMatrix = depMapXPR_subset[1:10,], crisprMatrix = depMapCRISPRscores_subset))
      expect_error(mts_Crispr(resultList = multisepOutputFull,
                              exprsMatrix = , crisprMatrix = depMapCRISPRscores_subset), "No Expression Matrix Provided")
      expect_error(mts_Crispr(resultList = multisepOutputFull,
                              exprsMatrix = depMapXPR_subset[1:10,], crisprMatrix = depMapCRISPRscores_subset, cores = 0), "cores should be >= 1")
    })


    capture_test("the code returns an output for a crispr score matrix of 0 values", {
      crispr_0value = replace(depMapCRISPRscores_subset, 1:50, 0)
      expect_output(mts_Crispr(resultList = multisepOutputFull,
                               exprsMatrix = depMapXPR_subset[1:10,], crisprMatrix = crispr_0value, cores = cores))
    })


    capture_test("by either specifying the fcVal and pVal or leaving as default, will return equal result", {
      mCrisprOut_t5 <- mts_Crispr(resultList = multisepOutputFull,
                                  exprsMatrix = depMapXPR_subset[1:5,], crisprMatrix = depMapCRISPRscores_subset, fcVal= -0.1, pVal = 0.1, cores = cores)
      mCrisprOut <- mts_Crispr(resultList = multisepOutputFull,
                               exprsMatrix = depMapXPR_subset[1:5,], crisprMatrix = depMapCRISPRscores_subset, cores = cores)
      expect_equal(mCrisprOut_t5, mCrisprOut)
    })


    capture_test("changing the gene number will match the expression gene result", {
      resultList1 <- mts_clusterAvg(exprsMatrix = depMapXPR_subset[1:2,], crisprMatrix = depMapCRISPRscores_subset, cores = cores) # to specify two expression gene results
      mCrisprOut_t6 <- mts_Crispr(resultList = resultList1,
                                  exprsMatrix = depMapXPR_subset[1:2,], crisprMatrix = depMapCRISPRscores_subset, fcVal= -0.1, pVal = 0.1, cores = cores)
      mCrisprOut_t7 <- mts_Crispr(resultList = resultList1,
                                  exprsMatrix = depMapXPR_subset[1:2,], crisprMatrix = depMapCRISPRscores_subset, fcVal= -0.1, pVal = 0.1, cores = cores)
      expect_equal(mCrisprOut_t6, mCrisprOut_t7)
    })

    capture_test("mts_Crispr output follows no errors for running as intended", {
      expect_no_error(mts_Crispr(resultList  = multisepList[1:3],
                                 exprsMatrix = depMapXPR_subset,
                                 crisprMatrix = depMapCRISPRscores_subset, cores = cores))
      expect_no_error(mts_Crispr(resultList = multisepList[1:3],
                                 exprsMatrix = depMapXPR_subset,
                                 crisprMatrix = depMapCRISPRscores_subset, fcVal = 0.1, pVal = 0.25, cores = cores))
    })

    capture_test("mts_Crispr correctly handles numeric effect size threshold for bidirectional analysis", {
      result <- mCrisprOut <- mts_Crispr(
        resultList = multisepList[1:3],
        exprsMatrix = depMapXPR_subset,
        crisprMatrix = depMapCRISPRscores_subset,
        fcVal = -0.1,
        pVal = 0.1
      )
      expect_s3_class(result, "data.frame")
    })


    ### mts_CrisprTS(): Tissue data ------
    mCrisprOut <- mts_Crispr(resultList = multisepOutputFull,
                             exprsMatrix = depMapXPR_subset[1:5,], crisprMatrix = depMapCRISPRscores_subset, cores = cores)
    capture_test("the two objects match using the default fcVal and pVal values in the ?mts_CrisprTS() documentation", {
      # mts_clusterAvg ->  mts_Crispr -> mts_CrisprTS
      mCrisprTS <- mts_CrisprTS(resultList = multisepOutputFull,
                                crisprMatrix = depMapCRISPRscores_subset, tissueMatrix = depMapTissue_subset, fcVal = -0.1,
                                pVal = 0.25, allDisRes = mCrisprOut, cores = cores) # allDisRes = mts_Crispr

      mCrisprTS_test <- mts_CrisprTS(resultList = multisepOutputFull,
                                     crisprMatrix = depMapCRISPRscores_subset, tissueMatrix = depMapTissue_subset, allDisRes = mCrisprOut, cores = cores)
      expect_equal(mCrisprTS, mCrisprTS_test)
    })

    capture_test("mts_CrisprTS output follows no errors for running as intended", {
      expect_no_error(mts_CrisprTS(resultList = multisepList, crisprMatrix = depMapCRISPRscores_subset,
                                   tissueMatrix = depMapTissue_subset, fcVal = -0.1, pVal = 0.25, allDisRes = multisepCrisprList[1:5,], cores = cores))
      expect_no_error(mts_CrisprTS(resultList = multisepList,
                                   crisprMatrix = depMapCRISPRscores_subset, tissueMatrix = depMapTissue_subset,
                                   allDisRes = multisepCrisprList[4:10,], cores = cores))
    })


    capture_test("mts_CrisprTS code returns informative error messages when invalid arguments are passed to the function", {
      expect_error(mts_CrisprTS(crisprMatrix = depMapCRISPRscores_subset, tissueMatrix = depMapTissue_subset, fcVal = -0.1,
                                pVal = 0.25, allDisRes = mCrisprOut), "No MultiSEp results list provided - please run mts_clusterAvg to generate")
      expect_error(mts_CrisprTS(resultList = multisepOutputFull,
                                crisprMatrix = , tissueMatrix = depMapTissue_subset, fcVal = -0.1,
                                pVal = 0.25, allDisRes = mCrisprOut), "No CRISPR Matrix Provided")
      expect_error(mts_CrisprTS(resultList = multisepOutputFull,
                                crisprMatrix = depMapCRISPRscores_subset, tissueMatrix =, fcVal = -0.1,
                                pVal = 0.25, allDisRes = mCrisprOut), "No tissue matrix provided")
      expect_error(mts_CrisprTS(resultList = multisepOutputFull,
                                crisprMatrix = depMapCRISPRscores_subset, tissueMatrix =depMapTissue_subset, fcVal = -0.1,
                                pVal = 0.25, allDisRes = ), "No multisep-crispr result table provided - please run mts_Crispr to generate")
    })

    copyT = depMapTissue_subset
    colnames(depMapTissue_subset) = c("samples", "diseaseType")

    capture_test("mts_CrisprTS can handle a tissueMatrix with different column names", {
      mCrisprTS <- mts_CrisprTS(resultList = multisepList,crisprMatrix = depMapCRISPRscores_subset,
                                tissueMatrix = copyT,fcVal = -0.1, pVal = 0.25, allDisRes = multisepCrisprList[1:5,], cores = cores)
      mCrisprTS <- mts_CrisprTS(resultList = multisepList, crisprMatrix = depMapCRISPRscores_subset,
                                tissueMatrix = depMapTissue_subset,fcVal = -0.1, pVal = 0.25, allDisRes = multisepCrisprList[1:5,], cores = cores)
      expect_equal(mCrisprTS, mCrisprTS)
    })

    ### mts_Mutation ------
    mixModelClusters <- mts_mixModelCluster(dataMatrix = depMapXPR_subset[1:5,])

    capture_test("mts_Mutation() returns informative error messages when invalid arguments are passed to the function", {
      expect_error(mts_Mutation(resultList = ,mutMatrix = depMapMUT_subset, tissueMatrix = depMapTissue_subset, pVal = 0.01))
      expect_error(mts_Mutation(resultList = mixModelClusters_depMapXPR, mutMatrix = ,  tissueMatrix = depMapTissue_subset,  pVal = 0.01), "No Mutation Matrix Provided")
      expect_error(mts_Mutation(resultList = NULL, mutMatrix = depMapMUT_subset, pVal = 0.01))
    })

    capture_test("mts_Mutation gives expected output", {
      expect_no_error(mts_Mutation(resultList = mixModelClusters_depMapXPR, mutMatrix = depMapMUT_subset, tissueMatrix = depMapTissue_subset, pVal = 0.25, cores = cores))
      expect_no_error(mts_Mutation(resultList = mixModelClusters_depMapXPR, mutMatrix = depMapMUT_subset, tissueMatrix = depMapTissue_subset, cores = cores))
      expect_no_error(mts_Mutation(resultList = mixModelClusters_depMapXPR, mutMatrix = depMapMUT_subset, cores = cores)) # can run without a tissueMatrix
    })

    capture_test("When the tissue matrix does not contain tissue and cell_line as the colnames then mts_Mutation() wont throw an error", {
      colnames(depMapTissue_subset) = c("sample", "disease")
      multisepMut_test <- mts_Mutation(resultList = mixModelClusters_depMapXPR,
                                       mutMatrix = depMapMUT_subset, tissueMatrix = depMapTissue_subset,
                                       pVal = 0.25, cores = cores)
      expect_no_error(multisepMut_test)
    })

    capture_test("the two objects match using the default pVal value in the ?multisepMutation() documentation and using different colnames in the tissue matrix ", {
      multisepMut_test1 = mts_Mutation(mixModelClusters_depMapXPR, depMapMUT_subset, depMapTissue_subset, pVal = 0.01, cores = cores)
      multisepMut_test2 = mts_Mutation(mixModelClusters_depMapXPR, depMapMUT_subset, copyT, cores = cores)
      expect_equal(multisepMut_test1, multisepMut_test2)
    })

    capture_test("the object returned by mts_Mutation() matches the expected column attributes and returns a vector with the specified length", {
      multisepMut_test1 = mts_Mutation(mixModelClusters_depMapXPR, depMapMUT_subset, copyT, pVal = 0.01, cores = cores)
      expect_named(multisepMut_test1, c('mRNA_gene', 'mutation_gene', 'tissue', 'chiSqPvalue', 'mutation_per_mode'))
      expect_length(multisepMut_test1, 5)
    })


    capture_test("an error is expected when a mutation score matrix with the columns and rows in different order is given to the function", {
      mDT_t = as.data.frame(t(depMapMUT_subset))
      expect_error(mts_Mutation(resultList = mixModelClusters,
                                mutMatrix = mDT_t,
                                pVal = 0.25))
    })


    capture_test("values are returned when using different pvalue threshold from default ", {
      expect_output(mts_Mutation(resultList = mixModelClusters,
                                 mutMatrix = depMapMUT_subset,
                                 pVal = 0.05, cores = cores))
    })


    ## plotMutation(): Mutation plots ------
    capture_test("mts_plotMutation code returns informative error messages when invalid arguments are passed to the function", {
      expect_error(mts_plotMutation(resultList = , mrna_gene = "PSMB8", mut_gene = "TP53",
                                    mutMatrix = depMapMUT_subset, tissueMatrix = depMapTissue_subset,
                                    diseaseFilter = "Pancreatic Cancer"), "No result list provided: A mts_clusterAvg result object is required to run this function")
      expect_error(mts_plotMutation(resultList = mixModelClusters, mrna_gene = "PSM8", mut_gene = "TP53",
                                    mutMatrix = depMapMUT_subset, tissueMatrix = depMapTissue_subset,
                                    diseaseFilter = "Pancreatic Cancer"), "PSM8 is not in supplied result list")

      expect_error(mts_plotMutation(resultList = mixModelClusters, mrna_gene = "EIF1AY", mut_gene = "T53",
                                    mutMatrix = depMapMUT_subset, tissueMatrix = depMapTissue_subset,
                                    diseaseFilter = "Pancreatic Cancer"), "T53 is not in supplied mutation matrix")
      expect_error(mts_plotMutation(resultList = mixModelClusters, mrna_gene = "EIF1AY", mut_gene = "TP53",
                                    mutMatrix = , tissueMatrix = depMapTissue_subset,
                                    diseaseFilter = "Pancreatic Cancer"), "No Mutation Matrix Provided")
      expect_error(mts_plotMutation(resultList = mixModelClusters, mrna_gene = "EIF1AY", mut_gene = "TP53",
                                    mutMatrix = depMapMUT_subset, tissueMatrix = ,
                                    diseaseFilter = "Pancreatic Cancer"), "No Tissue Matrix Provided")
      expect_error(mts_plotMutation(resultList = mixModelClusters, mrna_gene = "EIF1AY", mut_gene = "TP53",
                                    mutMatrix = depMapMUT_subset, tissueMatrix = depMapTissue_subset,
                                    diseaseFilter = " Cancer"), "Disease Filter not recognised: please check")
    })


    capture_test("mts_plotMutation gives expected output", {
      expect_no_error(mts_plotMutation(resultList = mixModelClusters, mrna_gene = "RPP25", mut_gene = "TP53",
                                       mutMatrix = depMapMUT_subset, tissueMatrix = depMapTissue_subset,
                                       diseaseFilter = "Pancreatic Cancer"))
      expect_no_error(mts_plotMutation(resultList = mixModelClusters, mrna_gene = "RPP25", mut_gene = "TP53",
                                       mutMatrix = depMapMUT_subset, tissueMatrix = depMapTissue_subset))
      expect_no_error(mts_plotMutation(resultList = mixModelClusters, mrna_gene = "DNAJC15", mut_gene = "TP53",
                                       mutMatrix = depMapMUT_subset, tissueMatrix = depMapTissue_subset))
      expect_no_error(mts_plotMutation(resultList = mixModelClusters, mrna_gene = "DNAJC15", mut_gene = "TP53",
                                       mutMatrix = depMapMUT_subset, tissueMatrix = copyT)) # using different colnames
    })

    capture_test("mts_plotMutation returns desired object", {
      expect_visible(mts_plotMutation(resultList = mixModelClusters, mrna_gene = "RPP25", mut_gene = "TP53",
                                      mutMatrix = depMapMUT_subset, tissueMatrix = depMapTissue_subset,
                                      diseaseFilter = "Pancreatic Cancer"))
    })

    capture_test("mts_plotMutation returns desired plot object with expected attributes", {
      plotM = mts_plotMutation(resultList = mixModelClusters, mrna_gene = "RPP25", mut_gene = "TP53",
                               mutMatrix = depMapMUT_subset, tissueMatrix = depMapTissue_subset)
      expect_equal(plotM$labels$colour, c('Mutation Class'))
      expect_equal(plotM$labels$title, c('RPP25 Expression Cluster TP53 Enrichment'))
      expect_equal(plotM$labels$x, c('RPP25 mRNA Expression Cluster'))
      expect_equal(plotM$labels$y, c('RPP25 log2 mRNA Expression'))
    })

    capture_test("plot layers match expectations",{
      plotM = mts_plotMutation(resultList = mixModelClusters, mrna_gene = "RPP25", mut_gene = "TP53",
                               mutMatrix = depMapMUT_subset, tissueMatrix = depMapTissue_subset)
      expect_equal(class(plotM$layers[[1]]$stat), c("StatIdentity","Stat", "ggproto", "gg") )
      expect_equal(class(plotM$layers[[1]]$geom), c("GeomPoint","Geom", "ggproto", "gg") )
    })

    capture_test("Scale range is NULL",{
      plotM = mts_plotMutation(resultList = mixModelClusters, mrna_gene = "RPP25", mut_gene = "TP53",
                               mutMatrix = depMapMUT_subset, tissueMatrix = depMapTissue_subset)
      expect_null(plotM$scales$scales[[1]]$range$range)
    })

    capture_test("function returns an object from the expected base type, object", {
      expect_s3_class(mts_plotMutation(resultList = mixModelClusters, mrna_gene = "RPP25", mut_gene = "TP53",
                                   mutMatrix = depMapMUT_subset, tissueMatrix = depMapTissue_subset), "ggplot")
      expect_s3_class(mts_plotMutation(resultList = mixModelClusters, mrna_gene = "RPP25", mut_gene = "TP53",
                                   mutMatrix = depMapMUT_subset, tissueMatrix = depMapTissue_subset, diseaseFilter = "Bone Cancer"), "ggplot")
    })

    ## mts_targetCoverageFromMutations ------
    mDT <- mts_Mutation(resultList = mixModelClusters_depMapXPR,
                        mutMatrix = depMapMUT_subset, tissueMatrix = depMapTissue_subset,
                        pVal = 0.05, cores = cores)
    TpopCoverage_test <- mts_targetCoverageFromMutations(
      mutData=depMapMUT_subset,
      edgeData=mRes,
      rowNum=100,
      cores = cores
    )

    capture_test("mts_targetCoverageFromMutations returns the desired object with the expected column attributes", {
      expect_type(TpopCoverage_test$Gene, (class = "character"))
      expect_type(TpopCoverage_test$NeighbourCount, (class = "double"))
      expect_type(TpopCoverage_test$NumSamplesWithMutation, (class = "double"))
      expect_type(TpopCoverage_test$NeighbourMutationFrequency, (class = "double"))
      expect_type(TpopCoverage_test$NeighbourGenes, (class = "character"))
      expect_type(TpopCoverage_test$MutatedSamples, (class = "character"))
    })

    capture_test("mts_targetCoverageFromMutations code returns informative error messages when invalid arguments are passed to the function", {
      expect_error(mts_targetCoverageFromMutations(mutData=, edgeData=mRes, rowNum=10),"Please provide a mutation score matrix")
      expect_error(mts_targetCoverageFromMutations(mutData=mDT, edgeData=, rowNum=10),"Please provide edgeData")
    })

    capture_test("mts_targetCoverageFromMutations returns a data frame with expected length", {
      expect_s3_class(TpopCoverage_test, "data.frame")
      expect_equal(nrow(TpopCoverage_test), 80)
      expect_equal(ncol(TpopCoverage_test), 6)
    })

    ## mts_formatMatrix ------
    capture_test("mts_formatMatrix returns informative error messages when invalid arguments are passed to the function", {
      expect_error(mts_formatMatrix(matrix = NULL,  cores =1), "matrix must be a data frame")
      expect_error(mts_formatMatrix(matrix = MUT_impactMatrix,  cores =0), "cores should be >= 1")
    })

    capture_test("mts_formatMatrix gives expected output", {
      expect_no_error(mts_formatMatrix(matrix = MUT_impactMatrix, cores = cores))
    })

    ## mts_genepairsChunkGeneration ------
    capture_test("mts_genepairsChunkGeneration gives expected output", {
      expect_output(mts_genepairsChunkGeneration(mixModelClusters1 = mixModelClusters_depMapCRISPR, num_tasks = 1)) # check it can default
      expect_output(mts_genepairsChunkGeneration(mixModelClusters1 = mixModelClusters_depMapCRISPR, mixModelClusters2 = mixModelClusters_depMapXPR, num_tasks=1))
    })

    capture_test("mts_genepairsChunkGeneration returns informative error messages when invalid arguments are passed to the function", {
      expect_error(mts_genepairsChunkGeneration(mixModelClusters1 = , num_tasks = 1))
      expect_error(mts_genepairsChunkGeneration(mixModelClusters1 = NULL, mixModelClusters2 = mixModelClusters_depMapXPR, num_tasks=1))
      expect_error(mts_genepairsChunkGeneration(mixModelClusters1 = mixModelClusters, num_tasks="1"), 'Error: num_tasks value must be numeric and greater than 0.')
      expect_error(mts_genepairsChunkGeneration(mixModelClusters1 = mixModelClusters))
    })

    ## mts_plotClusterDistribution ------
    mixturemodelClusters <- mts_mixModelCluster_XPR(dataMatrix = depMapXPR_subset[1:50,], cores = cores)
    CRISPRmixModelClusters = mts_crisprPartition(dataMatrix = depMapCRISPRscores_subset[1:50,], cores = cores)

    capture_test("mts_plotClusterDistribution function can produce a plot for both log2 and inverse values cluster function can plot log and non values", {
      logT= lapply(mixModelClusters, function(dfG) {
        dfG[,2]=log(as.numeric(dfG[,2]))
        return(dfG)
      })
      expect_visible(mts_plotClusterDistribution(mixModelClusters = logT, gene1 = "NMT2",gene2 = "STX2"))
      expect_visible(mts_plotClusterDistribution(mixModelClusters = mixModelClusters, gene1 = "DNAJC15", gene2 = "NMT2"))
    })

    capture_test("mts_plotClusterDistribution gives expected output", {
      expect_no_error(mts_plotClusterDistribution(mixModelClusters = mixModelClusters_depMapXPR, gene1 = "EIF1AY", gene2="RPP25"))
      expect_no_error(mts_plotClusterDistribution(mixModelClusters = mixModelClusters_depMapCRISPR, gene1="RPP25L", gene2="NMT1"))
    })

    capture_test("mts_plotClusterDistribution returns informative error messages when invalid arguments are passed to the function", {
      expect_error(mts_plotClusterDistribution(mixModelClusters = NULL,gene1 = "EIF1AY",gene2 = "RPP25"))
      expect_error(mts_plotClusterDistribution(mixModelClusters = mixModelClusters_depMapXPR, gene1 = "EIF1AX", gene2 = "RPP25"), "EIF1AX is not in supplied in the mixModelClusters list")
      expect_error(mts_plotClusterDistribution(mixModelClusters = mixModelClusters_depMapCRISPR, gene1 = "EIF1AY", gene2 = "NMT1"))
    })

    capture_test("mts_plotClusterDistribution gives expected output for bidirectional analysis", {
      expect_visible(mts_plotClusterDistribution(mixModelClusters = mixturemodelClusters,mixModelClusters2 = CRISPRmixModelClusters,
                                                 gene1 = "ACSL1",gene2 = "PSMB5"))
    })

    capture_test("mts_plotClusterDistribution gives expected output for genes with differing cell line counts, applicable for CRISPR", {
      expect_visible(mts_plotClusterDistribution(mixModelClusters = CRISPRmixModelClusters,
                                                 gene1 = "EIF1AX",gene2 = "NMT1"))
    })

    Lung_Cancer_cellLines <- depMapTissue_subset$cell_line[
      depMapTissue_subset$tissue == "Lung Cancer"]
    Lung_Cancer_cellLines

    # 2. subset XPR mixture model result list
    LungCancer_XPRmixturemodelClusters <- lapply(mixturemodelClusters, function(GMM) {
      GMM[GMM$Sample %in% Lung_Cancer_cellLines, ]})
    length(LungCancer_XPRmixturemodelClusters[[1]][,3])

    # 3. subset CRISPR mixture model result list
    LungCancer_CRISPRmixModelClusters <- lapply(CRISPRmixModelClusters, function(GMM) {
      GMM[GMM$Sample %in% Lung_Cancer_cellLines, ]})
    length(LungCancer_CRISPRmixModelClusters[[1]][,3])

    capture_test("mts_plotClusterDistribution gives expected output for tissue specific analysis", {
      expect_visible(mts_plotClusterDistribution(mixModelClusters = mixturemodelClusters,mixModelClusters2 = CRISPRmixModelClusters,
                                                 gene1 = "ACSL1",gene2 = "PSMB5", TScluster1 = LungCancer_XPRmixturemodelClusters,
                                                 TScluster2 = LungCancer_CRISPRmixModelClusters))
    })

    ## mts_GeneDepCrispr ------
    capture_test("mts_GeneDepCrispr returns informative error messages when invalid arguments are passed to the function", {
      x = 1
      expect_error(mts_GeneDepCrispr(exprsMatrix = x, crisprMatrix =depMapCRISPRscores_subset[1:2,]),"exprsMatrix must be a data frame")
      expect_error(mts_GeneDepCrispr(exprsMatrix = depMapXPR_subset[1:2,], crisprMatrix =depMapCRISPRscores_subset[1:2,], tissueMatrix = 1), "tissueMatrix must be a data frame")
      expect_error(mts_GeneDepCrispr(exprsMatrix = ), "No Expression Matrix Provided")
      expect_error(mts_GeneDepCrispr(exprsMatrix = depMapXPR_subset[1:2,], crisprMatrix = ), "No CRISPR Matrix Provide")
    })

    capture_test("mts_GeneDepCrispr returns desired object and attributes", {
      y2= mts_GeneDepCrispr(exprsMatrix = depMapXPR_subset[1:5,], crisprMatrix =depMapCRISPRscores_subset[1:5,], tissueMatrix = depMapTissue_subset, cores = cores)
      expect_s3_class(y2$CRISPR_Results, "data.frame")
      expect_s3_class(y2$CRISPR_TS_Results, "data.frame")
      expect_type(y2$CRISPR_Results$mRNA_gene, "character")
      expect_length(y2$CRISPR_TS_Results, 26)
      expect_equal(nrow(y2$CRISPR_Results), 7)
    })

    capture_test("mts_GeneDepCrispr gives expected output", {
      expect_no_error(mts_GeneDepCrispr(exprsMatrix = depMapXPR_subset[1:5,], crisprMatrix = depMapCRISPRscores_subset[1:5,], cores = cores))
      expect_no_error(mts_GeneDepCrispr(exprsMatrix = depMapXPR_subset[1:5,], crisprMatrix =depMapCRISPRscores_subset[1:5,], tissueMatrix = depMapTissue_subset, cores = cores))
      expect_no_error(mts_GeneDepCrispr(exprsMatrix = depMapXPR_subset[1:5,], crisprMatrix = depMapCRISPRscores_subset[1:5,], tissueMatrix=copyT, cores = cores))
    })

    ## mts_GeneDepID ------
    capture_test("mts_GeneDepID gives expected output", {
      expect_no_error(mts_GeneDepID(exprsMatrix = depMapXPR_subset[1:5,], crisprMatrix = depMapCRISPRscores_subset[1:5,], cores = cores))
      expect_no_error(mts_GeneDepID(exprsMatrix = depMapXPR_subset[1:5,], crisprMatrix =depMapCRISPRscores_subset[1:5,], tissueMatrix = depMapTissue_subset, cores = cores))
      expect_no_error(mts_GeneDepID(exprsMatrix = depMapXPR_subset[1:5,], crisprMatrix =depMapCRISPRscores_subset[1:5,], tissueMatrix = copyT, cores = cores))
    })

    capture_test("mts_GeneDepID returns informative error messages when invalid arguments are passed to the function", {
      x = 1
      expect_error(mts_GeneDepID(exprsMatrix = x, crisprMatrix =depMapCRISPRscores_subset[1:2,]),"exprsMatrix must be a data frame")
      expect_error(mts_GeneDepID(exprsMatrix = depMapXPR_subset[1:2,], crisprMatrix =depMapCRISPRscores_subset[1:2,], tissueMatrix = 1), "tissueMatrix must be a data frame")
      expect_error(mts_GeneDepID(exprsMatrix = ), "No Expression Matrix Provided")
      expect_error(mts_GeneDepID(exprsMatrix = depMapXPR_subset[1:2,], crisprMatrix = ), "No CRISPR Matrix Provide")
    })

    capture_test("mts_GeneDepID returns desired object and expected attributes", {
      y= mts_GeneDepID(exprsMatrix = depMapXPR_subset[1:5,], crisprMatrix =depMapCRISPRscores_subset[1:5,], tissueMatrix = depMapTissue_subset, cores = cores)
      expect_s3_class(y$CRISPR_Results, "data.frame")
      expect_s3_class(y$CRISPR_TS_Results, "data.frame")
      expect_length(y$CRISPR_Results, 25)
      expect_length(y$CRISPR_TS_Results, 26)
    })

    ## mts_GeneDepMutation ------

    capture_test("mts_GeneDepMutation gives expected output", {
      expect_no_error(mts_GeneDepMutation(exprsMatrix = depMapXPR_subset[1:5,], mutMatrix = depMapMUT_subset, tissueMatrix=depMapTissue_subset, cores = cores))
      expect_no_error(mts_GeneDepMutation(exprsMatrix = depMapXPR_subset[1:5,], mutMatrix = depMapMUT_subset, tissueMatrix=copyT, cores = cores))
      expect_no_error(mts_GeneDepMutation(exprsMatrix = depMapXPR_subset[1:5,], mutMatrix = depMapMUT_subset, tissueMatrix=depMapTissue_subset, pVal = 0.01, cores = cores))
    })

    capture_test("mts_GeneDepMutation returns informative error messages when invalid arguments are passed to the function", {
      x = 1
      expect_error(mts_GeneDepMutation(exprsMatrix = x, mutMatrix =depMapMUT_subset[1:2,]),"exprsMatrix must be a data frame")
      expect_error(mts_GeneDepMutation(exprsMatrix = depMapXPR_subset[1:2,], mutMatrix =depMapMUT_subset[1:2,], tissueMatrix = 1), "tissueMatrix must be a data frame")
      expect_error(mts_GeneDepMutation(exprsMatrix = depMapXPR_subset[1:2,], mutMatrix =depMapMUT_subset[1:2,]), "No Tissue Matrix Provided")
    })

    capture_test("mts_GeneDepMutation returns desired object and expected attributes", {
      x= mts_GeneDepMutation(exprsMatrix = depMapXPR_subset[1:5,], mutMatrix =depMapMUT_subset[1:5,], tissueMatrix = depMapTissue_subset, cores = cores)
      expect_s3_class(x, "data.frame")
      expect_named(x, c("mRNA_Gene","mutation_gene","tissue","pvalue" , "mMode"))
      expect_type(x$mRNA_Gene, "character")
      expect_type(x$pvalue, "double")
    })

    # mts_patternDetection ------
    capture_test("mts_patternDetection returns informative error messages when invalid arguments are passed to the function", {
      x = 1
      # genepairs
      expect_error(mts_patternDetection(genepairs = x, mixModelClusters1 =mixModelClusters_depMapXPR))
      # GMM
      expect_error(mts_patternDetection(mixModelClusters1 = NULL))
      # SL
      expect_error(mts_patternDetection(mixModelClusters1 = mixModelClusters_depMapXPR, SyntheticLethalityPrediction = x ))
      # cores
      expect_error(mts_patternDetection(mixModelClusters1 = mixModelClusters_depMapXPR, cores = 0))
      # directionality
      expect_error(mts_patternDetection(mixModelClusters1 = mixModelClusters_depMapXPR, directionality = "none"))
      # effect size
      expect_error(mts_patternDetection(mixModelClusters1 = mixModelClusters_depMapXPR, effectsize_threshold = "Yes"))
    })

    capture_test("correctly handles numeric effect size threshold", {
      result <- mts_patternDetection(
        genepairs = data.frame(Gene1="PSMB8",Gene2="TTC7B"),
        mixModelClusters1 = mixturemodelClusters,
        effectsize_threshold = 0.5,
        p_adjustMethod = "BY",
        SyntheticLethalityPrediction = TRUE,
        cores = 1,
        verbose = FALSE
      )
      expect_s3_class(result, "data.frame")
    })

    capture_test("mts_patternDetection correctly handles numeric effect size threshold for bidirectional analysis", {
      result <- mts_patternDetection(
        mixModelClusters1 = mixturemodelClusters[1:10],
        mixModelClusters2 = CRISPRmixModelClusters[1:10],
        effectsize_threshold = 0.5,
        p_adjustMethod = "BY",
        SyntheticLethalityPrediction = TRUE,
        cores = cores,
        verbose = FALSE
      )
      expect_s3_class(result, "data.frame")
    })

    capture_test("correctly handles tissue specific analysis for both one directional and bidirectional analysis", {
      TS1 <- mts_patternDetection(mixModelClusters1 = LungCancer_CRISPRmixModelClusters,
                                  mixModelClusters2 = LungCancer_XPRmixturemodelClusters,
                                  include_reverse_pairs = T, verbose=F,
                                  effectsize_threshold = 0, SyntheticLethalityPrediction = T,
                                  directionality = "enrichment",
                                  qVal = 1)
      expect_s3_class(TS1, "data.frame")
      TS2 <- mts_patternDetection(mixModelClusters1 = LungCancer_XPRmixturemodelClusters,
                                  include_reverse_pairs = F, verbose=F,
                                  effectsize_threshold = 0, SyntheticLethalityPrediction = T,
                                  directionality = "enrichment",
                                  qVal = 1)
      expect_s3_class(TS2, "data.frame")
    })
    
    
    capture_test("mts_patternDetection gives expected output for genes with differing cell line counts, applicable for CRISPR", {
      x = mts_patternDetection(genepairs = data.frame(Gene1 = "EIF1AX", Gene2 = "NMT1"),
                               mixModelClusters1 = mixModelClusters_depMapCRISPR,
                               cores = 1, qVal = 1, effectsize = F,
                               verbose = T)
      expect_s3_class(x, "data.frame")
      
    })
    
    capture_test("throws error for invalid p_adjustMethod", {
      expect_error(
        mts_patternDetection(
          genepairs = data.frame(Gene1 = "G1", Gene2 = "G2"),
          mixModelClusters1 = mixModelClusters_depMapXPR,
          p_adjustMethod = "INVALID",
          cores = 1
        ),
        "Invalid p-value correction method"
      )
    })

    capture_test("returns empty result when no gene pairs are valid", {
      result <- mts_patternDetection(
        genepairs = data.frame(Gene1 = "Gene1", Gene2 = "Gene2"),
        mixModelClusters1 = mixModelClusters_depMapXPR,
        cores = 1,
        verbose = FALSE
      )
      expect_equal(nrow(result), 0)
    })

    ## mts_pairwiseExpressionPlot ------
    capture_test("mts_pairwiseExpressionPlot produces a plot for valid genes", {
      pdf(tempfile()); on.exit(dev.off())
      expect_no_error(mts_pairwiseExpressionPlot(exprsMatrix = depMapXPR_subset, gene1 = "STX2", gene2 = "VRK2"))
    })

    capture_test("mts_pairwiseExpressionPlot returns informative errors for invalid input", {
      expect_error(mts_pairwiseExpressionPlot(gene1 = "STX2", gene2 = "VRK2"), "No Expression Matrix Provided")
      expect_error(mts_pairwiseExpressionPlot(exprsMatrix = as.matrix(depMapXPR_subset), gene1 = "STX2", gene2 = "VRK2"), "must be a data frame")
      expect_error(mts_pairwiseExpressionPlot(exprsMatrix = depMapXPR_subset, gene2 = "VRK2"), "No Gene1 provided")
    })

    ## mts_omics ------
    capture_test("mts_omics returns a data frame for unidirectional XPR vs XPR (synthetic lethality)", {
      out <- mts_omics(dataMatrix = depMapXPR_subset[1:5,], qVal = 1, cores = cores)
      expect_s3_class(out, "data.frame")
    })

    capture_test("mts_omics runs for bidirectional enrichment across data types (CRISPR vs XPR)", {
      expect_no_error(mts_omics(dataMatrix = depMapCRISPRscores_subset[1:5,],
                                dataMatrix2 = depMapXPR_subset[1:5,],
                                directionality = "enrichment", qVal = 1, cores = cores))
    })

    capture_test("mts_omics runs in GDR pattern-analysis mode (SyntheticLethalityPrediction = FALSE)", {
      expect_no_error(mts_omics(dataMatrix = depMapXPR_subset[1:5,],
                                SyntheticLethalityPrediction = FALSE,
                                effectsize = FALSE, qVal = 1, cores = cores))
    })

    capture_test("mts_omics handles categorical (mutation) data against expression", {
      mutImpact <- as.data.frame(ifelse(as.matrix(depMapMUT_small) == "WT", 2L, 1L),
                                 stringsAsFactors = FALSE, check.names = FALSE)
      rownames(mutImpact) <- rownames(depMapMUT_small)
      expect_no_error(mts_omics(dataMatrix = mutImpact, dataMatrix2 = depMapXPR_small,
                                categorical1 = TRUE, directionality = "depletion",
                                qVal = 1, effectsize = FALSE, cores = cores))
    })

    capture_test("mts_omics accepts pre-computed cluster lists via mixModelClusters1", {
      mutImpact <- as.data.frame(ifelse(as.matrix(depMapMUT_small) == "WT", 2L, 1L),
                                 stringsAsFactors = FALSE, check.names = FALSE)
      rownames(mutImpact) <- rownames(depMapMUT_small)
      mutClusters <- mts_formatMatrix(matrix = mutImpact, cores = cores)
      expect_no_error(mts_omics(mixModelClusters1 = mutClusters, directionality = "depletion",
                                qVal = 1, effectsize = FALSE, cores = cores))
    })

    ## mts_InducedDependency ------
    capture_test("mts_InducedDependency returns a result for induced dependency analysis", {
      out <- mts_InducedDependency(resultList = multisepList[1:3],
                                   exprsMatrix = depMapXPR_subset,
                                   crisprMatrix = depMapCRISPRscores_subset,
                                   cores = cores)
      expect_true(is.data.frame(out) || is.list(out))
    })

    capture_test("mts_InducedDependency respects user fold-change and p-value thresholds", {
      expect_no_error(mts_InducedDependency(resultList = multisepList[1:3],
                                            exprsMatrix = depMapXPR_subset,
                                            crisprMatrix = depMapCRISPRscores_subset,
                                            fcVal = 0.1, pVal = 0.1, cores = cores))
    })

    capture_test("mts_Crispr tolerates a CRISPR gene with no usable values (t.test regression)", {
      sparseCrispr <- depMapCRISPRscores_subset
      sparseCrispr[1, ] <- NA_real_
      mCrispr_sparse <- mts_Crispr(resultList = multisepOutputFull,
                                   exprsMatrix = depMapXPR_subset[1:4, ],
                                   crisprMatrix = sparseCrispr, cores = cores)
      expect_s3_class(mCrispr_sparse, "data.frame")
    })

    capture_test("mts_InducedDependency tolerates a CRISPR gene with no usable values (t.test regression)", {
      sparseCrispr <- depMapCRISPRscores_subset
      sparseCrispr[1, ] <- NA_real_
      id_sparse <- mts_InducedDependency(resultList = multisepList[1:3],
                                         exprsMatrix = depMapXPR_subset,
                                         crisprMatrix = sparseCrispr, cores = cores)
      expect_true(is.data.frame(id_sparse) || is.list(id_sparse))
    })

    capture_test("mts_CrisprTS tolerates a CRISPR gene with no usable values (t.test regression)", {
      sparseCrispr <- depMapCRISPRscores_subset
      sparseCrispr[1, ] <- NA_real_
      allDis <- mts_Crispr(resultList = multisepOutputFull,
                           exprsMatrix = depMapXPR_subset[1:4, ],
                           crisprMatrix = sparseCrispr, cores = cores)
      ts_sparse <- mts_CrisprTS(resultList = multisepOutputFull,
                                crisprMatrix = sparseCrispr,
                                tissueMatrix = depMapTissue_subset,
                                allDisRes = allDis, cores = cores)
      expect_s3_class(ts_sparse, "data.frame")
    })

    capture_test("mts_mixModelCluster reproduces known cluster sizes for EIF1AY", {
      gmm <- mts_mixModelCluster(dataMatrix = depMapXPR_subset[1:3, ], cores = cores)
      expect_named(gmm, c("EIF1AY", "RPP25", "DNAJC15"))
      expect_equal(nrow(gmm[["EIF1AY"]]), 1304L)
      expect_equal(as.integer(table(gmm[["EIF1AY"]][, 3])), c(544L, 312L, 50L, 398L))
    })

    capture_test("mts_crisprPartition reproduces known cluster sizes for EIF1AX", {
      cp <- mts_crisprPartition(dataMatrix = depMapCRISPRscores_subset[1:2, ], cores = cores)
      expect_equal(as.integer(table(cp$EIF1AX$Cluster_Assignment)), c(914L, 134L))
    })

    capture_test("mts_targetCoverageFromMutations reproduces known mutation counts", {
      tc <- mts_targetCoverageFromMutations(mutData = depMapMUT_subset, edgeData = mRes,
                                            rowNum = 100, cores = cores)
      expect_equal(nrow(tc), 80L)
      expect_equal(max(tc$NumSamplesWithMutation), 1552)
      expect_equal(sum(tc$NumSamplesWithMutation), 57995)
      expect_equal(tc$Gene[which.max(tc$NumSamplesWithMutation)], "BAIAP2L1")
    })

    capture_test("mts_omics returns informative errors for invalid arguments", {
      expect_error(mts_omics(dataMatrix = depMapXPR_subset[1:3, ], genepairs = 1, qVal = 1, cores = cores), "must be either a dataframe or a matrix")
      expect_error(mts_omics(dataMatrix = depMapXPR_subset[1:3, ], cores = 0, qVal = 1), "cores should be >= 1")
      expect_error(mts_omics(dataMatrix = depMapXPR_subset[1:3, ], p_adjustMethod = "ZZ", qVal = 1, cores = cores), "Invalid p-value correction method")
      expect_error(mts_omics(dataMatrix = depMapXPR_subset[1:3, ], SyntheticLethalityPrediction = "yes", qVal = 1, cores = cores), "Invalid input for SyntheticLethalityPrediction")
      expect_error(mts_omics(dataMatrix = depMapXPR_subset[1:3, ], effectsize = "yes", qVal = 1, cores = cores), "Invalid input for effectsize")
      expect_error(mts_omics(dataMatrix = depMapXPR_subset[1:3, ], categorical1 = "yes", qVal = 1, cores = cores), "Invalid input for categorical1")
      expect_error(mts_omics(dataMatrix = depMapXPR_subset[1:3, ], directionality = "up", qVal = 1, cores = cores), "Invalid value of directionality")
    })

    capture_test("mts_CrisprTS returns informative errors for wrong argument types", {
      expect_error(mts_CrisprTS(crisprMatrix = as.matrix(depMapCRISPRscores_subset)), "crisprMatrix must be a data frame")
      expect_error(mts_CrisprTS(crisprMatrix = depMapCRISPRscores_subset, resultList = 1), "resultList must be a list of data frames")
      expect_error(mts_CrisprTS(crisprMatrix = depMapCRISPRscores_subset, resultList = multisepList, tissueMatrix = 1), "tissueMatrix must be a data frame")
      expect_error(mts_CrisprTS(crisprMatrix = depMapCRISPRscores_subset, resultList = multisepList, tissueMatrix = depMapTissue_subset, allDisRes = 1), "allDisRes must be a data frame")
    })

    capture_test("mts_plotCRISPRGeneCluster handles diseaseFilter values", {
      expect_error(mts_plotCRISPRGeneCluster(resultList = multisepOutputFull, mrna_gene = "RPP25", crispr_gene = "DNAJC19", crisprMatrix = depMapCRISPRscores_subset, tissueMatrix = depMapTissue_subset, plotType = "crispr_only", diseaseFilter = " nope"), "Disease filter not recognised")
      expect_no_error(mts_plotCRISPRGeneCluster(resultList = multisepOutputFull, mrna_gene = "RPP25", crispr_gene = "DNAJC19", crisprMatrix = depMapCRISPRscores_subset, tissueMatrix = depMapTissue_subset, plotType = "crispr_only", diseaseFilter = "All"))
      expect_no_error(mts_plotCRISPRGeneCluster(resultList = multisepOutputFull, mrna_gene = "RPP25", crispr_gene = "DNAJC19", crisprMatrix = depMapCRISPRscores_subset, tissueMatrix = depMapTissue_subset, plotType = "Integrated", diseaseFilter = "Lung Cancer"))
    })
  }
  # convert results to data frame
  result_df <- data.frame(
    Description = names(test_results),
    Outcome = unlist(test_results),
    stringsAsFactors = FALSE
  )
  rownames(result_df) <- NULL
  return(result_df)
}