diff --git a/R/SingleCellExperiment.R b/R/SingleCellExperiment.R
index eb7e3800..ba665eb7 100644
--- a/R/SingleCellExperiment.R
+++ b/R/SingleCellExperiment.R
@@ -1,9 +1,24 @@
 #' Convert an AnnData object to a SingleCellExperiment object
 #'
 #' `to_SingleCellExperiment()` converts an AnnData object
-#'   to a SingleCellExperiment.
+#'   to a SingleCellExperiment object.
 #'
-#' @param object an AnnData object, e.g., InMemoryAnnData
+#' @param adata an AnnData object, e.g., InMemoryAnnData
+#' 
+#' @param assays_mapping A named list mapping `layers` in `adata` to
+#'   `assay` names in the created SingleCellExperiment object.
+#' @param col_data_mapping a named list mapping `obs` in `adata` to
+#'  `colData` in the created SingleCellExperiment object
+#' @param row_data_mapping a named list mapping `var` names in `adata` to
+#'   `rowData` in the created SingleCellExperiment object
+#' @param reduction_mapping a named list mapping reduction names in `adata` to
+#' reduction names in the created SingleCellExperiment object
+#' @param colPairs_mapping a named list mapping obsp names in `adata` to
+#' colPairs names in the created SingleCellExperiment object
+#' @param rowPairs_mapping a named list mapping varp names in `adata` to
+#' rowPairs names in the created SingleCellExperiment object
+#' @param metadata_mapping a named list mapping uns names in `adata` to
+#' metadata names in the created SingleCellExperiment object
 #'
 #' @return `to_SingleCellExperiment()` returns a SingleCellExperiment
 #'   representing the content of `object`.
@@ -27,65 +42,192 @@
 #' ## construct a SingleCellExperiment from an AnnData object
 #' sce <- to_SingleCellExperiment(ad)
 #' sce
