tests/testthat/test-coverage-plot-htna-multi-40.R

In cograph: Analysis and Visualization of Complex Networks

# test-coverage-plot-htna-multi-40.R - Comprehensive tests for plot-htna-multi.R
# Tests for plot_mtna() / mtna() multi-cluster TNA network visualization

# ============================================
# Test Data Setup
# ============================================

# Helper function to create test matrix with clusters
skip_on_cran()

create_clustered_matrix <- function(n_nodes = 20, n_clusters = 4, seed = 42) {
  set.seed(seed)
  nodes <- paste0("N", seq_len(n_nodes))
  m <- matrix(runif(n_nodes * n_nodes, 0, 0.3), n_nodes, n_nodes)
  diag(m) <- 0
  colnames(m) <- rownames(m) <- nodes
  m
}

# Helper function to create test clusters
create_test_clusters <- function(n_nodes = 20, n_clusters = 4) {
  cluster_size <- n_nodes %/% n_clusters
  clusters <- lapply(seq_len(n_clusters), function(i) {
    start <- (i - 1) * cluster_size + 1
    end <- if (i == n_clusters) n_nodes else i * cluster_size
    paste0("N", start:end)
  })
  names(clusters) <- paste0("Cluster", seq_len(n_clusters))
  clusters
}

# ============================================
# BASIC FUNCTIONALITY TESTS
# ============================================

test_that("plot_mtna() works with basic matrix input", {
  m <- create_clustered_matrix(20, 4)
  clusters <- create_test_clusters(20, 4)

  result <- safe_plot(plot_mtna(m, clusters))
  expect_true(result$success, info = result$error)
})

test_that("mtna() alias works identically to plot_mtna()", {
  m <- create_clustered_matrix(20, 4)
  clusters <- create_test_clusters(20, 4)

  result <- safe_plot(mtna(m, clusters))
  expect_true(result$success, info = result$error)
})

test_that("plot_mtna() works with 2 clusters (minimum)", {
  m <- create_clustered_matrix(10, 2)
  clusters <- list(
    Group1 = paste0("N", 1:5),
    Group2 = paste0("N", 6:10)
  )

  result <- safe_plot(plot_mtna(m, clusters))
  expect_true(result$success, info = result$error)
})

test_that("plot_mtna() works with many clusters", {
  m <- create_clustered_matrix(24, 6)
  clusters <- create_test_clusters(24, 6)

  result <- safe_plot(plot_mtna(m, clusters))
  expect_true(result$success, info = result$error)
})

test_that("plot_mtna() works with unequal cluster sizes", {
  m <- create_clustered_matrix(15, 3)
  clusters <- list(
    Small = paste0("N", 1:3),
    Medium = paste0("N", 4:9),
    Large = paste0("N", 10:15)
  )

  result <- safe_plot(plot_mtna(m, clusters))
  expect_true(result$success, info = result$error)
})

test_that("plot_mtna() works with single-node clusters", {
  m <- create_clustered_matrix(5, 5)
  clusters <- list(
    A = "N1",
    B = "N2",
    C = "N3",
    D = "N4",
    E = "N5"
  )

  result <- safe_plot(plot_mtna(m, clusters))
  expect_true(result$success, info = result$error)
})

# ============================================
# TNA OBJECT INPUT TESTS
# ============================================

test_that("plot_mtna() works with tna object", {
  skip_if_not_installed("tna")

  # Create a mock tna object
  m <- create_clustered_matrix(12, 3)
  tna_obj <- list(
    labels = colnames(m),
    weights = m
  )
  class(tna_obj) <- "tna"

  clusters <- list(
    A = paste0("N", 1:4),
    B = paste0("N", 5:8),
    C = paste0("N", 9:12)
  )

  result <- safe_plot(plot_mtna(tna_obj, clusters))
  expect_true(result$success, info = result$error)
})

# ============================================
# LAYOUT PARAMETER TESTS
# ============================================

test_that("plot_mtna() works with circle layout (default)", {
  m <- create_clustered_matrix(16, 4)
  clusters <- create_test_clusters(16, 4)

  result <- safe_plot(plot_mtna(m, clusters, layout = "circle"))
  expect_true(result$success, info = result$error)
})

test_that("plot_mtna() works with grid layout", {
  m <- create_clustered_matrix(16, 4)
  clusters <- create_test_clusters(16, 4)

  result <- safe_plot(plot_mtna(m, clusters, layout = "grid"))
  expect_true(result$success, info = result$error)
})

test_that("plot_mtna() works with horizontal layout", {
  m <- create_clustered_matrix(16, 4)
  clusters <- create_test_clusters(16, 4)

  result <- safe_plot(plot_mtna(m, clusters, layout = "horizontal"))
  expect_true(result$success, info = result$error)
})

test_that("plot_mtna() works with vertical layout", {
  m <- create_clustered_matrix(16, 4)
  clusters <- create_test_clusters(16, 4)

  result <- safe_plot(plot_mtna(m, clusters, layout = "vertical"))
  expect_true(result$success, info = result$error)
})

test_that("plot_mtna() errors on unknown layout", {
  m <- create_clustered_matrix(16, 4)
  clusters <- create_test_clusters(16, 4)

  expect_error(
    with_temp_png(plot_mtna(m, clusters, layout = "unknown")),
    "Unknown layout"
  )
})

# ============================================
# SPACING AND SIZE PARAMETER TESTS
# ============================================

test_that("plot_mtna() handles different spacing values", {
  m <- create_clustered_matrix(16, 4)
  clusters <- create_test_clusters(16, 4)

  # Small spacing
  result <- safe_plot(plot_mtna(m, clusters, spacing = 2))
  expect_true(result$success, info = result$error)

  # Large spacing
  result <- safe_plot(plot_mtna(m, clusters, spacing = 8))
  expect_true(result$success, info = result$error)
})

test_that("plot_mtna() handles different shape_size values", {
  m <- create_clustered_matrix(16, 4)
  clusters <- create_test_clusters(16, 4)

  # Small shapes
  result <- safe_plot(plot_mtna(m, clusters, shape_size = 1.0))
  expect_true(result$success, info = result$error)

  # Large shapes
  result <- safe_plot(plot_mtna(m, clusters, shape_size = 3.0))
  expect_true(result$success, info = result$error)
})

test_that("plot_mtna() handles different node_spacing values", {
  m <- create_clustered_matrix(16, 4)
  clusters <- create_test_clusters(16, 4)

  # Tight node spacing
  result <- safe_plot(plot_mtna(m, clusters, node_spacing = 0.3))
  expect_true(result$success, info = result$error)

  # Loose node spacing
  result <- safe_plot(plot_mtna(m, clusters, node_spacing = 0.8))
  expect_true(result$success, info = result$error)
})

test_that("plot_mtna() handles node_size parameter", {
  m <- create_clustered_matrix(16, 4)
  clusters <- create_test_clusters(16, 4)

  result <- safe_plot(plot_mtna(m, clusters, node_size = 5))
  expect_true(result$success, info = result$error)

  result <- safe_plot(plot_mtna(m, clusters, node_size = 1))
  expect_true(result$success, info = result$error)
})

test_that("plot_mtna() handles layout_margin parameter", {
  m <- create_clustered_matrix(16, 4)
  clusters <- create_test_clusters(16, 4)

  result <- safe_plot(plot_mtna(m, clusters, layout_margin = 0.05))
  expect_true(result$success, info = result$error)

  result <- safe_plot(plot_mtna(m, clusters, layout_margin = 0.3))
  expect_true(result$success, info = result$error)
})

test_that("plot_mtna() handles scale parameter", {
  m <- create_clustered_matrix(16, 4)
  clusters <- create_test_clusters(16, 4)

  # Normal scale
  result <- safe_plot(plot_mtna(m, clusters, scale = 1))
  expect_true(result$success, info = result$error)

  # High-res scale
  result <- safe_plot(plot_mtna(m, clusters, scale = 4))
  expect_true(result$success, info = result$error)
})

# ============================================
# COLOR PARAMETER TESTS
# ============================================

test_that("plot_mtna() uses default colors when none provided", {
  m <- create_clustered_matrix(16, 4)
  clusters <- create_test_clusters(16, 4)

  result <- safe_plot(plot_mtna(m, clusters, colors = NULL))
  expect_true(result$success, info = result$error)
})

test_that("plot_mtna() handles custom cluster colors", {
  m <- create_clustered_matrix(16, 4)
  clusters <- create_test_clusters(16, 4)

  custom_colors <- c("red", "blue", "green", "orange")

  result <- safe_plot(plot_mtna(m, clusters, colors = custom_colors))
  expect_true(result$success, info = result$error)
})