-to_SingleCellExperiment <- function(object) { # nolint
+to_SingleCellExperiment <- function(
+  adata,
+  assays_mapping = NULL,
+  col_data_mapping = NULL,
+  row_data_mapping = NULL,
+  reduction_mapping = NULL,
+  colPairs_mapping = NULL,
+  rowPairs_mapping = NULL,
+  metadata_mapping = NULL) {
+
   check_requires("Converting AnnData to SingleCellExperiment", "SingleCellExperiment", "Bioc")
 
-  stopifnot(
-    inherits(object, "AbstractAnnData")
-  )
+  stopifnot(inherits(adata, "AbstractAnnData"))
 
-  # trackstatus: class=SingleCellExperiment, feature=get_X, status=done
-  ## FIXME: name of 'X' from metadata[["X_name"]]
-  x_name <- "X"
-  assay_names <- as.character(c(
-    if (!is.null(object$X)) x_name,
-    object$layers_keys()
-  ))
+  # guess mappings if not provided
+  if (is.null(assays_mapping)) {
+    assays_mapping <- to_SCE_guess_assays(adata)
+  }
+  if (is.null(col_data_mapping)) {
+    col_data_mapping <- to_SCE_guess_all(adata, "obs")
+  }
+  if(is.null(row_data_mapping)) {
+    row_data_mapping <- to_SCE_guess_all(adata, "var")
+  }
+  if (is.null(reduction_mapping)) {
+    reduction_mapping <- to_SCE_guess_reduction(adata)
+  }
+  if (is.null(colPairs_mapping)) {
+    colPairs_mapping <- to_SCE_guess_all(adata, "obsp")
+  }
+  if (is.null(rowPairs_mapping)) {
+    rowPairs_mapping <- to_SCE_guess_all(adata, "varp")
+  }
+  if (is.null(metadata_mapping)) {
+    metadata_mapping <- to_SCE_guess_all(adata, "uns")
+  }
 
+  # trackstatus: class=SingleCellExperiment, feature=get_X, status=done
   # trackstatus: class=SingleCellExperiment, feature=get_layers, status=done
-  assays <- vector("list", length(assay_names))
-  names(assays) <- assay_names
-  for (assay in assay_names) {
-    value <- if (identical(assay, x_name)) {
-      object$X
+  sce_assays <- vector("list", length(assays_mapping))
+  names(sce_assays) <- assays_mapping
+  for (i in seq_along(assays_mapping)){
+    to <- assays_mapping[[i]]
+    from <- names(assays_mapping)[[i]]
+    if (from != "X"){
+      sce_assays[[to]] <- t(adata$layers[[from]])
     } else {
-      object$layers[[assay]]
+      sce_assays[[to]] <- t(adata$X)
     }
-    ## FIXME: is transposition robust & efficient here?
-    assays[[assay]] <- t(value)
   }
 
   # construct colData
+  # FIXME: probably better way to make a dataframe from a list of vectors
   # trackstatus: class=SingleCellExperiment, feature=get_obs, status=done
   # trackstatus: class=SingleCellExperiment, feature=get_obs_names, status=done
-  col_data <- S4Vectors::DataFrame(
-    object$obs,
-    row.names = object$obs_names
-  )
+  col_data <- .to_SCE_process_simple_mapping(adata, col_data_mapping, "obs")
+  col_data <- as(col_data, "DataFrame")
 
   # construct rowData
   # trackstatus: class=SingleCellExperiment, feature=get_var, status=done
   # trackstatus: class=SingleCellExperiment, feature=get_var_names, status=done
-  row_data <- S4Vectors::DataFrame(
-    object$var,
-    row.names = object$var_names
-  )
+  row_data <- .to_SCE_process_simple_mapping(adata, row_data_mapping, "var")
+  row_data <- as(row_data, "DataFrame")
+
+  # construct reducedDims
+  # trackstatus: class=SingleCellExperiment, feature=get_reductions, status=wip
+  reduceddims <- vector("list", length(reduction_mapping))
+  names(reduceddims) <- names(reduction_mapping)
+  for (i in seq_along(reduction_mapping)) {
+
+    name <- names(reduction_mapping)[[i]]
+    reduction <- reduction_mapping[[i]]
+
+    obsm_key <- reduction$obsm
+    varm_key <- reduction$varm
+    uns_key <- reduction$uns
+
+    reduceddims[[name]] <- .from_SingleCellExperiment_process_reduction(adata, name, obsm_key, varm_key, uns_key)
+  }
+
+  # construct colPairs
+  # trackstatus: class=SingleCellExperiment, feature=get_obsp, status=done
+  col_pairs <- .to_SCE_process_simple_mapping(adata, colPairs_mapping, "obsp")
+
+  # construct rowPairs
+  # trackstatus: class=SingleCellExperiment, feature=get_varp, status=done
+  row_pairs <- .to_SCE_process_simple_mapping(adata, rowPairs_mapping, "varp")
+
+  # construct metadata
+  # trackstatus: class=SingleCellExperiment, feature=get_uns, status=done
+  metadata <- .to_SCE_process_simple_mapping(adata, metadata_mapping, "uns")
 
   # construct output object
   sce <- SingleCellExperiment::SingleCellExperiment(
-    assays = assays,
+    assays = sce_assays,
     colData = col_data,
     rowData = row_data,
-    metadata = list(),
-    ## FIXME: assign object$uns to metadata
+    reducedDims = reduceddims,
+    colPairs = col_pairs,
+    rowPairs = row_pairs,
+    metadata = metadata,
     checkDimnames = TRUE
   )
 
-  ## reducedDims
+  sce
+}
+
+to_SCE_guess_assays <- function(adata) {
+  if (!inherits(adata, "AbstractAnnData")) {
+    stop("adata must be an object inheriting from AbstractAnnData")
+  }
 
-  ## rowPairs
+  layers <- list()
 
-  sce
+  if (!is.null(adata$X)) {
+    layer_name_for_x <- 
+      if (!"counts" %in% names(adata$layers)) { # could expand checks, to check if integers
+        "counts"
+      } else {
+        "data"
+      }
+    layers[["X"]] <- layer_name_for_x
+  }
+
+  for (layer_name in names(adata$layers)) {
+    layers[[layer_name]] <- layer_name
+  }
+
+  layers
+}
+
+to_SCE_guess_all <- function(adata, slot){
+  if (!inherits(adata, "AbstractAnnData")) {
+    stop("adata must be an object inheriting from AbstractAnnData")
+  }
+
+  mapping <- names(adata[[slot]])
+  names(mapping) <- names(adata[[slot]])
+
+  mapping
+}
+
+to_SCE_guess_reduction <- function(adata){
+  list()
+}
+
+.to_SCE_process_simple_mapping <- function(adata, mapping, slot){
+  # check if mapping contains all columns of slot
+  if(length(setdiff(names(adata[[slot]]), names(mapping))) == 0){
+    adata[[slot]]
+  } else {
+    mapped <- lapply(seq_along(mapping), function(i) {
+      adata[[slot]][[mapping[[i]]]]
+    })
+    names(mapped) <- names(mapping)
+  }
+}
+
+.from_SingleCellExperiment_process_reduction <- function(adata, key, obsm_key, varm_key, uns_key) {
+  # check arguments
+
+  embedding <- adata$obsm[[obsm_key]]
+
+  if (is.null(embedding)) {
+    stop(paste0("No embedding found for key '", obsm_key, "' in adata$obsm"))
+  }
+
+  rownames(embedding) <- adata$obs_names
+
+  if (varm_key %in% names(adata$varm)) {
+    loadings <- adata$varm[[varm_key]]
+    rownames(loadings) <- colnames(embedding)
+    
+    metadata <- list()
+    if (uns_key %in% names(adata$uns)) {
+      metadata <- adata$uns[[uns_key]]
+    }
+
+    LinearEmbeddingMatrix(
+      sampleFactors = embedding,
+      featureLoadings = loadings,
+      metadata = metadata
+    )
+  } else {
+    embedding
+  }
 }
 
 #' Convert a SingleCellExperiment object to an AnnData object
@@ -120,16 +262,22 @@ from_SingleCellExperiment <- function(
     # nolint end: object_name_linter
     sce,
     output_class = c("InMemory", "HDF5AnnData"),
+    x_mapping = NULL,
+    layers_mapping = NULL,
+    obsm_mapping = NULL,
+    varm_mapping = NULL,
+    obsp_mapping = NULL,
+    varp_mapping = NULL,
+    uns_mapping = NULL,
     ...) {
+
   check_requires("Converting SingleCellExperiment to AnnData", "SingleCellExperiment", "Bioc")
-  stopifnot(
-    inherits(sce, "SingleCellExperiment")
-  )
 
   output_class <- match.arg(output_class)
 
-  # fetch generator
-  generator <- get_anndata_constructor(output_class)
+  stopifnot(inherits(sce, "SingleCellExperiment"))
+
+  # TODO: guess mappings if not provided
 
   # trackstatus: class=SingleCellExperiment, feature=set_obs, status=done
   # trackstatus: class=SingleCellExperiment, feature=set_obs_names, status=done
@@ -143,47 +291,121 @@ from_SingleCellExperiment <- function(
     SummarizedExperiment::rowData(sce)
   )
 
-  # trackstatus: class=SingleCellExperiment, feature=set_X, status=done
-  # trackstatus: class=SingleCellExperiment, feature=set_layers, status=done
-  x_and_layers <- lapply(
-    SummarizedExperiment::assays(sce, withDimnames = FALSE),
-    function(mat) {
-      m <- t(mat)
-      # nolint start
-      # WORKAROUND: convert denseMatrix to matrix, because otherwise:
-      # - Could not write element '/layers/integer_dense' of type 'dgeMatrix':
-      #   no applicable method for 'h5writeDataset' applied to an object of class "c('dgeMatrix', 'unpackedMatrix', 'ddenseMatrix', 'generalMatrix', 'dMatrix', 'denseMatrix', 'compMa
-      # - Could not write element '/layers/integer_dense_with_nas' of type 'dgeMatrix':
-      #   no applicable method for 'h5writeDataset' applied to an object of class "c('dgeMatrix', 'unpackedMatrix', 'ddenseMatrix', 'generalMatrix', 'dMatrix', 'denseMatrix', 'compMatrix', 'Matrix', 'replValueSp')"
-      # nolint end
-      if (inherits(m, "denseMatrix")) {
-        m <- as.matrix(m)
-      }
-      m
-    }
-  )
-  if (length(x_and_layers) == 0L) {
-    x <- NULL
-    layers <- list()
-    names(layers) <- character()
-  } else {
-    x <- x_and_layers[[1]]
-    layers <- x_and_layers[-1]
-  }
+  # fetch generator
+  generator <- get_anndata_constructor(output_class)
 
   tryCatch(
-    generator$new(
-      X = x,
-      obs = obs,
-      var = var,
-      layers = layers,
-      ...
-    ),
+    {
+      adata <- generator$new(
+        obs = obs,
+        var = var,
+        ...
+      )
+
+      # fetch X
+      # trackstatus: class=SingleCellExperiment, feature=set_X, status=wip
+      x <- NULL
+      if(!is.null(x_mapping)){
+        x <- .to_anndata_matrix(SummarizedExperiment::assay(sce, withDimnames = FALSE))
+      }
+
+      # fetch layers
+      # trackstatus: class=SingleCellExperiment, feature=set_layers, status=wip
+      for (i in seq_along(layers_mapping)) {
+        layer <- layers_mapping[[i]]
+        layer_name <- names(layers_mapping)[[i]]
+
+        adata$uns[[layer_name]] <- .to_anndata_matrix(assay(sce, layer))
+      }
+
+      # trackstatus: class=SingleCellExperiment, feature=set_obsm, status=wip
+      for (i in seq_along(obsm_mapping)) {
+        obsm <- obsm_mapping[[i]]
+        obsm_name <- names(obsm_mapping)[[i]]
+
+        if (!is.character(obsm) || length(obsm) != 2){
+          stop("each obsm_mapping must be a character vector of length 2")
+        }
+
+        obsm_slot <- obsm[[1]]
+        obsm_key <- obsm[[2]]
+
+        if (obsm_slot == "reducedDims") {
+          adata$obsm[[obsm_name]] <- reducedDim(sce, obsm_key)
+        } else if (obsm_slot == "metadata") {
+          adata$obsm[[obsm_name]] <- metadata(sce)[[obsm_key]]
+        } 
+      }
+
+      # have a look at this for loadings: https://github.com/ivirshup/sc-interchange/issues/2
+      # could be in rowData or metadata, or in LinearEmbeddingMatrix (which is in a reducedDims slot)?
+      # if in rowData --> need a prefix? or a subslot?
+      # if in metadata --> need a subslot
+
+      # fetch varm
+      # trackstatus: class=SingleCellExperiment, feature=set_varm, status=todo
+      for (i in seq_along(varm_mapping)) {
+        varm <- varm_mapping[[i]]
+        varm_name <- names(varm_mapping)[[i]]
+
+      }
+
+      # fetch obsp
+      # trackstatus: class=SingleCellExperiment, feature=set_obsp, status=wip
+      for (i in seq_along(obsp_mapping)) {
+        obsp <- obsp_mapping[[i]]
+        obsp_name <- names(obsp_mapping)[[i]]
+
+        adata$obsp[[obsp_name]] <- .to_anndata_matrix(colPair(sce, obsp))
+      }
+
+      # fetch varp
+      # trackstatus: class=SingleCellExperiment, feature=set_varp, status=wip
+      for (i in seq_along(varp_mapping)) {
+        varp <- varp_mapping[[i]]
+        varp_name <- names(varp_mapping)[[i]]
+
+        adata$varp[[varp_name]] <- .to_anndata_matrix(rowPair(sce, varp))
+      }
+
+      # fetch uns
+      # trackstatus: class=SingleCellExperiment, feature=set_uns, status=wip
+      for (i in seq_along(uns_mapping)) {
+        uns <- uns_mapping[[i]]
+        uns_name <- names(uns_mapping)[[i]]
+
+        if (!is.character(uns) || length(uns) < 2 || length(uns) > 3) {
+          stop("each uns_mapping must be a character vector of length 2 or 3")
+        }
+
+        key1 <- uns[[1]]
+        key2 <- uns[[2]]
+
+        if (key1 == "misc") {
+          data <- seurat_obj@misc[[key2]]
+          if (length(uns) == 3) {
+            data <- data[[uns[[3]]]]
+          }
+          adata$uns[[uns_name]] <- data
+        }
+      }
+
+    },
     error = function(e) {
       if (output_class == "HDF5AnnData") {
-        on.exit(cleanup_HDF5AnnData(...))
+        on.exit(cleanup_HDF5AnnData(adata))
       }
       stop(e)
     }
   )
+
+}
+
+
+.to_anndata_matrix <- function(dge) {
+  m <- t(mat)
+  if (inherits(m, "denseMatrix")) {
+    m <- as.matrix(m)
+  }
+  m
 }
diff --git a/tests/testthat/test-SingleCellExperiment.R b/tests/testthat/test-SingleCellExperiment.R
index 8ecfd9d7..d6a782d6 100644
--- a/tests/testthat/test-SingleCellExperiment.R
+++ b/tests/testthat/test-SingleCellExperiment.R
@@ -1,88 +1,142 @@
-test_that("to_SingleCellExperiment() works", {
-  ad <- AnnData(
-    X = matrix(1:5, 3L, 5L),
-    obs = data.frame(row.names = letters[1:3], cell = 1:3),
-    var = data.frame(row.names = LETTERS[1:5], gene = 1:5)
-  )
-  ad0 <- AnnData(
-    obs = data.frame(row.names = letters[1:5]),
-    var = data.frame(row.names = LETTERS[1:10])
-  )
-
-  # conversion works
-  expect_no_error(sce <- to_SingleCellExperiment(ad))
-  expect_no_error(sce0 <- to_SingleCellExperiment(ad0))
-  expect_true(validObject(sce))
-  expect_true(validObject(sce0))
-
-  expect_identical(dim(sce), rev(ad$shape()))
-  expect_identical(dim(sce0), rev(ad0$shape()))
+dummy <- generate_dataset(10L, 20L)
+
+test_that("to_SingleCellExperiment with inmemoryanndata", {
+  library(SingleCellExperiment)
+
+  ad <- generate_dataset(n_obs = 10L, n_var = 20L, format = "AnnData")
+
+  sce <- ad$to_SingleCellExperiment()
+
+  expect_equal(nrow(sce), 20)
+  expect_equal(ncol(sce), 10)
 
-  # trackstatus: class=SingleCellExperiment, feature=test_get_obs_names, status=done
   # trackstatus: class=SingleCellExperiment, feature=test_get_var_names, status=done
-  expect_identical(dimnames(sce), list(LETTERS[1:5], letters[1:3]))
-  expect_identical(dimnames(sce0), list(LETTERS[1:10], letters[1:5]))
+  expect_equal(rownames(sce), rownames(dummy$var))
 
-  # trackstatus: class=SingleCellExperiment, feature=test_get_var, status=done
-  var_ <- as.data.frame(SummarizedExperiment::rowData(sce))
-  expect_identical(var_, ad$var)
-  var0_ <- as.data.frame(SummarizedExperiment::rowData(sce0))
-  expect_identical(var0_, ad0$var)
+  # trackstatus: class=SingleCellExperiment, feature=test_get_obs_names, status=done
+  expect_equal(colnames(sce), rownames(dummy$obs))
 
+  # check whether all obs keys are found in the sce metadata
   # trackstatus: class=SingleCellExperiment, feature=test_get_obs, status=done
-  obs_ <- as.data.frame(SummarizedExperiment::colData(sce))
-  expect_identical(obs_, ad$obs)
-  obs0_ <- as.data.frame(SummarizedExperiment::colData(sce0))
-  expect_identical(obs0_, ad0$obs)
-
-  # trackstatus: class=SingleCellExperiment, feature=test_get_X, status=done
-  expect_identical(
-    SummarizedExperiment::assay(sce, withDimnames = FALSE),
-    t(ad$X)
-  )
-  expect_error(
-    SummarizedExperiment::assay(sce0, withDimnames = FALSE)
-  )
-})
+  for (obs_key in colnames(dummy$obs)) {
+    expect_true(obs_key %in% colnames(colData(sce)))
+    expect_equal(colData(sce)[[obs_key]], dummy$obs[[obs_key]], info = paste0("obs_key: ", obs_key))
+  }
+
+  # check whether all var keys are found in the sce assay metadata
+  # trackstatus: class=SingleCellExperiment, feature=test_get_var, status=done
+  for (var_key in colnames(dummy$var)) {
+    expect_true(var_key %in% colnames(rowData(sce)))
+    expect_equal(rowData(sce)[[var_key]], dummy$var[[var_key]], info = paste0("var_key: ", var_key))
+  }
+
+  # check whether layers are found in the sce assays
+  for (layer_key in names(dummy$layers)) {
+    expect_true(layer_key %in% names(assays(sce)))
+    expect_true(all.equal(assay(sce, layer_key), t(dummy$layers[[layer_key]]), check.attributes = FALSE), info = paste0("layer_key: ", layer_key)) ## matrix dimensions and dimnames are different
+  }
+
+  # check whether all obsp keys are found in the colPairs
+  for (obsp_key in names(dummy$obsp)) {
+    expect_true(obsp_key %in% names(colPairs(sce)))
+    expect_equal(colData(sce)[[obsp_key]], dummy$obsp[[obsp_key]], info = paste0("obsm_key: ", obsm_key))
+  }
+
+  # check whether all varp keys are found in the rowPairs
+  for (varp_key in names(dummy$varp)) {
+    expect_true(varp_key %in% names(rowPairs(sce)))
+    expect_equal(rowData(sce)[[varp_key]], dummy$varp[[varp_key]], info = paste0("varm_key: ", varm_key))
+  }
+
+  # TODO: obsm keys? varm keys? --> test a reduction
 
-test_that("from_SingleCellExperiment() works", {
-  ## 0-dimensioned
-  sce0 <- SingleCellExperiment::SingleCellExperiment()
-  dimnames(sce0) <- list(character(0), character(0))
-
-  ## complete
-  x <- matrix(1:15, 3, 5)
-  layers <- list(A = matrix(15:1, 3, 5), B = matrix(LETTERS[1:15], 3, 5))
-  obs <- data.frame(cell = 1:3, row.names = LETTERS[1:3])
-  var <- data.frame(gene = 1:5, row.names = letters[1:5])
-  sce <- SingleCellExperiment::SingleCellExperiment(
-    assays = lapply(c(list(x), layers), t),
-    colData = obs,
-    rowData = var
-  )
-  dimnames <- dimnames(sce)
-
-  ad0 <- from_SingleCellExperiment(sce0, "InMemory")
-  ad <- from_SingleCellExperiment(sce, "InMemory")
-
-  # trackstatus: class=SingleCellExperiment, feature=test_set_X, status=done
-  expect_identical(ad0$X, NULL)
-  expect_identical(ad$X, x)
-  # trackstatus: class=SingleCellExperiment, feature=test_set_obs, status=done
-  expect_identical(ad0$obs, data.frame(row.names = character(0)))
-  expect_identical(ad$obs, obs)
-  # trackstatus: class=SingleCellExperiment, feature=test_set_var, status=done
-  expect_identical(ad0$var, data.frame(row.names = character(0)))
-  expect_identical(ad$var, var)
-  # trackstatus: class=SingleCellExperiment, feature=test_set_obs_names, status=done
-  expect_identical(ad0$obs_names, character(0))
-  expect_identical(ad$obs_names, dimnames[[2]])
-  # trackstatus: class=SingleCellExperiment, feature=test_set_var_names, status=done
-  expect_identical(ad0$var_names, character(0))
-  expect_identical(ad$var_names, dimnames[[1]])
-  # trackstatus: class=SingleCellExperiment, feature=test_set_layers, status=done
-  layers0 <- list()
-  names(layers0) <- character()
-  expect_identical(ad0$layers, layers0)
-  expect_identical(ad$layers, layers)
 })
+
+# test_that("to_SingleCellExperiment() works", {
+#   ad <- AnnData(
+#     X = matrix(1:5, 3L, 5L),
+#     obs = data.frame(row.names = letters[1:3], cell = 1:3),
+#     var = data.frame(row.names = LETTERS[1:5], gene = 1:5)
+#   )
+#   ad0 <- AnnData(
+#     obs = data.frame(row.names = letters[1:5]),
+#     var = data.frame(row.names = LETTERS[1:10])
+#   )
+
+#   # conversion works
+#   expect_no_error(sce <- to_SingleCellExperiment(ad))
+#   expect_no_error(sce0 <- to_SingleCellExperiment(ad0))
+#   expect_true(validObject(sce))
+#   expect_true(validObject(sce0))
+
+#   expect_identical(dim(sce), rev(ad$shape()))
+#   expect_identical(dim(sce0), rev(ad0$shape()))
+
+#   # trackstatus: class=SingleCellExperiment, feature=test_get_obs_names, status=done
+#   # trackstatus: class=SingleCellExperiment, feature=test_get_var_names, status=done
+#   expect_identical(dimnames(sce), list(LETTERS[1:5], letters[1:3]))
+#   expect_identical(dimnames(sce0), list(LETTERS[1:10], letters[1:5]))
+
+#   # trackstatus: class=SingleCellExperiment, feature=test_get_var, status=done
+#   var_ <- as.data.frame(SummarizedExperiment::rowData(sce))
+#   expect_identical(var_, ad$var)
+#   var0_ <- as.data.frame(SummarizedExperiment::rowData(sce0))
+#   expect_identical(var0_, ad0$var)
+
+#   # trackstatus: class=SingleCellExperiment, feature=test_get_obs, status=done
+#   obs_ <- as.data.frame(SummarizedExperiment::colData(sce))
+#   expect_identical(obs_, ad$obs)
+#   obs0_ <- as.data.frame(SummarizedExperiment::colData(sce0))
+#   expect_identical(obs0_, ad0$obs)
+
+#   # trackstatus: class=SingleCellExperiment, feature=test_get_X, status=done
+#   expect_identical(
+#     SummarizedExperiment::assay(sce, withDimnames = FALSE),
+#     t(ad$X)
+#   )
+#   expect_error(
+#     SummarizedExperiment::assay(sce0, withDimnames = FALSE)
+#   )
+# })
+
+# test_that("from_SingleCellExperiment() works", {
+#   ## 0-dimensioned
+#   sce0 <- SingleCellExperiment::SingleCellExperiment()
+#   dimnames(sce0) <- list(character(0), character(0))
+
+#   ## complete
+#   x <- matrix(1:15, 3, 5)
+#   layers <- list(A = matrix(15:1, 3, 5), B = matrix(LETTERS[1:15], 3, 5))
+#   obs <- data.frame(cell = 1:3, row.names = LETTERS[1:3])
+#   var <- data.frame(gene = 1:5, row.names = letters[1:5])
+#   sce <- SingleCellExperiment::SingleCellExperiment(
+#     assays = lapply(c(list(x), layers), t),
+#     colData = obs,
+#     rowData = var
+#   )
+#   dimnames <- dimnames(sce)
+
+#   ad0 <- from_SingleCellExperiment(sce0, "InMemory")
+#   ad <- from_SingleCellExperiment(sce, "InMemory")
+
+#   # trackstatus: class=SingleCellExperiment, feature=test_set_X, status=done
+#   expect_identical(ad0$X, NULL)
+#   expect_identical(ad$X, x)
+#   # trackstatus: class=SingleCellExperiment, feature=test_set_obs, status=done
+#   expect_identical(ad0$obs, data.frame(row.names = character(0)))
+#   expect_identical(ad$obs, obs)
+#   # trackstatus: class=SingleCellExperiment, feature=test_set_var, status=done
+#   expect_identical(ad0$var, data.frame(row.names = character(0)))
+#   expect_identical(ad$var, var)
+#   # trackstatus: class=SingleCellExperiment, feature=test_set_obs_names, status=done
+#   expect_identical(ad0$obs_names, character(0))
+#   expect_identical(ad$obs_names, dimnames[[2]])
+#   # trackstatus: class=SingleCellExperiment, feature=test_set_var_names, status=done
+#   expect_identical(ad0$var_names, character(0))
+#   expect_identical(ad$var_names, dimnames[[1]])
+#   # trackstatus: class=SingleCellExperiment, feature=test_set_layers, status=done
+#   layers0 <- list()
+#   names(layers0) <- character()
+#   expect_identical(ad0$layers, layers0)
+#   expect_identical(ad$layers, layers)
+# })