test_that("plot_mtna() recycles colors when fewer than clusters", {
  m <- create_clustered_matrix(16, 4)
  clusters <- create_test_clusters(16, 4)

  # Only 2 colors for 4 clusters
  result <- safe_plot(plot_mtna(m, clusters, colors = c("red", "blue")))
  expect_true(result$success, info = result$error)
})

test_that("plot_mtna() handles custom edge_colors", {
  m <- create_clustered_matrix(16, 4)
  clusters <- create_test_clusters(16, 4)

  edge_colors <- c("#FF0000", "#00FF00", "#0000FF", "#FFFF00")

  result <- safe_plot(plot_mtna(m, clusters, edge_colors = edge_colors))
  expect_true(result$success, info = result$error)
})

# ============================================
# SHAPE PARAMETER TESTS
# ============================================

test_that("plot_mtna() uses default shapes when none provided", {
  m <- create_clustered_matrix(16, 4)
  clusters <- create_test_clusters(16, 4)

  result <- safe_plot(plot_mtna(m, clusters, shapes = NULL))
  expect_true(result$success, info = result$error)
})

test_that("plot_mtna() handles circle shape", {
  m <- create_clustered_matrix(8, 2)
  clusters <- list(A = paste0("N", 1:4), B = paste0("N", 5:8))

  result <- safe_plot(plot_mtna(m, clusters, shapes = c("circle", "circle")))
  expect_true(result$success, info = result$error)
})

test_that("plot_mtna() handles square shape", {
  m <- create_clustered_matrix(8, 2)
  clusters <- list(A = paste0("N", 1:4), B = paste0("N", 5:8))

  result <- safe_plot(plot_mtna(m, clusters, shapes = c("square", "square")))
  expect_true(result$success, info = result$error)
})

test_that("plot_mtna() handles diamond shape", {
  m <- create_clustered_matrix(8, 2)
  clusters <- list(A = paste0("N", 1:4), B = paste0("N", 5:8))

  result <- safe_plot(plot_mtna(m, clusters, shapes = c("diamond", "diamond")))
  expect_true(result$success, info = result$error)
})

test_that("plot_mtna() handles triangle shape", {
  m <- create_clustered_matrix(8, 2)
  clusters <- list(A = paste0("N", 1:4), B = paste0("N", 5:8))

  result <- safe_plot(plot_mtna(m, clusters, shapes = c("triangle", "triangle")))
  expect_true(result$success, info = result$error)
})

test_that("plot_mtna() handles mixed shapes", {
  m <- create_clustered_matrix(16, 4)
  clusters <- create_test_clusters(16, 4)

  shapes <- c("circle", "square", "diamond", "triangle")

  result <- safe_plot(plot_mtna(m, clusters, shapes = shapes))
  expect_true(result$success, info = result$error)
})

test_that("plot_mtna() handles additional polygon shapes", {
  m <- create_clustered_matrix(24, 6)
  clusters <- create_test_clusters(24, 6)

  shapes <- c("circle", "square", "diamond", "triangle", "pentagon", "hexagon")

  result <- safe_plot(plot_mtna(m, clusters, shapes = shapes))
  expect_true(result$success, info = result$error)
})

# ============================================
# EDGE BUNDLING TESTS
# ============================================

test_that("plot_mtna() works with bundle_edges = TRUE (default)", {
  m <- create_clustered_matrix(16, 4)
  clusters <- create_test_clusters(16, 4)

  result <- safe_plot(plot_mtna(m, clusters, bundle_edges = TRUE))
  expect_true(result$success, info = result$error)
})

test_that("plot_mtna() works with bundle_edges = FALSE", {
  m <- create_clustered_matrix(16, 4)
  clusters <- create_test_clusters(16, 4)

  result <- safe_plot(plot_mtna(m, clusters, bundle_edges = FALSE))
  expect_true(result$success, info = result$error)
})

test_that("plot_mtna() handles different bundle_strength values", {
  m <- create_clustered_matrix(16, 4)
  clusters <- create_test_clusters(16, 4)

  # Tight bundling
  result <- safe_plot(plot_mtna(m, clusters, bundle_strength = 0.2))
  expect_true(result$success, info = result$error)

  # Loose bundling
  result <- safe_plot(plot_mtna(m, clusters, bundle_strength = 1.0))
  expect_true(result$success, info = result$error)
})

# ============================================
# SUMMARY EDGES TESTS
# ============================================

test_that("plot_mtna() works with summary_edges = TRUE (default)", {
  m <- create_clustered_matrix(16, 4)
  clusters <- create_test_clusters(16, 4)

  result <- safe_plot(plot_mtna(m, clusters, summary_edges = TRUE))
  expect_true(result$success, info = result$error)
})

test_that("plot_mtna() works with summary_edges = FALSE", {
  m <- create_clustered_matrix(16, 4)
  clusters <- create_test_clusters(16, 4)

  result <- safe_plot(plot_mtna(m, clusters, summary_edges = FALSE))
  expect_true(result$success, info = result$error)
})

test_that("plot_mtna() handles within_edges parameter in summary mode", {
  m <- create_clustered_matrix(16, 4)
  clusters <- create_test_clusters(16, 4)

  # With within-cluster edges
  result <- safe_plot(plot_mtna(m, clusters, summary_edges = TRUE, within_edges = TRUE))
  expect_true(result$success, info = result$error)

  # Without within-cluster edges
  result <- safe_plot(plot_mtna(m, clusters, summary_edges = TRUE, within_edges = FALSE))
  expect_true(result$success, info = result$error)
})

# ============================================
# AGGREGATION METHOD TESTS
# ============================================

test_that("plot_mtna() handles aggregation = 'sum'", {
  m <- create_clustered_matrix(16, 4)
  clusters <- create_test_clusters(16, 4)

  result <- safe_plot(plot_mtna(m, clusters, aggregation = "sum"))
  expect_true(result$success, info = result$error)
})

test_that("plot_mtna() handles aggregation = 'mean'", {
  m <- create_clustered_matrix(16, 4)
  clusters <- create_test_clusters(16, 4)

  result <- safe_plot(plot_mtna(m, clusters, aggregation = "mean"))
  expect_true(result$success, info = result$error)
})

test_that("plot_mtna() handles aggregation = 'max'", {
  m <- create_clustered_matrix(16, 4)
  clusters <- create_test_clusters(16, 4)

  result <- safe_plot(plot_mtna(m, clusters, aggregation = "max"))
  expect_true(result$success, info = result$error)
})

test_that("plot_mtna() handles aggregation = 'min'", {
  m <- create_clustered_matrix(16, 4)
  clusters <- create_test_clusters(16, 4)

  result <- safe_plot(plot_mtna(m, clusters, aggregation = "min"))
  expect_true(result$success, info = result$error)
})

test_that("plot_mtna() handles aggregation = 'median'", {
  m <- create_clustered_matrix(16, 4)
  clusters <- create_test_clusters(16, 4)

  result <- safe_plot(plot_mtna(m, clusters, aggregation = "median"))
  expect_true(result$success, info = result$error)
})

test_that("plot_mtna() handles aggregation = 'density'", {
  m <- create_clustered_matrix(16, 4)
  clusters <- create_test_clusters(16, 4)

  result <- safe_plot(plot_mtna(m, clusters, aggregation = "density"))
  expect_true(result$success, info = result$error)
})

# ============================================
# BORDER AND DISPLAY TESTS
# ============================================

test_that("plot_mtna() handles show_border = TRUE", {
  m <- create_clustered_matrix(16, 4)
  clusters <- create_test_clusters(16, 4)

  result <- safe_plot(plot_mtna(m, clusters, summary_edges = FALSE, show_border = TRUE))
  expect_true(result$success, info = result$error)
})

test_that("plot_mtna() handles show_border = FALSE", {
  m <- create_clustered_matrix(16, 4)
  clusters <- create_test_clusters(16, 4)

  result <- safe_plot(plot_mtna(m, clusters, summary_edges = FALSE, show_border = FALSE))
  expect_true(result$success, info = result$error)
})

test_that("plot_mtna() handles curvature parameter", {
  m <- create_clustered_matrix(16, 4)
  clusters <- create_test_clusters(16, 4)

  # No curvature
  result <- safe_plot(plot_mtna(m, clusters, curvature = 0))
  expect_true(result$success, info = result$error)

  # High curvature
  result <- safe_plot(plot_mtna(m, clusters, curvature = 0.6))
  expect_true(result$success, info = result$error)
})

# ============================================
# LEGEND TESTS
# ============================================

test_that("plot_mtna() handles legend = TRUE (default)", {
  m <- create_clustered_matrix(16, 4)
  clusters <- create_test_clusters(16, 4)

  result <- safe_plot(plot_mtna(m, clusters, legend = TRUE))
  expect_true(result$success, info = result$error)
})

test_that("plot_mtna() handles legend = FALSE", {
  m <- create_clustered_matrix(16, 4)
  clusters <- create_test_clusters(16, 4)

  result <- safe_plot(plot_mtna(m, clusters, legend = FALSE))
  expect_true(result$success, info = result$error)
})

test_that("plot_mtna() handles different legend_position values", {
  m <- create_clustered_matrix(16, 4)
  clusters <- create_test_clusters(16, 4)

  positions <- c("topright", "topleft", "bottomright", "bottomleft")

  for (pos in positions) {
    result <- safe_plot(plot_mtna(m, clusters, legend = TRUE, legend_position = pos))
    expect_true(result$success, info = paste("Legend position", pos, "failed:", result$error))
  }
})

# ============================================
# ERROR HANDLING TESTS
# ============================================

test_that("plot_mtna() errors when cluster_list is NULL without community", {
  m <- create_clustered_matrix(16, 4)

  expect_error(
    with_temp_png(plot_mtna(m, cluster_list = NULL)),
    "Either cluster_list or community must be specified"
  )
})

test_that("plot_mtna() errors with fewer than 2 clusters", {
  m <- create_clustered_matrix(8, 2)
  clusters <- list(OnlyOne = paste0("N", 1:8))

  expect_error(
    with_temp_png(plot_mtna(m, clusters)),
    "cluster_list must be a list of 2\\+ character vectors"
  )
})

test_that("plot_mtna() errors when cluster_list is not a list", {
  m <- create_clustered_matrix(8, 2)

  expect_error(
    with_temp_png(plot_mtna(m, cluster_list = c("N1", "N2", "N3"))),
    "cluster_list must be a list"
  )
})

test_that("plot_mtna() errors on overlapping clusters", {
  m <- create_clustered_matrix(10, 2)
  clusters <- list(
    A = paste0("N", 1:6),
    B = paste0("N", 5:10)  # Overlaps with A at N5, N6
  )

  expect_error(
    with_temp_png(plot_mtna(m, clusters)),
    "cluster_list groups must not overlap"
  )
})

test_that("plot_mtna() errors when cluster nodes not in matrix", {
  m <- create_clustered_matrix(8, 2)
  clusters <- list(
    A = paste0("N", 1:4),
    B = paste0("X", 1:4)  # X1-X4 not in matrix
  )

  expect_error(
    with_temp_png(plot_mtna(m, clusters)),
    "Nodes not found in x"
  )
})

test_that("plot_mtna() errors with invalid input type", {
  clusters <- list(
    A = paste0("N", 1:4),
    B = paste0("N", 5:8)
  )

  expect_error(
    with_temp_png(plot_mtna("invalid", clusters)),
    "x must be a cograph_network, tna object, or matrix"
  )
})

# ============================================
# COMMUNITY DETECTION TESTS
# ============================================

test_that("plot_mtna() works with community parameter (requires igraph)", {
  skip_if_not_installed("igraph")

  # Create symmetric matrix for community detection (some algorithms need undirected)
  set.seed(42)
  m <- matrix(runif(400, 0, 0.3), 20, 20)
  m <- (m + t(m)) / 2  # Make symmetric
  diag(m) <- 0
  colnames(m) <- rownames(m) <- paste0("N", 1:20)

  result <- safe_plot(plot_mtna(m, community = "louvain"))
  expect_true(result$success, info = result$error)
})

test_that("plot_mtna() works with walktrap community detection", {
  skip_if_not_installed("igraph")

  # Create symmetric matrix for community detection
  set.seed(42)
  m <- matrix(runif(400, 0, 0.3), 20, 20)
  m <- (m + t(m)) / 2
  diag(m) <- 0
  colnames(m) <- rownames(m) <- paste0("N", 1:20)

  result <- safe_plot(plot_mtna(m, community = "walktrap"))
  expect_true(result$success, info = result$error)
})

test_that("plot_mtna() works with fast_greedy community detection", {
  skip_if_not_installed("igraph")

  # Create symmetric matrix for community detection
  set.seed(42)
  m <- matrix(runif(400, 0, 0.3), 20, 20)
  m <- (m + t(m)) / 2
  diag(m) <- 0
  colnames(m) <- rownames(m) <- paste0("N", 1:20)

  result <- safe_plot(plot_mtna(m, community = "fast_greedy"))
  expect_true(result$success, info = result$error)
})

test_that("plot_mtna() works with label_prop community detection", {
  skip_if_not_installed("igraph")

  # Create network with clear community structure for label_prop
  set.seed(42)
  m <- matrix(0, 20, 20)
  # Create 4 dense clusters with sparse inter-cluster connections
  for (cluster in list(1:5, 6:10, 11:15, 16:20)) {
    m[cluster, cluster] <- runif(25, 0.5, 1.0)
  }
  # Sparse inter-cluster connections
  m[1, 6] <- m[6, 1] <- 0.1
  m[6, 11] <- m[11, 6] <- 0.1
  m[11, 16] <- m[16, 11] <- 0.1
  m <- (m + t(m)) / 2
  diag(m) <- 0
  colnames(m) <- rownames(m) <- paste0("N", 1:20)

  # label_prop may still sometimes find fewer clusters - wrap in tryCatch
  result <- tryCatch({
    safe_plot(plot_mtna(m, community = "label_prop"))
  }, error = function(e) {
    # If only 1 cluster is found, skip
    if (grepl("2\\+ character vectors", e$message)) {
      list(success = TRUE, error = NULL)  # Skip this case
    } else {
      list(success = FALSE, error = e$message)
    }
  })
  expect_true(result$success, info = result$error)
})

test_that("plot_mtna() works with infomap community detection", {
  skip_if_not_installed("igraph")

  # Create network with clear community structure for infomap
  set.seed(42)
  m <- matrix(0, 20, 20)
  # Create 4 dense clusters
  for (cluster in list(1:5, 6:10, 11:15, 16:20)) {
    m[cluster, cluster] <- runif(25, 0.5, 1.0)
  }
  # Sparse inter-cluster connections
  m[1, 6] <- 0.1
  m[6, 11] <- 0.1
  m[11, 16] <- 0.1
  m[16, 1] <- 0.1
  diag(m) <- 0
  colnames(m) <- rownames(m) <- paste0("N", 1:20)

  # infomap may also sometimes find fewer clusters - wrap in tryCatch
  result <- tryCatch({
    safe_plot(plot_mtna(m, community = "infomap"))
  }, error = function(e) {
    # If only 1 cluster is found, skip
    if (grepl("2\\+ character vectors", e$message)) {
      list(success = TRUE, error = NULL)  # Skip this case
    } else {
      list(success = FALSE, error = e$message)
    }
  })
  expect_true(result$success, info = result$error)
})

# ============================================
# MATRIX WITHOUT NAMES TESTS
# ============================================

test_that("plot_mtna() handles matrix without colnames", {
  set.seed(42)
  m <- matrix(runif(64, 0, 0.3), 8, 8)
  diag(m) <- 0
  # No row/col names - should use indices as labels

  clusters <- list(
    A = c("1", "2", "3", "4"),
    B = c("5", "6", "7", "8")
  )

  result <- safe_plot(plot_mtna(m, clusters))
  expect_true(result$success, info = result$error)
})

# ============================================
# UNNAMED CLUSTERS TESTS
# ============================================

test_that("plot_mtna() handles unnamed cluster list", {
  m <- create_clustered_matrix(8, 2)
  clusters <- list(
    paste0("N", 1:4),
    paste0("N", 5:8)
  )
  # No names on clusters

  result <- safe_plot(plot_mtna(m, clusters))
  expect_true(result$success, info = result$error)
})

# ============================================
# EDGE LABEL TESTS
# ============================================

test_that("plot_mtna() handles edge.labels parameter in summary mode", {
  m <- create_clustered_matrix(16, 4)
  clusters <- create_test_clusters(16, 4)

  # With edge labels
  result <- safe_plot(plot_mtna(m, clusters, summary_edges = TRUE, edge.labels = TRUE))
  expect_true(result$success, info = result$error)

  # Without edge labels
  result <- safe_plot(plot_mtna(m, clusters, summary_edges = TRUE, edge.labels = FALSE))
  expect_true(result$success, info = result$error)
})

test_that("plot_mtna() handles edge.label.cex parameter", {
  m <- create_clustered_matrix(16, 4)
  clusters <- create_test_clusters(16, 4)

  result <- safe_plot(plot_mtna(m, clusters, summary_edges = TRUE, edge.label.cex = 1.2))
  expect_true(result$success, info = result$error)
})

# ============================================
# EDGE WIDTH TESTS
# ============================================

test_that("plot_mtna() handles edge.lwd parameter", {
  m <- create_clustered_matrix(16, 4)
  clusters <- create_test_clusters(16, 4)

  result <- safe_plot(plot_mtna(m, clusters, edge.lwd = 2))
  expect_true(result$success, info = result$error)
})

# ============================================
# MINIMUM WEIGHT FILTER TESTS
# ============================================

test_that("plot_mtna() handles minimum weight filter", {
  m <- create_clustered_matrix(16, 4)
  clusters <- create_test_clusters(16, 4)

  result <- safe_plot(plot_mtna(m, clusters, summary_edges = TRUE, within_edges = TRUE, minimum = 0.1))
  expect_true(result$success, info = result$error)
})

# ============================================
# RETURN VALUE TESTS
# ============================================

test_that("plot_mtna() returns cluster_summary invisibly in summary mode", {
  m <- create_clustered_matrix(16, 4)
  clusters <- create_test_clusters(16, 4)

  result <- with_temp_png({
    ret <- plot_mtna(m, clusters, summary_edges = TRUE)
    ret
  })

  # Now returns cluster_summary invisibly per plan
  expect_s3_class(result, "cluster_summary")
})

test_that("plot_mtna() returns plot_tna result in non-summary mode", {
  m <- create_clustered_matrix(16, 4)
  clusters <- create_test_clusters(16, 4)

  result <- with_temp_png({
    ret <- plot_mtna(m, clusters, summary_edges = FALSE)
    ret
  })

  # In non-summary mode, returns whatever plot_tna returns (cograph_network)
  # This may be NULL if plot_tna returns invisibly
  # The key is that the function completes without error
  expect_true(TRUE)
})

# ============================================
# SPECIAL GEOMETRY TESTS
# ============================================

test_that("plot_mtna() handles edges from cluster to itself in summary mode", {
  # Create a matrix where diagonal clusters have internal edges
  m <- create_clustered_matrix(8, 2)
  clusters <- list(
    A = paste0("N", 1:4),
    B = paste0("N", 5:8)
  )

  # Within-cluster edges should be displayed with within_edges = TRUE
  result <- safe_plot(plot_mtna(m, clusters, summary_edges = TRUE, within_edges = TRUE))
  expect_true(result$success, info = result$error)
})

test_that("plot_mtna() handles zero-weight inter-cluster edges", {
  set.seed(42)
  m <- matrix(0, 8, 8)
  colnames(m) <- rownames(m) <- paste0("N", 1:8)
  # Only within-cluster edges
  m[1:4, 1:4] <- runif(16, 0.1, 0.3)
  m[5:8, 5:8] <- runif(16, 0.1, 0.3)
  diag(m) <- 0

  clusters <- list(
    A = paste0("N", 1:4),
    B = paste0("N", 5:8)
  )

  result <- safe_plot(plot_mtna(m, clusters, summary_edges = TRUE))
  expect_true(result$success, info = result$error)
})

# ============================================
# SHELL EDGE POINT GEOMETRY TESTS
# ============================================

test_that("plot_mtna() handles edge points on circle border", {
  m <- create_clustered_matrix(8, 2)
  clusters <- list(
    A = paste0("N", 1:4),
    B = paste0("N", 5:8)
  )

  result <- safe_plot(plot_mtna(m, clusters, shapes = c("circle", "circle")))
  expect_true(result$success, info = result$error)
})

test_that("plot_mtna() handles edge points on square border", {
  m <- create_clustered_matrix(8, 2)
  clusters <- list(
    A = paste0("N", 1:4),
    B = paste0("N", 5:8)
  )

  result <- safe_plot(plot_mtna(m, clusters, shapes = c("square", "square")))
  expect_true(result$success, info = result$error)
})

test_that("plot_mtna() handles edge points on diamond border", {
  m <- create_clustered_matrix(8, 2)
  clusters <- list(
    A = paste0("N", 1:4),
    B = paste0("N", 5:8)
  )

  result <- safe_plot(plot_mtna(m, clusters, shapes = c("diamond", "diamond")))
  expect_true(result$success, info = result$error)
})

test_that("plot_mtna() handles edge points on triangle border", {
  m <- create_clustered_matrix(8, 2)
  clusters <- list(
    A = paste0("N", 1:4),
    B = paste0("N", 5:8)
  )

  result <- safe_plot(plot_mtna(m, clusters, shapes = c("triangle", "triangle")))
  expect_true(result$success, info = result$error)
})

# ============================================
# COMBINATIONS OF PARAMETERS TESTS
# ============================================

test_that("plot_mtna() handles combined visual customizations", {
  m <- create_clustered_matrix(16, 4)
  clusters <- create_test_clusters(16, 4)

  result <- safe_plot(plot_mtna(m, clusters,
    layout = "grid",
    spacing = 5,
    shape_size = 2,
    node_spacing = 0.6,
    colors = c("lightblue", "lightgreen", "lightyellow", "lightpink"),
    shapes = c("circle", "square", "diamond", "triangle"),
    curvature = 0.2,
    node_size = 4,
    legend = TRUE,
    legend_position = "bottomleft"
  ))
  expect_true(result$success, info = result$error)
})

test_that("plot_mtna() handles summary mode with all aggregation types", {
  m <- create_clustered_matrix(12, 3)
  clusters <- list(
    A = paste0("N", 1:4),
    B = paste0("N", 5:8),
    C = paste0("N", 9:12)
  )

  agg_methods <- c("sum", "mean", "max", "min", "median", "density")

  for (method in agg_methods) {
    result <- safe_plot(plot_mtna(m, clusters,
      summary_edges = TRUE,
      within_edges = TRUE,
      aggregation = method
    ))
    expect_true(result$success, info = paste("Aggregation", method, "failed:", result$error))
  }
})

# ============================================
# LARGE NETWORK TESTS
# ============================================

test_that("plot_mtna() handles moderately large networks", {
  m <- create_clustered_matrix(50, 5)
  clusters <- create_test_clusters(50, 5)

  result <- safe_plot(plot_mtna(m, clusters))
  expect_true(result$success, info = result$error)
})

# ============================================
# SPARSE NETWORK TESTS
# ============================================

test_that("plot_mtna() handles sparse networks", {
  set.seed(42)
  m <- matrix(0, 16, 16)
  colnames(m) <- rownames(m) <- paste0("N", 1:16)
  # Only a few edges
  m[1, 5] <- 0.5
  m[5, 9] <- 0.3
  m[9, 13] <- 0.4

  clusters <- create_test_clusters(16, 4)

  result <- safe_plot(plot_mtna(m, clusters))
  expect_true(result$success, info = result$error)
})

# ============================================
# WEIGHTED NETWORK TESTS
# ============================================

test_that("plot_mtna() correctly visualizes weight differences", {
  set.seed(42)
  m <- matrix(runif(64, 0, 1), 8, 8)
  diag(m) <- 0
  colnames(m) <- rownames(m) <- paste0("N", 1:8)

  clusters <- list(
    High = paste0("N", 1:4),  # These will have high inter-cluster weights
    Low = paste0("N", 5:8)
  )

  # Make inter-cluster weights high
  m[1:4, 5:8] <- runif(16, 0.7, 1.0)

  result <- safe_plot(plot_mtna(m, clusters, summary_edges = TRUE))
  expect_true(result$success, info = result$error)
})

# ============================================
# COMPLETE GRAPH TEST
# ============================================

test_that("plot_mtna() handles complete graph with clusters", {
  set.seed(42)
  m <- matrix(runif(64, 0.1, 0.5), 8, 8)
  diag(m) <- 0
  colnames(m) <- rownames(m) <- paste0("N", 1:8)

  clusters <- list(
    A = paste0("N", 1:4),
    B = paste0("N", 5:8)
  )

  result <- safe_plot(plot_mtna(m, clusters))
  expect_true(result$success, info = result$error)
})