#
# GAMS - General Algebraic Modeling System R API
#
# Copyright (c) 2017-2024 GAMS Software GmbH <support@gams.com>
# Copyright (c) 2017-2024 GAMS Development Corp. <support@gams.com>
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in all
# copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
#

library(gamstransfer)


gams_checked <- -1
skip_if_no_gams <- function() {
  if (gams_checked == -1) {
    ret <- system2(command = "gams", stdout = NULL, stderr = NULL)
    if (ret == 127) {
      gams_checked <- 0
    } else {
      gams_checked <- 1
    }
  }

  if (gams_checked == 0) {
    testthat::skip("GAMS Unavailable")
  }
}

test_that("readwritetest", {
  skip_if_no_gams()
  m <- Container$new()

  # read all symbols
  m$read(testthat::test_path("testdata", "biggdxtest.gdx"))

  # test supercall read
  rl <- readGDX(testthat::test_path("testdata", "biggdxtest.gdx"))
  m2 <- Container$new()
  m2$readList(rl)

  expect_equal(m$equals(m2), TRUE)

  # write everything
  m$write(testthat::test_path("gt.gdx"))

  ret <- system2(
    command = "gdxdiff", args =
      paste0(testthat::test_path("testdata", "biggdxtest.gdx"), " ", testthat::test_path("gt.gdx")),
    stdout = FALSE
  )
  expect_equal(ret, 0)

  # write everything
  m$write(testthat::test_path("gt.gdx"), mode = "string")

  ret <- system2(
    command = "gdxdiff", args =
      paste0(testthat::test_path("testdata", "biggdxtest.gdx"), " ", testthat::test_path("gt.gdx")),
    stdout = FALSE
  )
  expect_equal(ret, 0)

  # test the super call write
  writeList <- m$asList()
  writeGDX(writeList, "gt.gdx")

  ret <- system2(
    command = "gdxdiff", args =
      paste0(testthat::test_path("testdata", "biggdxtest.gdx"), " ", testthat::test_path("gt.gdx")),
    stdout = FALSE
  )
  expect_equal(ret, 0)

  # test the super call write from the read super call
  writeGDX(rl, "gt.gdx")

  ret <- system2(
    command = "gdxdiff", args =
      paste0(testthat::test_path("testdata", "biggdxtest.gdx"), " ", testthat::test_path("gt.gdx")),
    stdout = FALSE
  )
  expect_equal(ret, 0)
})


test_that("test_num_1", {
  skip_if_no_gams()
  m <- Container$new()
  expect_true(inherits(m, "Container"))

  i <- Set$new(m, "i", records = c("a", "b"))
  expect_true(is.data.frame(i$records))
  expect_equal(nrow(i$records), 2)

  j <- Set$new(m, "j", records = c("c", "d"))
  expect_true(is.data.frame(j$records))
  expect_equal(nrow(j$records), 2)

  recs <- data.frame(list(
    "i" = c("a", "b"),
    "j" = c("c", "d"), "values" = c(1, 1)
  ))
  a <- Parameter$new(m, "a", c("i", "j"), records = recs)
  expect_true(is.data.frame(a$records))
  expect_equal(nrow(a$records), 2)

  m$write("gt.gdx")

  ret <- system2(
    command = "gdxdiff", args =
      paste0(testthat::test_path("testdata", "test1.gdx"), " ", testthat::test_path("gt.gdx")),
    stdout = FALSE
  )

  expect_equal(ret, 0)

  m$write("gt.gdx", mode = "string")

  ret <- system2(
    command = "gdxdiff", args =
      paste0(testthat::test_path("testdata", "test1.gdx"), " ", testthat::test_path("gt.gdx")),
    stdout = FALSE
  )

  expect_equal(ret, 0)

  # test the super call write
  writeList <- m$asList()
  writeGDX(writeList, "gt.gdx")

  ret <- system2(
    command = "gdxdiff", args =
      paste0(testthat::test_path("testdata", "test1.gdx"), " ", testthat::test_path("gt.gdx")),
    stdout = FALSE
  )
  expect_equal(ret, 0)
})

test_that("test_num_2", {
  skip_if_no_gams()
  m <- Container$new()
  expect_true(inherits(m, "Container"))

  i <- Set$new(m, "i")
  expect_true(is.null(i$records))

  j <- Set$new(m, "j")
  expect_true(is.null(j$records))

  recs <- data.frame(list(
    "i" = c("a", "b"),
    "j" = c("c", "d"), "values" = c(1, 1)
  ))
  a <- Parameter$new(m, "a", c(i, j), recs, domainForwarding = TRUE)

  expect_true(is.data.frame(i$records))
  expect_equal(as.character(i$records$uni), c("a", "b"))

  expect_true(is.data.frame(j$records))
  expect_equal(as.character(j$records$uni), c("c", "d"))

  m$write("gt.gdx")

  ret <- system2(
    command = "gdxdiff", args =
      paste0(testthat::test_path("testdata", "test2.gdx"), " ", testthat::test_path("gt.gdx")),
    stdout = FALSE
  )

  expect_equal(ret, 0)

  m$write("gt.gdx", mode = "string")

  ret <- system2(
    command = "gdxdiff", args =
      paste0(testthat::test_path("testdata", "test2.gdx"), " ", testthat::test_path("gt.gdx")),
    stdout = FALSE
  )

  expect_equal(ret, 0)

  # test the super call write
  writeList <- m$asList()
  writeGDX(writeList, "gt.gdx")

  ret <- system2(
    command = "gdxdiff", args =
      paste0(testthat::test_path("testdata", "test2.gdx"), " ", testthat::test_path("gt.gdx")),
    stdout = FALSE
  )
  expect_equal(ret, 0)
})

test_that("test_num_3", {
  skip_if_no_gams()
  m <- Container$new()
  expect_true(inherits(m, "Container"))

  i <- Set$new(m, "i")
  expect_true(is.null(i$records))

  j <- Alias$new(m, "j", i)
  expect_true(is.null(j$records))

  recs <- data.frame(list(
    "i" = c("a", "b"),
    "j" = c("a", "b"), "values" = c(1, 1)
  ))
  a <- Parameter$new(m, "a", c(i, j), recs, domainForwarding = TRUE)

  expect_true(is.data.frame(i$records))
  expect_equal(as.character(i$records$uni), c("a", "b"))

  expect_true(is.data.frame(j$records))
  expect_equal(as.character(j$records$uni), c("a", "b"))
  expect_equal(nrow(a$records), 2)

  m$write("gt.gdx")

  ret <- system2(
    command = "gdxdiff", args =
      paste0(testthat::test_path("testdata", "test3.gdx"), " ", testthat::test_path("gt.gdx")),
    stdout = FALSE
  )

  expect_equal(ret, 0)

  m$write("gt.gdx", mode = "string")

  ret <- system2(
    command = "gdxdiff", args =
      paste0(testthat::test_path("testdata", "test3.gdx"), " ", testthat::test_path("gt.gdx")),
    stdout = FALSE
  )

  expect_equal(ret, 0)

  # test the super call write
  writeList <- m$asList()
  writeGDX(writeList, "gt.gdx")

  ret <- system2(
    command = "gdxdiff", args =
      paste0(testthat::test_path("testdata", "test3.gdx"), " ", testthat::test_path("gt.gdx")),
    stdout = FALSE
  )
  expect_equal(ret, 0)
})

test_that("test_num_4", {
  skip_if_no_gams()
  m <- Container$new()

  i <- Set$new(m, "i")
  expect_true(is.null(i$records))

  j <- Set$new(m, "j", i)
  expect_true(is.null(j$records))

  k <- Set$new(m, "k", j)
  expect_true(is.null(k$records))

  l <- Set$new(m, "l", k, records = c("a", "b"), domainForwarding = TRUE)
  expect_true(is.data.frame(i$records))
  expect_equal(as.character(i$records$uni), c("a", "b"))

  expect_true(is.data.frame(j$records))
  expect_equal(as.character(j$records$i), c("a", "b"))

  expect_true(is.data.frame(k$records))
  expect_equal(as.character(k$records$j), c("a", "b"))

  expect_true(is.data.frame(l$records))
  expect_equal(as.character(l$records$k), c("a", "b"))

  m$write("gt.gdx")

  ret <- system2(
    command = "gdxdiff", args =
      paste0(testthat::test_path("testdata", "test4.gdx"), " ", testthat::test_path("gt.gdx")),
    stdout = FALSE
  )

  expect_equal(ret, 0)

  m$write("gt.gdx", mode = "string")

  ret <- system2(
    command = "gdxdiff", args =
      paste0(testthat::test_path("testdata", "test4.gdx"), " ", testthat::test_path("gt.gdx")),
    stdout = FALSE
  )

  expect_equal(ret, 0)

  # test the super call write
  writeList <- m$asList()
  writeGDX(writeList, "gt.gdx")

  ret <- system2(
    command = "gdxdiff", args =
      paste0(testthat::test_path("testdata", "test4.gdx"), " ", testthat::test_path("gt.gdx")),
    stdout = FALSE
  )
  expect_equal(ret, 0)
})

test_that("test_num_5", {
  skip_if_no_gams()
  m <- Container$new()
  expect_true(inherits(m, "Container"))

  i <- Set$new(m, "i")
  expect_true(is.null(i$records))

  recs <- data.frame(list("i" = "c", "element_text" = "desc for elem 'c'"))
  j <- Set$new(m, "j", i, records = recs, domainForwarding = TRUE)
  expect_true(is.data.frame(i$records))
  expect_equal(as.character(i$records$uni), c("c"))
  expect_true(is.data.frame(j$records))
  expect_equal(as.character(j$records$i), c("c"))

  k <- Set$new(m, "k", j)
  expect_true(is.data.frame(i$records))
  expect_equal(as.character(i$records$uni), c("c"))
  expect_true(is.data.frame(j$records))
  expect_equal(as.character(j$records$i), c("c"))
  expect_true(is.null(k$records))

  l <- Set$new(m, "l", k, records = c("a", "b"), domainForwarding = TRUE)
  expect_true(is.data.frame(i$records))
  expect_equal(as.character(i$records$uni), c("c", "a", "b"))
  expect_true(is.data.frame(j$records))
  expect_equal(as.character(j$records$i), c("c", "a", "b"))

  expect_true(is.data.frame(k$records))
  expect_equal(as.character(k$records$j), c("a", "b"))

  expect_true(is.data.frame(l$records))
  expect_equal(as.character(l$records$k), c("a", "b"))

  m$write("gt.gdx")

  ret <- system2(
    command = "gdxdiff", args =
      paste0(testthat::test_path("testdata", "test5.gdx"), " ", testthat::test_path("gt.gdx")),
    stdout = FALSE
  )

  expect_equal(ret, 0)

  m$write("gt.gdx", mode = "string")

  ret <- system2(
    command = "gdxdiff", args =
      paste0(testthat::test_path("testdata", "test5.gdx"), " ", testthat::test_path("gt.gdx")),
    stdout = FALSE
  )

  expect_equal(ret, 0)

  # test the super call write
  writeList <- m$asList()
  writeGDX(writeList, "gt.gdx")

  ret <- system2(
    command = "gdxdiff", args =
      paste0(testthat::test_path("testdata", "test5.gdx"), " ", testthat::test_path("gt.gdx")),
    stdout = FALSE
  )
  expect_equal(ret, 0)
})

test_that("test_num_6", {
  m <- Container$new()
  expect_true(inherits(m, "Container"))

  i <- Set$new(m, "i", records = c("c", "a", "b"))
  expect_true(is.data.frame(i$records))
  m$write("gt.gdx")
  m$write("gt.gdx", mode = "string")
  m2 <- Container$new(testthat::test_path("testdata", "test6_uels.gdx"))
  expect_true(inherits(m2, "Container"))
  expect_true(is.data.frame(m2["foo"]$records))

  expect_equal(as.character(m$getUELs()), as.character(m2["foo"]$records$uni))

  # test supercall read
  rl <- readGDX(testthat::test_path("testdata", "test6_uels.gdx"))
  m3 <- Container$new()
  m3$readList(rl)
  expect_equal(m2$equals(m3), TRUE)
})

test_that("test_num_7", {
  m <- Container$new()
  expect_true(inherits(m, "Container"))

  i <- Set$new(m, "i", records = c("c", "a", "b"))
  expect_true(is.data.frame(i$records))

  m$write("gt.gdx", uelPriority = "a")
  m$write("gt.gdx", uelPriority = "a", mode = "string")

  m2 <- Container$new(testthat::test_path("testdata", "test7_uels.gdx"))
  expect_true(inherits(m2, "Container"))
  expect_true(is.data.frame(m2["foo"]$records))

  expect_equal(c("a", "c", "b"), as.character(m2["foo"]$records$uni))

  # test supercall read
  rl <- readGDX(testthat::test_path("testdata", "test7_uels.gdx"))
  m3 <- Container$new()
  m3$readList(rl)
  expect_equal(m2$equals(m3), TRUE)
})

test_that("test_num_8", {
  m <- Container$new()
  expect_true(inherits(m, "Container"))

  i <- Set$new(m, "i", records = c("a", "b"))
  expect_equal(as.character(i$records$uni), c("a", "b"))

  j <- Alias$new(m, "j", i)
  expect_equal(as.character(j$records$uni), c("a", "b"))
  expect_equal(j$aliasWith$name, "i")

  k <- Alias$new(m, "k", j)
  expect_equal(as.character(k$records$uni), c("a", "b"))
  expect_equal(j$aliasWith$name, "i")

  # try writing
  m$write("out.gdx")
  m$write("out.gdx", mode = "string")
  # test the super call write
  writeList <- m$asList()
  writeGDX(writeList, "out.gdx")
})

test_that("test_num_9", {
  m <- Container$new()
  expect_true(inherits(m, "Container"))

  i <- Set$new(m, "i", list("*", "*"),
    records =
      data.frame(list("col1" = c("a", "b"), "col2" = c("c", "d")))
  )

  j <- Parameter$new(m, "j", "*",
    records =
      data.frame(list("col1" = c("e", "f"), "col2" = c(1, 1)))
  )
  expect_equal(as.character(i$records$col1), c("a", "b"))
  expect_equal(as.character(i$records$col2), c("c", "d"))

  expect_equal(as.character(m$getUELs()), c("a", "b", "c", "d", "e", "f"))

  # just try writing to see if there are any errors
  m$write("out.gdx")
  m$write("out.gdx", mode = "string")
  # test the super call write
  writeList <- m$asList()
  writeGDX(writeList, "out.gdx")
})

test_that("test_num_10", {
  m <- Container$new()
  expect_true(inherits(m, "Container"))

  i <- Set$new(m, "i")
  expect_true(is.null(i$records))

  j <- Set$new(m, "j")
  expect_true(is.null(j$records))

  a <- Parameter$new(m, "a", list(i, j), domainForwarding = TRUE)

  df <- data.frame(
    "i" = c("a", "b"),
    "j" = c("c", "d"), "value" = c(1, 1)
  )

  a$records <- df
  expect_false(a$isValid())

  df <- data.frame(
    "i" = factor(c("a", "b")),
    "j" = factor(c("c", "d")), "value" = c(1, 1)
  )

  a$records <- df
  expect_true(a$isValid())

  expect_equal(as.character(i$records$uni), c("a", "b"))
  expect_equal(as.character(j$records$uni), c("c", "d"))

  # try writing
  m$write("out.gdx")
  m$write("out.gdx", mode = "string")
  # test the super call write
  writeList <- m$asList()
  writeGDX(writeList, "gt.gdx")
})

test_that("test_num_11", {
  m <- Container$new()
  expect_true(inherits(m, "Container"))

  i <- Set$new(m, "i", records = c("a", "b", "c"))
  expect_equal(as.character(i$records$uni), c("a", "b", "c"))


  j <- Parameter$new(m, "j", i,
    records = data.frame("j" = c("a", "c"), "val" = c(1, 2))
  )
  expect_equal(as.character(j$records$j), c("a", "c"))
  expect_equal(j$records$value, c(1, 2))

  m$removeSymbols(c("i", "j"))

  i <- Set$new(m, "i", records = c("a", "b", "c", "d"))
  j <- Parameter$new(m, "j", i,
    records = data.frame("i" = c("a", "c"), "val" = c(1, 2))
  )
  expect_equal(j$toDense(), array(c(1, 0, 2, 0)))
  m$write("out.gdx")
  m$write("out.gdx", mode = "string")
  # test the super call write
  writeList <- m$asList()
  writeGDX(writeList, "out.gdx")
})

test_that("test_num_12", {
  testthat::expect_warning(Container$new(testthat::test_path("testdata", "test12.gdx")))
})

test_that("test_num_13", {
  m <- Container$new()
  i <- Set$new(m, "i", records = c("a", "b", "c"))
  j <- Set$new(m, "j", records = c("d", "e", "f"))
  a <- Parameter$new(m, "a", i, records = data.frame("i" = c("a", "c"), "val" = c(1, 2)))
  b <- Parameter$new(m, "b", j, records = data.frame("j" = c("e", "f"), "val" = c(1, 2)))

  m$removeSymbols("i")
  expect_equal(unlist(m$data$keys()), c("j", "a", "b"))

  m$removeSymbols(c("a", "b"))
  expect_equal(unlist(m$data$keys()), c("j"))

  m$write("out.gdx")
  m$write("out.gdx", mode = "string")
  # test the super call write
  writeList <- m$asList()
  writeGDX(writeList, "out.gdx")
})


test_that("test_num_14", {
  m <- Container$new()
  i <- Set$new(m, "i", records = c("a", "b", "c"))

  expect_equal(unlist(m$data$keys()), c("i"))

  m$renameSymbol("i", "h")
  expect_equal(unlist(m$data$keys()), c("h"))

  m$write("out.gdx")
  m$write("out.gdx", mode = "string")
  # test the super call write
  writeList <- m$asList()
  writeGDX(writeList, "out.gdx")
})

# test_that("test_num_15", {
#   m  = Container$new()
#   i = Set$new(m, "i", records=c("a", "b", "c"))
#   a = Parameter$new(m, "a", i, records=data.frame(c("aa", "c"), c(1, 2)))

#   expect_equal(a$findDomainViolations(), 1)
#     expect_equal(a$isValid(), FALSE)
# }
# )

test_that("test_num_16", {
  m <- Container$new()
  i <- Set$new(m, "i")
  j <- Set$new(m, "j", i, records = c("a", "b"), domainForwarding = TRUE)
  k <- Set$new(m, "k")
  l <- Set$new(m, "l", k, records = c("c"), domainForwarding = TRUE)
  a <- Parameter$new(m, "a", l, records = data.frame(c("aa", "c"), c(1, 2)), domainForwarding = TRUE)

  # check container
  expect_equal(m$.requiresStateCheck, TRUE)
  expect_equal(m$isValid(), TRUE)
  expect_equal(m$.requiresStateCheck, FALSE)

  expect_equal(as.character(m["l"]$records$k), c("c", "aa"))
  expect_equal(as.character(m["k"]$records$uni), c("c", "aa"))
  expect_equal(as.character(m["j"]$records$i), c("a", "b"))
  expect_equal(as.character(m["i"]$records$uni), c("a", "b"))

  expect_equal(as.character(m$getUELs()), c("a", "b", "c", "aa"))
  expect_equal(a$isValid(), TRUE)
  expect_equal(l$isValid(), TRUE)
})

test_that("test_num_17", {
  m <- Container$new()
  m$addSet("i")
  m$addSet("j", m["i"], records = c("a", "b"), domainForwarding = TRUE)
  m$addSet("k")
  m$addSet("l", m["k"], records = c("c"), domainForwarding = TRUE)

  m$addParameter("a", m["l"], records = data.frame(c("aa", "c"), c(1, 2)), domainForwarding = TRUE)

  # check container
  expect_equal(m$.requiresStateCheck, TRUE)
  expect_equal(m$isValid(), TRUE)
  expect_equal(m$.requiresStateCheck, FALSE)

  expect_equal(as.character(m["l"]$records$k), c("c", "aa"))
  expect_equal(as.character(m["k"]$records$uni), c("c", "aa"))
  expect_equal(as.character(m["j"]$records$i), c("a", "b"))
  expect_equal(as.character(m["i"]$records$uni), c("a", "b"))

  expect_equal(as.character(m$getUELs()), c("a", "b", "c", "aa"))

  expect_equal(m$listSymbols(isValid = FALSE), NULL)
})

test_that("test_num_18", {
  m <- Container$new()
  df <- data.frame("domain" = c("i0"))

  types <- c(
    "binary",
    "integer",
    "positive",
    "negative",
    "free",
    "sos1",
    "sos2",
    "semicont",
    "semiint"
  )

  for (i in types) {
    varname <- paste0("a_", i)
    m$addVariable(varname, i, "*", records = df)

    expect_equal(
      colnames(m[varname]$records),
      c("domain")
    )
  }
})

test_that("test_num_19", {
  m <- Container$new()
  df <- data.frame("domain" = c("i0"))

  types <- c(
    "eq", "geq", "leq", "nonbinding", "cone", "external", "boolean"
  )

  for (i in types) {
    eqname <- paste0("a_", i)
    m$addEquation(eqname, i, "*", records = df)

    expect_equal(
      colnames(m[eqname]$records),
      c("domain")
    )
  }
})

test_that("test_num_20", {
  m <- Container$new()
  df <- data.frame(list("i0", 1, 1, 1, 1, 1))
  colnames(df) <- c("domain", "marginal", "lower", "scale", "upper", "level")

  type <- c(
    "binary",
    "integer",
    "positive",
    "negative",
    "free",
    "sos1",
    "sos2",
    "semicont",
    "semiint"
  )

  for (i in type) {
    varname <- paste0("a_", i)
    m$addVariable(varname, i, "*", records = df)
    expect_equal(
      colnames(m[varname]$records),
      c("domain", "level", "marginal", "lower", "upper", "scale")
    )
  }
})

test_that("test_num_21", {
  m <- Container$new()
  df <- data.frame(list("i0", 1, 1, 1, 1, 1))
  colnames(df) <- c("domain", "marginal", "lower", "scale", "upper", "level")

  type <- c(
    "eq", "geq", "leq", "nonbinding", "cone", "external", "boolean"
  )

  for (i in type) {
    eqname <- paste0("a_", i)
    m$addEquation(eqname, i, "*", records = df)
    expect_equal(
      colnames(m[eqname]$records),
      c("domain", "level", "marginal", "lower", "upper", "scale")
    )
  }
})


test_that("test_num_22", {
  m <- Container$new()
  m$read(testthat::test_path("testdata", "trnsport.gdx"), records = FALSE)

  # test supercall read
  rl <- readGDX(testthat::test_path("testdata", "trnsport.gdx"),
    records = FALSE
  )
  m2 <- Container$new()
  m2$readList(rl)

  expect_equal(m$equals(m2), TRUE)

  for (i in m$data$values()) {
    expect_equal(m[i$name]$records, NULL)
  }
})


test_that("test_num_23", {
  m <- Container$new()
  m$read(testthat::test_path("testdata", "trnsport.gdx"), c("i", "j", "x"))

  # test supercall read
  rl <- readGDX(testthat::test_path("testdata", "trnsport.gdx"),
    symbols = c("i", "j", "x")
  )
  m2 <- Container$new()
  m2$readList(rl)
  expect_equal(m$equals(m2), TRUE)

  expect_equal(m["i"]$domainType, "none")
  expect_equal(m["j"]$domainType, "none")
  expect_equal(m["x"]$domainType, "regular")
})

test_that("test_num_24", {
  m <- Container$new()
  m$read(testthat::test_path("testdata", "trnsport.gdx"), c("x"))
  # test supercall read
  rl <- readGDX(testthat::test_path("testdata", "trnsport.gdx"),
    symbols = c("x")
  )
  m2 <- Container$new()
  m2$readList(rl)
  expect_equal(m$equals(m2), TRUE)

  expect_equal(unlist(m$data$keys()), "x")
  expect_equal(m["x"]$domainType, "relaxed")
})

test_that("test_num_25", {
  m <- Container$new(testthat::test_path("testdata", "test25.gdx"))

  expect_equal(unlist(m$data$keys()), "i")
  expect_equal(m["i"]$domain, c("i"))
  expect_equal(m["i"]$domainType, "relaxed")

  # test supercall read
  rl <- readGDX(testthat::test_path("testdata", "test25.gdx"))
  m2 <- Container$new()
  m2$readList(rl)
  expect_equal(m$equals(m2), TRUE)
})


test_that("test_num_26", {
  m <- Container$new()
  i <- Set$new(m, "i", "p")
  expect_equal(i$domainType, "relaxed")

  j <- Set$new(m, "j", i,
    records =
      data.frame(i = c("c"), c("desc for elem 'c'")), domainForwarding = TRUE
  )

  df <- data.frame("p" = c("c"))
  df$p <- factor(df$p, ordered = TRUE)
  expect_equal(i$records, df)

  df <- data.frame("i" = c("c"), "element_text" = c("desc for elem 'c'"))
  df$i <- factor(df$i, ordered = TRUE)
  expect_equal(j$records, df)

  k <- Set$new(m, "k", "j")
  expect_equal(k$records, NULL)

  l <- Set$new(m, "l", k, records = c("a", "b"), domainForwarding = TRUE)

  # test l
  df <- data.frame("k" = c("a", "b"))
  df$k <- factor(df$k, ordered = TRUE)
  expect_equal(l$records, df)

  # test k
  df <- data.frame("j" = c("a", "b"))
  df$j <- factor(df$j, ordered = TRUE)
  expect_equal(k$records, df)

  # test j
  df <- data.frame("i" = c("c"), "element_text" = c("desc for elem 'c'"))
  df$i <- factor(df$i, ordered = TRUE)
  expect_equal(j$records, df)

  # test i
  df <- data.frame("p" = c("c"))
  df$p <- factor(df$p, ordered = TRUE)
  expect_equal(i$records, df)
})

test_that("test_num_27", {
  skip_if_no_gams()
  m <- Container$new()
  m$read(testthat::test_path("testdata", "test27.gdx"))

  # test supercall read
  rl <- readGDX(testthat::test_path("testdata", "test27.gdx"))
  m2 <- Container$new()
  m2$readList(rl)
  expect_equal(m$equals(m2), TRUE)

  # write everything
  m$write(testthat::test_path("gt.gdx"))

  ret <- system2(
    command = "gdxdiff", args =
      paste0(testthat::test_path("testdata", "test27.gdx"), " ", testthat::test_path("gt.gdx")),
    stdout = FALSE
  )
  expect_equal(ret, 0)

  # write everything
  m$write(testthat::test_path("gt.gdx"), mode = "string")

  ret <- system2(
    command = "gdxdiff", args =
      paste0(testthat::test_path("testdata", "test27.gdx"), " ", testthat::test_path("gt.gdx")),
    stdout = FALSE
  )
  expect_equal(ret, 0)

  # test the super call write
  writeList <- m$asList()
  writeGDX(writeList, "gt.gdx")

  ret <- system2(
    command = "gdxdiff", args =
      paste0(testthat::test_path("testdata", "test27.gdx"), " ", testthat::test_path("gt.gdx")),
    stdout = FALSE
  )
  expect_equal(ret, 0)
})

test_that("test_num_28", {
  m <- Container$new()

  i <- Set$new(m, "i")
  a_eq <- Equation$new(m, "a_eq", "eq", i)
  a_geq <- Equation$new(m, "a_geq", "geq", i)
  a_leq <- Equation$new(m, "a_leq", "leq", i)
  a_nonbinding <- Equation$new(m, "a_nonbinding", "nonbinding", i)
  a_cone <- Equation$new(m, "a_cone", "cone", i)
  a_external <- Equation$new(m, "a_external", "external", i)
  a_boolean <- Equation$new(m, "a_boolean", "boolean", i)
  # try writing

  expect_equal(m$write("gt.gdx"), NULL)
  expect_equal(m$write("gt.gdx", mode = "string"), NULL)
  # test the super call write
  writeList <- m$asList()
  writeGDX(writeList, "gt.gdx")
})

test_that("test_num_29", {
  m <- Container$new()

  i <- Set$new(m, "i")
  a_binary <- Variable$new(m, "a_binary", "binary", i)
  a_integer <- Variable$new(m, "a_integer", "integer", i)
  a_positive <- Variable$new(m, "a_positive", "positive", i)
  a_negative <- Variable$new(m, "a_negative", "negative", i)
  a_free <- Variable$new(m, "a_free", "free", i)
  a_sos1 <- Variable$new(m, "a_sos1", "sos1", i)
  a_sos2 <- Variable$new(m, "a_sos2", "sos2", i)
  a_semicont <- Variable$new(m, "a_semicont", "semicont", i)
  a_semiint <- Variable$new(m, "a_semiint", "semiint", i)

  # try writing
  expect_equal(m$write("gt.gdx"), NULL)
  expect_equal(m$write("gt.gdx", mode = "string"), NULL)
  # test the super call write
  writeList <- m$asList()
  writeGDX(writeList, "gt.gdx")
})

test_that("test_num_30", {
  m <- Container$new()
  i <- Set$new(m, "i")

  a <- Parameter$new(m, "a", i)
  # try writing
  expect_equal(m$write("gt.gdx"), NULL)
  expect_equal(m$write("gt.gdx", mode = "string"), NULL)
  # test the super call write
  writeList <- m$asList()
  writeGDX(writeList, "gt.gdx")
})

test_that("test_num_31", {
  m <- Container$new()
  i <- Set$new(m, "i", "j")
  j <- Set$new(m, "j", "i")

  a <- Parameter$new(m, "a", c(i, j))
  m$removeSymbols("j")
  j <- Set$new(m, "j", "i")
  expect_true(a$isValid(verbose = TRUE))
})

test_that("test_num_32", {
  m <- Container$new()
  i <- Set$new(m, "i")
  m$isValid()

  expect_equal(m$.requiresStateCheck, FALSE)

  j <- Set$new(m, "j")

  expect_true(m$.requiresStateCheck)
})

test_that("test_num_33", {
  m <- Container$new()
  i <- Set$new(m, "i")
  j <- Set$new(m, "j")
  k <- Set$new(m, "k")

  i$domain <- j
  j$domain <- k
  k$domain <- i

  expect_error(m$.__enclos_env__$private$validSymbolOrder())
})

test_that("test_num_34", {
  m <- Container$new()
  i <- Set$new(m, "i")
  j <- Alias$new(m, "j", i)
  j$setRecords(c("a", "b"))
  df <- data.frame("uni" = c("a", "b"))
  df$uni <- factor(df$uni, ordered = TRUE)

  expect_equal(i$records, df)
})

test_that("test_num_35", {
  m <- Container$new()
  i <- Set$new(m, "i")
  j <- Alias$new(m, "j", i)
  j$description <- "just a test"
  expect_equal(i$description, "just a test")
})

test_that("test_num_36", {
  m <- Container$new()
  i <- Set$new(m, "i")
  k <- Set$new(m, "k")
  j <- Alias$new(m, "j", i)
  j$domain <- c(k, k)
  expect_equal(i$domainNames, c("k", "k"))
})

test_that("test_num_37", {
  m <- Container$new()
  i <- Set$new(m, "i")
  j <- Alias$new(m, "j", i)
  j$isSingleton <- TRUE
  expect_equal(i$isSingleton, TRUE)
})

test_that("test_num_38", {
  m <- Container$new()
  i <- Set$new(m, "i")

  expect_equal(i$dimension, 1)
  expect_equal(i$domain, c("*"))

  i$dimension <- 2
  expect_equal(i$dimension, 2)
  expect_equal(i$domain, c("*", "*"))

  i$dimension <- 0
  expect_equal(i$dimension, 0)
  expect_equal(i$domain, list())

  a <- Parameter$new(m, "a")
  expect_equal(a$dimension, 0)
  expect_equal(a$domain, list())
  expect_equal(a$isScalar, TRUE)

  a$dimension <- 2
  expect_equal(a$domain, list("*", "*"))
  expect_equal(a$isScalar, FALSE)

  a$dimension <- 0
  expect_equal(a$domain, list())
  expect_equal(a$isScalar, TRUE)

  ip <- Alias$new(m, "ip", i)
  ip$dimension <- 2
  expect_equal(ip$dimension, 2)
  expect_equal(i$dimension, 2)
  expect_equal(ip$domain, list("*", "*"))
  expect_equal(i$domain, list("*", "*"))
})

test_that("test_num_39", {
  m <- Container$new()
  i <- Set$new(m, "i")
  expect_equal(i$numberRecords, 0)
  m$removeSymbols("i")

  i <- Set$new(m, "i", records = c("a", "b"))
  expect_equal(i$numberRecords, 2)

  j <- Set$new(m, "j", i, records = c("a", "c"))

  # expect_true(is.na(j$numberRecords)) #because NA
})

test_that("test_num_40", {
  m <- Container$new(testthat::test_path("testdata", "test40.gdx"))
  expect_true(m["a"]$domainType == "regular")
  expect_true(is.null(m["a"]$records))

  # test supercall read
  rl <- readGDX(testthat::test_path("testdata", "test40.gdx"))
  m2 <- Container$new()
  m2$readList(rl)
  expect_equal(m$equals(m2), TRUE)
})

test_that("test_num_41", {
  # test for matrix input of parameter records 2D
  m <- Container$new()
  i <- Set$new(m, "i", records = c("a", "b"))
  j <- Set$new(m, "j", records = c("x", "y", "z"))

  recs <- matrix(c(1:6), nrow = 2, ncol = 3)
  d <- Parameter$new(m, "d", c(i, j), records = recs)

  df <- data.frame(
    i = c("a", "a", "a", "b", "b", "b"),
    j = c("x", "y", "z", "x", "y", "z"),
    value = c(1, 3, 5, 2, 4, 6)
  )
  df[, 1] <- factor(df[, 1], ordered = TRUE)
  df[, 2] <- factor(df[, 2], ordered = TRUE)


  expect_equal(d$records, df)

  # test for array input of parameter records 2D
  m$removeSymbols("d")
  recs <- array(c(1:6), dim = c(2, 3))
  d <- Parameter$new(m, "d", c(i, j), records = recs)
  expect_equal(d$records, df)

  # test for array 3D
  recs <- array(c(1:12), dim = c(2, 3, 2))
  k <- Set$new(m, "k", records = c("alpha", "beta"))
  d3 <- Parameter$new(m, "d3", c(i, j, k), records = recs)

  df <- data.frame(
    i = c("a", "a", "a", "a", "a", "a", "b", "b", "b", "b", "b", "b"),
    j = c("x", "x", "y", "y", "z", "z", "x", "x", "y", "y", "z", "z"),
    k = c(
      "alpha", "beta", "alpha", "beta", "alpha", "beta",
      "alpha", "beta", "alpha", "beta", "alpha", "beta"
    ),
    value = c(1, 7, 3, 9, 5, 11, 2, 8, 4, 10, 6, 12)
  )
  df[, 1] <- factor(df[, 1], ordered = TRUE)
  df[, 2] <- factor(df[, 2], ordered = TRUE)
  df[, 3] <- factor(df[, 3], ordered = TRUE)
  expect_equal(d3$records, df)
})

test_that("test_num_42", {
  m <- Container$new()
  i <- Set$new(m, "i", records = paste0("i", c(1:5)))
  j <- Set$new(m, "j", records = paste0("j", c(1:5)))
  recs <- data.frame(
    "i" = c("i1", "i2", "i3", "i4", "i5"),
    "j" = c("j1", "j2", "j3", "j4", "j5"), "val" = c(1, 1, 1, 1, 1)
  )
  a <- Parameter$new(m, "a", domain = c(i, j), records = recs)
  ap <- Parameter$new(m, "ap", domain = c(i, j), records = a$toDense())
  expect_equal(a$records, ap$records)

  v <- Variable$new(m, "v", domain = c(i, j), records = list("level" = a$toDense()))

  df <- data.frame(
    i = i$records[, 1],
    j = j$records[, 1],
    level = c(1, 1, 1, 1, 1)
  )

  expect_equal(v$records, df)

  v2 <- Variable$new(m, "v2",
    domain = c(i, j),
    records = list(
      "level" = a$toDense(),
      marginal = a$toDense(),
      lower = a$toDense(),
      upper = a$toDense(),
      scale = a$toDense()
    )
  )

  e <- Equation$new(m, "e", "eq",
    domain = c(i, j),
    records = list(
      "level" = a$toDense(),
      marginal = a$toDense(),
      lower = a$toDense(),
      upper = a$toDense(),
      scale = a$toDense()
    )
  )

  df <- data.frame(
    i = i$records[, 1],
    j = j$records[, 1],
    level = c(1, 1, 1, 1, 1),
    marginal = replicate(5, 1),
    lower = replicate(5, 1),
    upper = replicate(5, 1),
    scale = replicate(5, 1)
  )

  expect_equal(v2$records, df)
  expect_equal(e$records, df)
})

# test converting arrays to records for Parameters, Varaibles, Equations
test_that("test_num_43", {
  m <- Container$new()
  i <- Set$new(m, "i", records = paste0("i", c(1:5)))
  j <- Set$new(m, "j", records = paste0("j", c(1:5)))
  recs <- data.frame(
    "i" = c("i1", "i2", "i3", "i4", "i5"),
    "j" = c("j1", "j2", "j3", "j4", "j5"), "val" = c(0, 0, 0, 0, 0)
  )
  recs[2, "val"] <- 1
  recs[4, "val"] <- SpecialValues$EPS
  recs <- recs[-c(1, 3, 5), ]
  row.names(recs) <- NULL

  recs2 <- data.frame(
    "i" = c("i1", "i2", "i3", "i4", "i5"),
    "j" = c("j1", "j2", "j3", "j4", "j5"), "val" = c(0, 0, 0, 0, 0)
  )
  recs2["val"] <- SpecialValues$EPS

  a <- Parameter$new(m, "a", domain = c(i, j), records = recs)
  ap <- Parameter$new(m, "ap", domain = c(i, j), records = recs2)

  v <- Variable$new(m, "v",
    domain = c(i, j),
    records = list(
      "level" = a$toDense(),
      "marginal" = ap$toDense()
    )
  )

  e <- Equation$new(m, "e", "eq",
    domain = c(i, j),
    records = list(
      "level" = a$toDense(),
      "marginal" = ap$toDense()
    )
  )

  cols <- v$domainLabels
  cols <- append(cols, c("level", "marginal", "lower", "upper", "scale"))

  recs <- data.frame(
    "i" = c("i1", "i2", "i3", "i4", "i5"),
    "j" = c("j1", "j2", "j3", "j4", "j5"), "level" = c(0, 0, 0, 0, 0),
    "marginal" = replicate(5, SpecialValues$EPS)
  )
  recs[, 1] <- factor(recs[, 1], ordered = TRUE)
  recs[, 2] <- factor(recs[, 2], ordered = TRUE)
  recs[2, "level"] <- 1
  recs[4, "level"] <- SpecialValues$EPS

  expect_equal(v$records, recs)

  recs <- data.frame(
    "i" = c("i1", "i2", "i3", "i4", "i5"),
    "j" = c("j1", "j2", "j3", "j4", "j5"), "level" = c(0, 0, 0, 0, 0),
    "marginal" = replicate(5, SpecialValues$EPS)
  )
  recs[, 1] <- factor(recs[, 1], ordered = TRUE)
  recs[, 2] <- factor(recs[, 2], ordered = TRUE)
  recs[2, "level"] <- 1
  recs[4, "level"] <- SpecialValues$EPS

  expect_equal(e$records, recs)
})

test_that("test_num_44", {
  m <- Container$new(testthat::test_path("testdata", "test44.gdx"))
  expect_true(m["i"]$type == "free")

  m$write("out.gdx")

  # test supercall read
  rl <- readGDX(testthat::test_path("testdata", "test44.gdx"))
  m2 <- Container$new()
  m2$readList(rl)
  expect_equal(m$equals(m2), TRUE)

  m2 <- Container$new(testthat::test_path("out.gdx"))
  expect_true(m2["i"]$type == "free")

  m$write("out.gdx", mode = "string")

  m2 <- Container$new(testthat::test_path("out.gdx"))
  expect_true(m2["i"]$type == "free")

  # test the super call write
  writeList <- m$asList()
  writeGDX(writeList, "out.gdx", mode = "string")

  m2 <- Container$new(testthat::test_path("out.gdx"))
  expect_true(m2["i"]$type == "free")
})

test_that("test_num_45", {
  m <- Container$new()
  i <- Set$new(m, "i", records = paste0("i", 1:5))
  j <- Set$new(m, "j", i, records = paste0("i", 1:5))

  m$removeSymbols("i")

  expect_true(is.null(i$container))
  expect_true(unlist(m$data$keys()) == c("j"))
  expect_true(j$isValid())
  expect_equal(j$domain, "*")
})

test_that("test_num_46", {
  skip_if_no_gams()
  h <- Container$new()
  h$read(testthat::test_path("testdata", "biggdxtest.gdx"))

  m <- Container$new(h)
  # write everything
  m$write(testthat::test_path("gt.gdx"))

  ret <- system2(
    command = "gdxdiff", args =
      paste0(testthat::test_path("testdata", "biggdxtest.gdx"), " ", testthat::test_path("gt.gdx")),
    stdout = FALSE
  )
  expect_equal(ret, 0)

  # write everything
  m$write(testthat::test_path("gt.gdx"), mode = "string")

  ret <- system2(
    command = "gdxdiff", args =
      paste0(testthat::test_path("testdata", "biggdxtest.gdx"), " ", testthat::test_path("gt.gdx")),
    stdout = FALSE
  )
  expect_equal(ret, 0)

  # test the super call write
  writeList <- m$asList()
  writeGDX(writeList, "gt.gdx")

  ret <- system2(
    command = "gdxdiff", args =
      paste0(testthat::test_path("testdata", "biggdxtest.gdx"), " ", testthat::test_path("gt.gdx")),
    stdout = FALSE
  )
  expect_equal(ret, 0)
})

test_that("test_num_47", {
  m <- Container$new(testthat::test_path("testdata", "test47.gdx"))
  expect_true(m["a"]$domainType == "regular")
  expect_true(is.null(m["a"]$records))

  # test supercall read
  rl <- readGDX(testthat::test_path("testdata", "test47.gdx"))
  m2 <- Container$new()
  m2$readList(rl)
  expect_equal(m$equals(m2), TRUE)
})

test_that("test_num_48", {
  m <- Container$new()
  i <- Set$new(m, "i", domain = c("k"), records = paste0("i", 1:5))
  j <- Set$new(m, "j", domain = c("*"), records = paste0("j", 1:5))
  k <- Set$new(m, "k", domain = c("*", "l"), records = data.frame(paste0("k", 1:5), paste0("l", 1:5)))
  l <- Set$new(m, "l", i, records = paste0("i", 1:2))
  m$write("data.gdx")

  m <- Container$new("data.gdx")

  expect_true(m["i"]$domainType == "relaxed")
  expect_true(m["j"]$domainType == "none")
  expect_true(m["k"]$domainType == "relaxed")
  expect_true(m["l"]$domainType == "regular")

  expect_true(!is.null(m["i"]$records))
  expect_true(!is.null(m["j"]$records))
  expect_true(!is.null(m["k"]$records))
  expect_true(!is.null(m["l"]$records))

  m$write("data.gdx", mode = "string")

  m <- Container$new("data.gdx")

  expect_true(m["i"]$domainType == "relaxed")
  expect_true(m["j"]$domainType == "none")
  expect_true(m["k"]$domainType == "relaxed")
  expect_true(m["l"]$domainType == "regular")

  expect_true(!is.null(m["i"]$records))
  expect_true(!is.null(m["j"]$records))
  expect_true(!is.null(m["k"]$records))
  expect_true(!is.null(m["l"]$records))

  # test the super call write
  writeList <- m$asList()
  writeGDX(writeList, "data.gdx")
  expect_true(m["i"]$domainType == "relaxed")
  expect_true(m["j"]$domainType == "none")
  expect_true(m["k"]$domainType == "relaxed")
  expect_true(m["l"]$domainType == "regular")

  expect_true(!is.null(m["i"]$records))
  expect_true(!is.null(m["j"]$records))
  expect_true(!is.null(m["k"]$records))
  expect_true(!is.null(m["l"]$records))
})


test_that("test_num_49", {
  m <- Container$new(testthat::test_path("testdata", "test49.gdx"))
  expect_equal(m["i"]$domainType, "relaxed")

  # test supercall read
  rl <- readGDX(testthat::test_path("testdata", "test49.gdx"))
  m2 <- Container$new()
  m2$readList(rl)
  expect_equal(m$equals(m2), TRUE)
})

test_that("test_num_50", {
  m <- Container$new()
  i <- Set$new(m, "i", domain = c("k"), records = paste0("i", 1:5))
  j <- Set$new(m, "j", domain = c("*"), records = paste0("j", 1:5))
  k <- Set$new(m, "k", domain = c("*", "l"), records = data.frame(paste0("k", 1:5), paste0("l", 1:5)))
  l <- Set$new(m, "l", i, records = paste0("i", 1:2))
  m$write("data.gdx")


  m <- Container$new()
  m$read(testthat::test_path("data.gdx"), symbols = "i")
  expect_true(!is.null(m["i"]))

  m <- Container$new()
  m$read(testthat::test_path("data.gdx"), symbols = c("i", "j"))
  expect_true(!is.null(m["i"]))
  expect_true(!is.null(m["j"]))

  # test supercall read
  rl <- readGDX(testthat::test_path("data.gdx"),
    symbols = c("i", "j")
  )
  m2 <- Container$new()
  m2$readList(rl)
  expect_equal(m$equals(m2), TRUE)

  m <- Container$new()
  expect_error(m$read(testthat::test_path("data.gdx"), symbols = c("i", "j", "dummy")))

  m <- Container$new()
  i <- Set$new(m, "i", domain = c("k"), records = paste0("i", 1:5))
  j <- Set$new(m, "j", domain = c("*"), records = paste0("j", 1:5))
  k <- Set$new(m, "k", domain = c("*", "l"), records = data.frame(paste0("k", 1:5), paste0("l", 1:5)))
  l <- Set$new(m, "l", i, records = paste0("i", 1:2))
  m$write("data.gdx", mode = "string")

  # test the super call write
  writeList <- m$asList()
  writeGDX(writeList, "gt.gdx")

  m <- Container$new()
  m$read(testthat::test_path("data.gdx"), symbols = "i")
  expect_true(!is.null(m["i"]))

  m <- Container$new()
  m$read(testthat::test_path("data.gdx"), symbols = c("i", "j"))
  expect_true(!is.null(m["i"]))
  expect_true(!is.null(m["j"]))

  m <- Container$new()
  expect_error(m$read(testthat::test_path("data.gdx"), symbols = c("i", "j", "dummy")))
})

test_that("test_num_51", {
  expect_error(Container$new("dummy.gdx"))

  m <- Container$new()
  expect_error(m$read("dummy.gdx"))
})

test_that("test_num_52", {
  expect_error(Container$new(data.frame()))

  m <- Container$new()
  expect_error(m$read(data.frame()))
})

test_that("test_num_53", {
  expect_warning(Container$new(testthat::test_path("testdata", "test53.gdx")))
})

test_that("test_num_54", {
  m <- Container$new(testthat::test_path("testdata", "trnsport.gdx"))

  for (i in unlist(m$data$keys())) {
    expect_true(is.list(m[i]$summary))
  }

  expect_true(is.vector(m$listSymbols()))
  expect_true(is.vector(m$listParameters()))
  expect_true(is.vector(m$listSets()))
  expect_true(is.null(m$listAliases()))
  expect_true(is.vector(m$listVariables()))
  expect_true(is.vector(m$listEquations()))

  expect_equal(length(m$listVariables(types = "free")), 1)
  expect_equal(length(m$listVariables(types = "positive")), 1)

  expect_equal(length(m$listEquations(types = "geq")), 1)
  expect_equal(length(m$listEquations(types = "eq")), 1)
  expect_equal(length(m$listEquations(types = "leq")), 1)
  expect_equal(length(m$listEquations(types = c("geq", "leq"))), 2)

  expect_true(is.data.frame(m$describeSets()))
  expect_true(is.data.frame(m$describeParameters()))
  expect_true(is.data.frame(m$describeVariables()))
  expect_true(is.data.frame(m$describeEquations()))

  expect_equal(nrow(m$describeEquations(m$listEquations(types = "geq"))), 1)
  expect_equal(nrow(m$describeEquations(m$listEquations(types = "eq"))), 1)
  expect_equal(nrow(m$describeEquations(m$listEquations(types = "leq"))), 1)
})

test_that("test_num_55", {
  m <- Container$new(testthat::test_path("testdata", "trnsport.gdx"))
  old_names <- unlist(m$data$keys())
  for (i in unlist(m$data$keys())) {
    expect_true(!is.null(m[i]$records))
  }

  m <- Container$new()
  m$read(testthat::test_path("testdata", "trnsport.gdx"))
  for (i in unlist(m$data$keys())) {
    expect_true(is.data.frame(m[i]$records))
  }

  m <- Container$new(testthat::test_path("testdata", "test55.gdx"))
  new_names <- unlist(m$data$keys())
  for (i in unlist(m$data$keys())) {
    if (i != "ce") {
      expect_true(!is.null(m[i]$records))
    }
  }

  expect_true(!identical(old_names, new_names))

  # test supercall read
  rl <- readGDX(testthat::test_path("testdata", "test55.gdx"))
  m2 <- Container$new()
  m2$readList(rl)
  expect_equal(m$equals(m2), TRUE)
})

test_that("test_num_56", {
  m <- Container$new()
  m$read(testthat::test_path("testdata", "trnsport.gdx"))

  for (i in unlist(m$data$keys())) {
    expect_true(is.data.frame(m[i]$records))
  }
})

test_that("test_num_57", {
  df <- data.frame(
    expand.grid(
      c("a1", "a2"),
      c("b1", "b2"), c("c1", "c2"), c("d1", "d2")
    ),
    stringsAsFactors = TRUE
  )

  df$value <- 1
  m <- Container$new()
  t <- Parameter$new(m, "t", domain = replicate(4, "*"))
  t$records <- df

  expect_true(t$isValid())
})



# test read from another Container
test_that("test_num_59", {
  m <- Container$new(testthat::test_path("testdata", "trnsport_with_alias.gdx"))
  expect_true(m$isValid())

  m2 <- Container$new(m)
  expect_true(m2$isValid())
})

# test read from another Container with invalid symbols
test_that("test_num_60", {
  m <- Container$new()
  i <- Set$new(m, "i", records = paste0("i", 1:10))
  j <- Set$new(m, "j", records = paste0("j", 1:10))

  a <- Parameter$new(m, "a", c(i, j))
  a$.__enclos_env__$private$.records <- "ham"
  expect_true(!a$isValid())
  expect_error(Container$new(m))

  m2 <- Container$new()
  m2$read(m, c("i", "j"))
  expect_equal(unlist(m2$data$keys()), c("i", "j"))
  expect_error(m2$read(m, "a"))
})


# test converting arrays with EPS (across several columns) values for Parameters, Variables, Equations
test_that("test_num_61", {
  m <- Container$new()
  i <- Set$new(m, "i", records = paste0("i", c(1:5)))
  j <- Set$new(m, "j", records = paste0("j", c(1:5)))
  recs <- data.frame(
    "i" = c("i1", "i2", "i3", "i4", "i5"),
    "j" = c("j1", "j2", "j3", "j4", "j5"), "val" = c(0, 1, 0, SpecialValues$EPS, 0)
  )
  recs <- recs[-c(1, 3, 5), ]
  a <- Parameter$new(m, "a", domain = c(i, j), records = recs)

  recs <- data.frame(
    "i" = c("i1", "i2", "i3", "i4", "i5"),
    "j" = c("j1", "j2", "j3", "j4", "j5"), "val" = replicate(5, SpecialValues$EPS)
  )

  ap <- Parameter$new(m, "ap", domain = c(i, j), records = recs)

  v <- Variable$new(m, "v",
    domain = c(i, j), records =
      list("level" = a$toDense(), "marginal" = ap$toDense())
  )

  e <- Equation$new(m, "e", "eq",
    domain = c(i, j),
    records = list(
      "level" = a$toDense(),
      marginal = ap$toDense()
    )
  )

  df <- data.frame(
    i = i$records[, 1],
    j = j$records[, 1],
    level = c(0, 1, 0, SpecialValues$EPS, 0),
    marginal = replicate(5, SpecialValues$EPS)
  )

  expect_equal(v$records, df)

  df <- data.frame(
    i = i$records[, 1],
    j = j$records[, 1],
    level = c(0, 1, 0, SpecialValues$EPS, 0),
    marginal = replicate(5, SpecialValues$EPS)
  )
  expect_equal(e$records, df)
})

# test symbol isValid if categories are not set properly (directly)
test_that("test_num_62", {
  df <- data.frame(rev(expand.grid(rev(list(
    paste0("h", 1:10),
    paste0("m", 1:10), paste0("s", 1:10)
  )))), stringsAsFactors = TRUE)

  colnames(df) <- c("h_1", "m_2", "s_3")

  df[["value"]] <- runif(nrow(df), 0, 100)

  m <- Container$new()
  hrs <- Set$new(m, "h", records = unique(df$h_1))
  mins <- Set$new(m, "m", records = unique(df$m_2))
  secs <- Set$new(m, "s", records = unique(df$s_3))

  a <- Parameter$new(m, "a", c(hrs, mins, secs))

  # set records directly
  a$records <- df

  expect_true(a$isValid())
})

# test symbol isValid if categories are set properly (directly)
test_that("test_num_63", {
  df <- data.frame(rev(expand.grid(rev(list(
    paste0("h", 1:10),
    paste0("m", 1:10), paste0("s", 1:10)
  )))), stringsAsFactors = TRUE)

  colnames(df) <- c("h_1", "m_2", "s_3")

  df[["value"]] <- runif(nrow(df), 0, 100)

  m <- Container$new()
  hrs <- Set$new(m, "h", records = unique(df$h_1))
  mins <- Set$new(m, "m", records = unique(df$m_2))
  secs <- Set$new(m, "s", records = unique(df$s_3))

  a <- Parameter$new(m, "a", c(hrs, mins, secs))

  df$h_1 <- factor(df$h_1, levels = levels(hrs$records$uni), ordered = TRUE)
  df$m_2 <- factor(df$m_2, levels = levels(mins$records$uni), ordered = TRUE)
  df$s_3 <- factor(df$s_3, levels = levels(secs$records$uni), ordered = TRUE)
  # set records directly
  a$records <- df

  expect_true(a$isValid())
})

# test symbol isValid if categories are not linked to the proper set (directly)
test_that("test_num_64", {
  df <- data.frame(rev(expand.grid(rev(list(
    paste0("h", 1:10),
    paste0("m", 1:10), paste0("s", 1:10)
  )))), stringsAsFactors = TRUE)

  colnames(df) <- c("h_1", "m_2", "s_3")

  df[["value"]] <- runif(nrow(df), 0, 100)

  m <- Container$new()
  hrs <- Set$new(m, "h", records = unique(df$h_1))
  mins <- Set$new(m, "m", records = unique(df$m_2))
  secs <- Set$new(m, "s", records = unique(df$s_3))

  a <- Parameter$new(m, "a", c(hrs, mins, secs))

  dumb_set <- append(levels(df$h_1), "new_element")

  df$h_1 <- factor(df$h_1, levels = dumb_set, ordered = TRUE)
  df$m_2 <- factor(df$m_2, levels = levels(mins$records$uni), ordered = TRUE)
  df$s_3 <- factor(df$s_3, levels = levels(secs$records$uni), ordered = TRUE)
  # set records directly
  a$records <- df

  expect_true(a$isValid())
})

# test Exception when attempting to set a symbol name with invalid characters
test_that("test_num_65", {
  m <- Container$new()
  expect_error(Set$new(m, "milk&meat"))
  expect_error(Set$new(m, "_milk&meat"))
})

# test that name.setter (symbols and aliases) cannot set name if it already exists in container
test_that("test_num_66", {
  m <- Container$new()
  i <- Set$new(m, "i")
  j <- Set$new(m, "j")

  ip <- Alias$new(m, "ip", i)
  jp <- Alias$new(m, "jp", j)
  expr <- function() j$name <- "i"
  expect_error(expr())
  expr <- function() jp$name <- "ip"
  expect_error(expr())
})

# test utility functions
test_that("test_num_67", {
  m <- Container$new()
  i <- Set$new(m, "i", records = paste0("i", 1:10))
  a <- Parameter$new(m, "a", i, records = data.frame(i$records[, 1], 1:10))
  expect_equal(a$getMaxValue(), 10.0)
  expect_equal(a$getMinValue(), 1.0)
  expect_equal(a$getMeanValue(), 5.5)
  expect_equal(a$getMaxAbsValue(), 10.0)
  expect_equal(a$whereMax(), 10)
  expect_equal(a$whereMaxAbs(), 10)
  expect_equal(a$whereMin(), 1)
  expect_equal(a$countNA(), 0)
  expect_equal(a$countEps(), 0)
  expect_equal(a$countUndef(), 0)
  expect_equal(a$countPosInf(), 0)
  expect_equal(a$countNegInf(), 0)
})

# test passing .toDense() of multiple dimensions to setRecords
test_that("test_num_68", {
  m <- Container$new()
  i <- Set$new(m, "i", records = paste0("i", 1:10))
  j <- Set$new(m, "j", records = paste0("j", 1:10))

  a0 <- Parameter$new(m, "a0", records = 10)
  a1 <- Parameter$new(m, "a1", i, records = data.frame(i = paste0("i", 1:10), 1:10))


  df <- data.frame(rev(expand.grid(rev(list(
    paste0("i", 1:10),
    paste0("j", 1:5)
  )))), stringsAsFactors = TRUE)
  values <- replicate(50, 0)
  count <- 1
  for (i1 in 1:10) {
    for (j1 in 1:5) {
      values[count] <- i1 + j1
      count <- count + 1
    }
  }
  df$values <- values
  a2 <- Parameter$new(m, "a2", c(i, j), records = df)


  df <- data.frame(rev(expand.grid(rev(list(
    paste0("i", 1:10),
    paste0("j", 1:5), paste0("i", 1:10)
  )))), stringsAsFactors = TRUE)

  values <- replicate(500, 0)
  count <- 1
  for (i1 in 1:10) {
    for (j1 in 1:5) {
      for (ip1 in 1:10) {
        values[count] <- i1 + j1 + ip1
        count <- count + 1
      }
    }
  }
  df$values <- values

  a3 <- Parameter$new(m, "a3", c(i, j, i), records = df)

  a0p <- Parameter$new(m, "a0p", records = a0$toDense())
  a1p <- Parameter$new(m, "a1p", i, records = a1$toDense())
  a2p <- Parameter$new(m, "a2p", c(i, j), records = a2$toDense())
  a3p <- Parameter$new(m, "a3p", c(i, j, i), records = a3$toDense())

  v0 <- Variable$new(m, "v0", records = a0$toDense())
  v1 <- Variable$new(m, "v1", domain = i, records = a1$toDense())
  v2 <- Variable$new(m, "v2", domain = c(i, j), records = a2$toDense())
  v3 <- Variable$new(m, "v3", domain = c(i, j, i), records = a3$toDense())

  v0p <- Variable$new(m, "v0p", records = v0$toDense())
  v1p <- Variable$new(m, "v1p", domain = i, records = v1$toDense())
  v2p <- Variable$new(m, "v2p", domain = c(i, j), records = v2$toDense())
  v3p <- Variable$new(m, "v3p", domain = c(i, j, i), records = v3$toDense())

  e0 <- Equation$new(m, "e0", "eq", records = a0$toDense())
  e1 <- Equation$new(m, "e1", "eq", domain = i, records = a1$toDense())
  e2 <- Equation$new(m, "e2", "eq", domain = c(i, j), records = a2$toDense())
  e3 <- Equation$new(m, "e3", "eq", domain = c(i, j, i), records = a3$toDense())

  e0p <- Equation$new(m, "e0p", "eq", records = e0$toDense())
  e1p <- Equation$new(m, "e1p", "eq", domain = i, records = e1$toDense())
  e2p <- Equation$new(m, "e2p", "eq", domain = c(i, j), records = e2$toDense())
  e3p <- Equation$new(m, "e3p", "eq", domain = c(i, j, i), records = e3$toDense())

  expect_equal(a0$records, a0p$records)
  expect_equal(a1$records, a1p$records)
  # expect_equal(as.numeric(a2$records), as.numeric(a2p$records))
  # expect_equal(as.numeric(a3$records), as.numeric(a3p$records))

  expect_equal(v0$records, v0p$records)
  expect_equal(v1$records, v1p$records)
  expect_equal(v2$records, v2p$records)
  expect_equal(v3$records, v3p$records)

  expect_equal(e0$records, e0p$records)
  expect_equal(e1$records, e1p$records)
  expect_equal(e2$records, e2p$records)
  expect_equal(e3$records, e3p$records)
})

# test passing .toDense() of multiple dimensions to setRecords (named list structure)
test_that("test_num_69", {
  m <- Container$new()
  i <- Set$new(m, "i", records = paste0("i", 1:10))
  j <- Set$new(m, "j", records = paste0("j", 1:10))

  a0 <- Parameter$new(m, "a0", records = 10)
  a1 <- Parameter$new(m, "a1", i, records = data.frame(i = paste0("i", 1:10), 1:10))


  df <- data.frame(rev(expand.grid(rev(list(
    paste0("i", 1:10),
    paste0("j", 1:5)
  )))), stringsAsFactors = TRUE)
  values <- replicate(50, 0)
  count <- 1
  for (i1 in 1:10) {
    for (j1 in 1:5) {
      values[count] <- i1 + j1
      count <- count + 1
    }
  }
  df$values <- values
  a2 <- Parameter$new(m, "a2", c(i, j), records = df)


  df <- data.frame(rev(expand.grid(rev(list(
    paste0("i", 1:10),
    paste0("j", 1:5), paste0("i", 1:10)
  )))), stringsAsFactors = TRUE)

  values <- replicate(500, 0)
  count <- 1
  for (i1 in 1:10) {
    for (j1 in 1:5) {
      for (ip1 in 1:10) {
        values[count] <- i1 + j1 + ip1
        count <- count + 1
      }
    }
  }
  df$values <- values

  a3 <- Parameter$new(m, "a3", c(i, j, i), records = df)

  a0dict <- list(
    level = a0$toDense(),
    marginal = a0$toDense(),
    lower = a0$toDense(),
    upper = a0$toDense(),
    scale = a0$toDense()
  )

  a1dict <- list(
    level = a1$toDense(),
    marginal = a1$toDense(),
    lower = a1$toDense(),
    upper = a1$toDense(),
    scale = a1$toDense()
  )

  a2dict <- list(
    level = a2$toDense(),
    marginal = a2$toDense(),
    lower = a2$toDense(),
    upper = a2$toDense(),
    scale = a2$toDense()
  )

  a3dict <- list(
    level = a3$toDense(),
    marginal = a3$toDense(),
    lower = a3$toDense(),
    upper = a3$toDense(),
    scale = a3$toDense()
  )

  a0p <- Parameter$new(m, "a0p", records = a0$toDense())
  a1p <- Parameter$new(m, "a1p", i, records = a1$toDense())
  a2p <- Parameter$new(m, "a2p", c(i, j), records = a2$toDense())
  a3p <- Parameter$new(m, "a3p", c(i, j, i), records = a3$toDense())

  v0 <- Variable$new(m, "v0", records = a0dict)
  v1 <- Variable$new(m, "v1", domain = i, records = a1dict)
  v2 <- Variable$new(m, "v2", domain = c(i, j), records = a2dict)
  v3 <- Variable$new(m, "v3", domain = c(i, j, i), records = a3dict)

  v0p <- Variable$new(m, "v0p", records = a0dict)
  v1p <- Variable$new(m, "v1p", domain = i, records = a1dict)
  v2p <- Variable$new(m, "v2p", domain = c(i, j), records = a2dict)
  v3p <- Variable$new(m, "v3p", domain = c(i, j, i), records = a3dict)

  e0 <- Equation$new(m, "e0", "eq", records = a0dict)
  e1 <- Equation$new(m, "e1", "eq", domain = i, records = a1dict)
  e2 <- Equation$new(m, "e2", "eq", domain = c(i, j), records = a2dict)
  e3 <- Equation$new(m, "e3", "eq", domain = c(i, j, i), records = a3dict)

  e0p <- Equation$new(m, "e0p", "eq", records = a0dict)
  e1p <- Equation$new(m, "e1p", "eq", domain = i, records = a1dict)
  e2p <- Equation$new(m, "e2p", "eq", domain = c(i, j), records = a2dict)
  e3p <- Equation$new(m, "e3p", "eq", domain = c(i, j, i), records = a3dict)

  expect_equal(a0$records, a0p$records)
  expect_equal(a1$records, a1p$records)
  # expect_equal(as.numeric(a2$records), as.numeric(a2p$records))
  # expect_equal(as.numeric(a3$records), as.numeric(a3p$records))

  expect_equal(v0$records, v0p$records)
  expect_equal(v1$records, v1p$records)
  expect_equal(v2$records, v2p$records)
  expect_equal(v3$records, v3p$records)

  expect_equal(e0$records, e0p$records)
  expect_equal(e1$records, e1p$records)
  expect_equal(e2$records, e2p$records)
  expect_equal(e3$records, e3p$records)
})

# shape test by passing eigen values and eigen vectors
test_that("test_num_70", {
  m <- Container$new(testthat::test_path("testdata", "test70.gdx"))

  # test supercall read
  rl <- readGDX(testthat::test_path("testdata", "test70.gdx"))
  m2 <- Container$new()
  m2$readList(rl)
  expect_equal(m$equals(m2), TRUE)

  e <- eigen(m["a"]$toDense())
  val <- e$values
  vec <- e$vectors
  eval <- Parameter$new(m, "eval", m["i"], records = val)
  evec <- Parameter$new(m, "evec", c(m["i"], m["j"]), records = vec)

  expect_true(m$isValid())
})

test_that("test_num_71", {
  arr0 <- array(c(1:270), dim = c(5, 6, 9))
  m <- Container$new()
  i <- Set$new(m, "i", records = paste0("i", 1:5))
  j <- Set$new(m, "j", records = paste0("j", 1:6))
  k <- Set$new(m, "k", records = paste0("i", 1:9))

  h <- Parameter$new(m, "h", c(i, j, k), records = arr0)
  hp <- Parameter$new(m, "hp", c(i, j, k), records = h$toDense())

  expect_equal(h$shape, c(5, 6, 9))
  expect_equal(hp$shape, c(5, 6, 9))
  expect_equal(dim(h$toDense()), c(5, 6, 9))
  expect_equal(dim(hp$toDense()), c(5, 6, 9))

  expect_equal(h$records, hp$records)
  expect_equal(arr0, h$toDense())
  expect_equal(arr0, hp$toDense())

  v <- Variable$new(m, "v", "free", c(i, j, k), records = arr0)
  vp <- Variable$new(m, "vp", "free", c(i, j, k), records = v$toDense())


  expect_equal(v$shape, c(5, 6, 9))
  expect_equal(vp$shape, c(5, 6, 9))
  expect_equal(dim(v$toDense()), c(5, 6, 9))
  expect_equal(dim(vp$toDense()), c(5, 6, 9))
  expect_equal(v$records, vp$records)
  expect_equal(arr0, v$toDense())
  expect_equal(arr0, vp$toDense())

  e <- Equation$new(m, "e", "eq", c(i, j, k), records = arr0)
  ep <- Equation$new(m, "ep", "eq", c(i, j, k), records = e$toDense())

  expect_equal(e$shape, c(5, 6, 9))
  expect_equal(ep$shape, c(5, 6, 9))
  expect_equal(dim(e$toDense()), c(5, 6, 9))
  expect_equal(dim(ep$toDense()), c(5, 6, 9))
  expect_equal(e$records, ep$records)
  expect_equal(arr0, e$toDense())
  expect_equal(arr0, ep$toDense())
})

test_that("test_num_72", {
  m <- Container$new(testthat::test_path("testdata", "test72.gdx"))

  expect_equal(m["dim0"]$shape, dim(m["dim0"]$toDense()))
  expect_equal(m["dim1"]$shape, dim(m["dim1"]$toDense()))

  # test supercall read
  rl <- readGDX(testthat::test_path("testdata", "test72.gdx"))
  m2 <- Container$new()
  m2$readList(rl)
  expect_equal(m$equals(m2), TRUE)
})

test_that("test_num_73", {
  m <- Container$new(testthat::test_path("testdata", "test73.gdx"))

  # test supercall read
  rl <- readGDX(testthat::test_path("testdata", "test73.gdx"))
  m2 <- Container$new()
  m2$readList(rl)
  expect_equal(m$equals(m2), TRUE)

  m["ProfitA"]$setRecords(cumsum(m["ProfitM"]$toDense()))

  expect_equal(m["ProfitA"]$numberRecords, m["t"]$numberRecords)
})

test_that("test_num_74", {
  m <- Container$new()
  d <- Parameter$new(m, "d")
  e <- Parameter$new(m, "e")
  expect_true(m$hasSymbols("d"))
  expect_true(m$hasSymbols("e"))
  expect_true(m$hasSymbols("D"))
  expect_true(m$hasSymbols("E"))
  expect_equal(m$hasSymbols(c("d", "e")), c(TRUE, TRUE))

  expect_false(m$hasSymbols("f"))
  expect_equal(m$hasSymbols(c("F", "g")), c(FALSE, FALSE))

  expect_equal(m$getSymbolNames(c("D", "d")), c("d", "d"))
  expect_equal(m$getSymbolNames("D"), "d")
  expect_error(m$getSymbolNames("F"))
})

# test case sensitive rename and remove
test_that("test_num_75", {
  m <- Container$new()
  d <- Parameter$new(m, "d")
  e <- Parameter$new(m, "e")

  # case insensitive remove
  m$removeSymbols("D")
  expect_equal(unlist(m$data$keys()), "e")

  d <- Parameter$new(m, "d")

  # case insensitive rename
  m$renameSymbol("D", "d_new")
  expect_equal(unlist(m$data$keys()), c("e", "d_new"))

  # change case using rename
  m$renameSymbol("d_new", "D_neW")
  expect_equal(tolower(unlist(m$data$keys())), tolower(c("e", "D_neW")))
})

# test getsymbols
test_that("test_num_76", {
  m <- Container$new()
  d <- Parameter$new(m, "d")
  e <- Parameter$new(m, "e")

  expect_equal(length(m$getSymbols(m$listSymbols())), 2)
  symbolobjects <- m$getSymbols(m$listSymbols())

  expect_true(inherits(symbolobjects[[1]], "Parameter"))
  expect_true(inherits(symbolobjects[[2]], "Parameter"))

  expect_error(m$getSymbols("f"))

  symobject <- m$getSymbols("d")
  expect_true(inherits(symobject[[1]], "Parameter"))

  symobject <- m$getSymbols("D")
  expect_true(inherits(symobject[[1]], "Parameter"))

  expect_error(m$getSymbols(200))
})

# test listSymbols
test_that("test_num_76", {
  m <- Container$new()
  i <- Set$new(m, "i", records = c("a", "b", "c"))
  a <- Parameter$new(m, "a", i, records = data.frame(c("aa", "c"), c(1, 2)))

  expect_equal(a$isValid(), TRUE)
  # expect_equal(m$listSymbols(isValid=TRUE), "i")
  # expect_equal(m$listSymbols(isValid=FALSE), "a")
})

# test symbol duplicate record methods
test_that("test_num_77", {
  m <- Container$new()
  df <- data.frame(matrix(NA, nrow = 30, ncol = 2))
  df[1:10, 1] <- paste0("i", 1:10)
  df[11:20, 1] <- paste0("j", 1:10)
  df[21:30, 1] <- paste0("i", 1:10)
  df[1:10, 2] <- 1:10
  df[11:20, 2] <- 1:10
  df[21:30, 2] <- 1:10
  a <- Parameter$new(m, "a", domain = "*", records = df)
  b <- Parameter$new(m, "b", domain = "*", records = data.frame(paste0("i", 1:10), 1:10))

  # expect_equal(a$isValid(), FALSE)
  expect_equal(a$findDuplicateRecords(keep = "first"), a$records[21:30, ])
  expect_equal(a$findDuplicateRecords(keep = "last"), a$records[1:10, ])
  expect_equal(a$findDuplicateRecords(keep = FALSE), a$records[append(1:10, 21:30), ])
  expect_equal(a$countDuplicateRecords(), 10)
  expect_true(a$hasDuplicateRecords())
  a$dropDuplicateRecords(keep = "first")
  expect_equal(as.character(a$records[, 1]), append(paste0("i", 1:10), paste0("j", 1:10)))

  m$removeSymbols("a")

  a <- Parameter$new(m, "a", domain = "*", records = df)
  a$dropDuplicateRecords(keep = "last")
  expect_equal(as.character(a$records[, 1]), append(paste0("j", 1:10), paste0("i", 1:10)))

  expect_true(b$isValid())
  expect_equal(b$countDuplicateRecords(), 0)
  expect_true(!b$hasDuplicateRecords())
  bcopy <- b
  b$dropDuplicateRecords()
  expect_equal(bcopy, b)
  expect_true(m$isValid())
})

# test container duplicate record methods
test_that("test_num_78", {
  m <- Container$new()
  df <- data.frame(matrix(NA, nrow = 30, ncol = 2))
  df[1:10, 1] <- paste0("i", 1:10)
  df[11:20, 1] <- paste0("j", 1:10)
  df[21:30, 1] <- paste0("i", 1:10)
  df[1:10, 2] <- 1:10
  df[11:20, 2] <- 1:10
  df[21:30, 2] <- 1:10
  a <- Parameter$new(m, "a", "*", records = df)
  b <- Parameter$new(m, "b", "*", records = data.frame(paste0("i", 1:10), 1:10))
  c <- Parameter$new(m, "c", "*", records = data.frame(paste0("j", 1:10), 1:10))

  expect_true(m$hasDuplicateRecords())
  expect_equal(m$countDuplicateRecords(), list("a" = 10))
  m$dropDuplicateRecords()
  expect_true(m$isValid())
})

# test getUELs method
test_that("test_num_79", {
  m <- Container$new()
  i <- Set$new(m, "i", domain = c("*", "*"), records = data.frame(c("i1", "i2", "i3"), c("i4", "i5", "i6")))
  j <- Set$new(m, "j", domain = c("*", "*"), records = data.frame(c("j1", "j2", "j3"), c("j4", "j5", "j6")))

  expect_equal(i$getUELs(dimension = 1), c("i1", "i2", "i3"))
  expect_equal(i$getUELs(dimension = 2), c("i4", "i5", "i6"))
  expect_equal(i$getUELs(), paste0("i", 1:6))
  expect_error(i$getUELs(dimension = 3))
  expect_error(i$getUELs(codes = 0))

  expect_equal(i$getUELs(dimension = 1), paste0("i", 1:3))
  expect_equal(i$getUELs(dimension = 2), paste0("i", 4:6))
  expect_error(i$getUELs(dimension = 3))
  expect_error(i$getUELs(codes = 0))

  expect_equal(i$getUELs(dimension = 1, codes = 1), "i1")
  expect_equal(i$getUELs(dimension = 1, codes = 3), "i3")
  expect_equal(i$getUELs(dimension = 1, codes = c(1, 3)), c("i1", "i3"))
  expect_error(i$getUELs(codes = 100, dimension = 0))

  expect_equal(j$getUELs(dimension = 1), paste0("j", 1:3))
  expect_equal(j$getUELs(dimension = 2), paste0("j", 4:6))
  expect_equal(j$getUELs(), paste0("j", 1:6))
  expect_error(j$getUELs(dimension = 3))

  expect_equal(m$getUELs("i"), i$getUELs())
  expect_equal(m$getUELs("j"), j$getUELs())
  expect_equal(m$getUELs(), append(i$getUELs(), j$getUELs()))
  expect_error(m$getUELs("k"))
})

# test removeUELs method
test_that("test_num_80", {
  m <- Container$new()
  i <- Set$new(m, "i", domain = c("*", "*"), records = data.frame(c("i1", "i2", "i3"), c("i4", "i5", "i6")))
  i$removeUELs("hi", 1)
  i$removeUELs("hi", 2)
  i$removeUELs("hi")

  expect_equal(i$getUELs(), paste0("i", 1:6))

  i$removeUELs("i1", 1)
  expect_equal(i$getUELs(), paste0("i", 2:6))

  m <- Container$new()
  i <- Set$new(m, "i", domain = c("*", "*"), records = data.frame(c("i1", "i2", "i3"), c("i4", "i5", "i6")))
  ip <- Alias$new(m, "ip", i)
  ip$removeUELs("hi", 1)
  ip$removeUELs("hi", 2)
  ip$removeUELs("hi")

  expect_equal(ip$getUELs(), paste0("i", 1:6))

  ip$removeUELs("i1", 1)
  expect_equal(ip$getUELs(), paste0("i", 2:6))

  m <- Container$new()
  i <- Set$new(m, "i", domain = c("*", "*"), records = data.frame(c("i1", "i2", "i3"), c("i4", "i5", "i6")))
  i$removeUELs("i4")
  expect_equal(i$getUELs(), append(paste0("i", 1:3), c("i5", "i6")))

  m <- Container$new()
  i <- Set$new(m, "i", domain = c("*", "*"), records = data.frame(c("i1", "i2", "i3"), c("i4", "i5", "i6")))
  ip <- Alias$new(m, "ip", i)
  ip$removeUELs("i4")
  expect_equal(ip$getUELs(), append(paste0("i", 1:3), c("i5", "i6")))

  m <- Container$new()
  i <- Set$new(m, "i", domain = c("*", "*"), records = data.frame(c("i1", "i2", "i3"), c("i4", "i5", "i6")))
  j <- Set$new(m, "j", domain = c("*", "*"), records = data.frame(c("j1", "j2", "j3"), c("j4", "j5", "j6")))
  ip <- Alias$new(m, "ip", i)
  m$removeUELs(c("i1", "j4"))
  expect_equal(m$getUELs(), append(paste0("i", 2:6), paste0("j", c(1:3, 5, 6))))
})

# test renameUELs method
test_that("test_num_81", {
  m <- Container$new()
  i <- Set$new(m, "i", domain = c("*", "*"), records = data.frame(c("i1", "i2", "i5"), c("i4", "i5", "i6")))
  i$renameUELs(c("jammin" = "java"), 1)
  i$renameUELs(c("jammin" = "java"), 2)
  i$renameUELs(c("jammin" = "java"))
  m$renameUELs(c("jammin" = "java"))

  i$renameUELs(c(i2 = "java"))
  expect_equal(i$getUELs(1), c("i1", "java", "i5"))

  m <- Container$new()
  i <- Set$new(m, "i", domain = c("*", "*"), records = data.frame(c("i1", "i2", "i5"), c("i4", "i5", "i6")))
  expect_equal(m$getUELs(), c("i1", "i2", "i5", "i4", "i6"))
  m$renameUELs(c(i2 = "java"))
  expect_equal(m$getUELs(), c("i1", "java", "i5", "i4", "i6"))
})

# test addUELs method
test_that("test_num_82", {
  m <- Container$new()
  i <- Set$new(m, "i", domain = c("*", "*"), records = data.frame(c("i1", "i2", "i5"), c("i4", "i5", "i6")))
  i$addUELs("ham", 1)
  expect_equal(i$getUELs(1), c("i1", "i2", "i5", "ham"))

  i$addUELs("cheese", 2)
  expect_equal(i$getUELs(2), c("i4", "i5", "i6", "cheese"))

  m$removeUELs()
  expect_equal(m$getUELs(), c("i1", "i2", "i5", "i4", "i6"))
})

# test reorderUELs method
test_that("test_num_83", {
  m <- Container$new()
  i <- Set$new(m, "i", records = c("i1", "i2", "i3"))
  a <- Parameter$new(m, "a", i, records = data.frame(paste0("i", c(1, 3, 2)), c(1, 3, 2)))

  expect_equal(a$getUELs(1), c("i1", "i3", "i2"))
  a$reorderUELs(i$getUELs(1), 1)
  expect_equal(a$getUELs(), c("i1", "i2", "i3"))
})

# test setUELs method
test_that("test_num_84", {
  m <- Container$new()
  i <- Set$new(m, "i", records = c("a", "b", "c"))
  j <- Parameter$new(m, "j", i, records = data.frame(c("a", "c"), c(1, 2)))

  expect_equal(j$getUELs(1), c("a", "c"))

  j$setUELs(c("j1", "a", "c", "j4"), 1, rename = TRUE)
  expect_equal(j$getUELs(1), c("j1", "a", "c", "j4"))
  expect_equal(as.character(j$records[, 1]), c("j1", "a"))


  m <- Container$new()
  i <- Set$new(m, "i", records = c("a", "b", "c"))
  j <- Parameter$new(m, "j", i, records = data.frame(c("a", "c"), c(1, 2)))

  expect_equal(j$getUELs(1), c("a", "c"))

  j$setUELs(c("j1", "a", "c", "j4"), 1, rename = FALSE)
  expect_equal(j$getUELs(1), c("j1", "a", "c", "j4"))
  expect_equal(as.character(j$records[, 1]), c("a", "c"))

  # multiple dimensions
  m <- Container$new()
  i <- Set$new(m, "i", records = c("a", "b", "c"))
  j <- Parameter$new(m, "j", c(i, i), records = data.frame(c("a", "c"), c("b", "a"), c(1, 2)))
  j$setUELs(c("j1", "a", "c", "j4"), rename = FALSE)
  expect_equal(j$getUELs(1), c("j1", "a", "c", "j4"))
  expect_equal(j$getUELs(2), c("j1", "a", "c", "j4"))

  expect_equal(as.character(j$records[, 1]), c("a", "c"))
  expect_true(is.na(j$records[1, 2]))
  expect_equal(as.character(j$records[, 1]), c("a", "c"))
})

# test getDomainViolations method
test_that("test_num_85", {
  m <- Container$new()
  i <- Set$new(m, "i", records = c("SeaTtle", "hamburg"))
  j <- Set$new(m, "j", i, records = c("seattle", "Hamburg"))
  ip <- Alias$new(m, "ip", i)
  jp <- Alias$new(m, "jp", j)

  expect_true(i$isValid())
  expect_true(j$isValid())
  expect_equal(i$getDomainViolations(), NULL)
  expect_equal(j$getDomainViolations(), NULL)
  expect_equal(ip$getDomainViolations(), NULL)
  expect_equal(jp$getDomainViolations(), NULL)

  # test container getdomainviolations
  expect_true(is.null(m$getDomainViolations()))

  m <- Container$new()
  i <- Set$new(m, "i", records = c("SeaTtle", "hamburg"))
  j <- Set$new(m, "j", i, records = c(" seattle", "Hamburg"))
  ip <- Alias$new(m, "ip", i)
  jp <- Alias$new(m, "jp", j)

  expect_true(i$isValid())
  expect_true(j$isValid())
  expect_equal(i$getDomainViolations(), NULL)
  expect_equal(j$getDomainViolations()[[1]]$violations, c(" seattle"))
  expect_equal(ip$getDomainViolations(), NULL)
  expect_equal(jp$getDomainViolations()[[1]]$violations, c(" seattle"))

  expect_equal(length(m$getDomainViolations()), 2)
  dv <- m$getDomainViolations()
  expect_equal(dv[[1]]$symbol, j)
  expect_equal(dv[[1]]$dimension, 1)
  expect_equal(dv[[1]]$domain, i)
  expect_equal(dv[[1]]$violations, c(" seattle"))

  # finddomainviolations  for alias
  df <- jp$findDomainViolations()
  expect_equal(as.character(df[[1]]), " seattle")

  expect_true(jp$hasDomainViolations())
  expect_equal(jp$countDomainViolations(), 1)
  jp$dropDomainViolations()
  expect_equal(as.character(j$records$i), "Hamburg")
})

# test findDomainViolations method
test_that("test_num_86", {
  m <- Container$new()
  i <- Set$new(m, "i", records = c("j1", "j2"))
  a <- Parameter$new(m, "a", i, records = data.frame(paste0("j", 1:10), 1:10))
  a2 <- Parameter$new(m, "a2", c(i, i), records = data.frame(paste0("j", 1:10), paste0("j", 1:10), 1:10))
  expect_true(a$isValid())
  expect_true(is.data.frame(a$findDomainViolations()))
  expect_equal(a$findDomainViolations(), a$records[3:10, ])

  expect_equal(a$countDomainViolations(), 8)
  expect_true(a$hasDomainViolations())
  # container hasDomainViolations()
  expect_true(m$hasDomainViolations())

  # container countDomainViolations()
  expect_equal(m$countDomainViolations()$a, 8)
  expect_equal(m$countDomainViolations()$a2, 8)

  a$dropDomainViolations()
  expect_equal(as.character(a$records[, 1]), c("j1", "j2"))
  expect_false(a$hasDomainViolations())
  expect_equal(a$countDomainViolations(), 0)
  expect_equal(a$findDuplicateRecords(), data.frame())
  expect_true(a$isValid())

  # test dropdomainviolations for container
  m <- Container$new()
  i <- Set$new(m, "i", records = c("j1", "j2"))
  a <- Parameter$new(m, "a", i, records = data.frame(paste0("j", 1:10), 1:10))
  a2 <- Parameter$new(m, "a2", c(i, i), records = data.frame(paste0("j", 1:10), paste0("j", 1:10), 1:10))

  m$dropDomainViolations()
  expect_equal(as.character(a$records[, 1]), c("j1", "j2"))
  expect_false(m$hasDomainViolations())
  empty_named_list <- list()
  names(empty_named_list) <- character(0)
  expect_equal(m$countDomainViolations(), empty_named_list)
})


# test overwriting sets
test_that("test_num_87", {
  m <- Container$new()
  i <- Set$new(m, "i", records = c("a", "b", "c"))

  expect_true(inherits(m$addSet("i", records = c("f", "b", "c")), "Set"))
  expect_error(m$addSet("i", "a", records = c("f", "b", "c")))
  expect_true(inherits(m$addSet("i", records = c("f", "b", "c"), description = "hamburger"), "Set"))

  expect_equal(m["i"]$description, "hamburger")
  expect_true(inherits(m$addSet("i", records = c("f", "b", "c")), "Set"))
  expect_equal(m["i"]$description, "hamburger")

  expect_error(Set$new(m, "i", records = c("f", "b", "c")))
})

# test overwriting Parameters
test_that("test_num_88", {
  m <- Container$new()
  i <- Parameter$new(m, "i", "*", records = data.frame(paste0("i", 1:5), 1:5))

  expect_true(inherits(m$addParameter("i", "*", records = data.frame(paste0("i", 1:5), 1:5)), "Parameter"))
  expect_error(m$addParameter("i", "a", records = data.frame(paste0("i", 1:5), 1:5)))
  expect_true(inherits(m$addParameter("i", "*", records = data.frame(paste0("i", 1:5), 1:5), description = "hamburger"), "Parameter"))

  expect_equal(m["i"]$description, "hamburger")
  expect_true(inherits(m$addParameter("i", "*", records = data.frame(paste0("i", 1:5), 1:5)), "Parameter"))
  expect_equal(m["i"]$description, "hamburger")

  expect_error(Parameter$new(m, "i", records = data.frame(paste0("i", 1:5), 1:5)))

  # overwriting parameter with domain
  m <- Container$new()
  i <- Set$new(m, "i", records = paste0("i", 1:5))
  j <- Set$new(m, "j", records = paste0("j", 1:5))
  d <- Parameter$new(m, "d", domain = c(i, j), records = diag(5))

  # test filtering zeros
  expect_equal(as.character(d$records$i), paste0("i", 1:5))
  expect_equal(as.character(d$records$j), paste0("j", 1:5))
  expect_equal(as.numeric(d$records$value), replicate(5, 1))

  # overwriting
  m$addParameter("d", , domain = c(i, j), records = matrix(0, 5, 5))
  expect_true(nrow(d$records) == 0)
})

# test overwriting Variables
test_that("test_num_89", {
  m <- Container$new()
  recs <- data.frame(paste0("i", 1:5), 1:5)
  colnames(recs) <- c("1", "level")
  i <- Variable$new(m, "i", "free", "*", records = recs)

  expect_true(inherits(m$addVariable("i", "free", "*", records = recs), "Variable"))
  expect_error(m$addVariable("i", "free", "a", records = recs))
  expect_true(inherits(m$addVariable("i", "free", "*", records = recs, description = "hamburger"), "Variable"))

  expect_equal(m["i"]$description, "hamburger")
  expect_true(inherits(m$addVariable("i", "free", "*", records = recs), "Variable"))
  expect_equal(m["i"]$description, "hamburger")

  expect_error(Variable$new(m, "i", "free", records = recs))
})

# test overwriting Equations
test_that("test_num_90", {
  m <- Container$new()
  recs <- data.frame(paste0("i", 1:5), 1:5)
  colnames(recs) <- c("1", "level")
  i <- Equation$new(m, "i", "eq", "*", records = recs)

  expect_true(inherits(m$addEquation("i", "eq", "*", records = recs), "Equation"))
  expect_error(m$addEquation("i", "eq", "a", records = recs))
  expect_true(inherits(m$addEquation("i", "eq", "*", records = recs, description = "hamburger"), "Equation"))

  expect_equal(m["i"]$description, "hamburger")
  expect_true(inherits(m$addEquation("i", "eq", "*", records = recs), "Equation"))
  expect_equal(m["i"]$description, "hamburger")

  expect_error(Equation$new(m, "i", "eq", records = recs))
})

# test overwriting Alias
test_that("test_num_91", {
  m <- Container$new()
  i <- Set$new(m, "i", records = c("a", "b", "c"))
  j <- Set$new(m, "j", records = c("i", "j", "k"))
  ip <- m$addAlias("ip", i)

  expect_true(inherits(ip, "Alias"))
  expect_equal(ip$aliasWith, i)
  expect_error(m$addAlias("j", i))

  ip <- m$addAlias("ip", j)
  expect_true(inherits(ip, "Alias"))
  expect_equal(ip$aliasWith, j)
})

# change column headings when changing domain
test_that("test_num_92", {
  m <- Container$new()
  i <- Set$new(m, "i", records = paste0("i", 1:5))

  a <- Parameter$new(m, "a", c(i, i), records = data.frame(p_1 = paste0("i", 1:5), p_2 = paste0("i", 1:5), 1:5))
  a$domain <- c("p", "p")
  expect_equal(a$domain, c("p", "p"))
  expect_true(a$isValid())
  expect_equal(colnames(a$records), c("p_1", "p_2", "value"))

  m <- Container$new()
  i <- Set$new(m, "i", records = paste0("i", 1:5))
  ip <- Alias$new(m, "ip", i)

  a <- Parameter$new(m, "a", c(i, ip), records = data.frame(p_1 = paste0("i", 1:5), p_2 = paste0("i", 1:5), 1:5))
  a$domain <- c("p", "p")
  expect_equal(a$domain, c("p", "p"))
  expect_true(a$isValid())
  expect_equal(colnames(a$records), c("p_1", "p_2", "value"))

  m <- Container$new()
  i <- Set$new(m, "i", records = paste0("i", 1:5))
  r <- Set$new(m, "r", records = paste0("r", 1:5))

  a <- Parameter$new(m, "a", c(i, i), records = data.frame(r_1 = paste0("i", 1:5), r_2 = paste0("i", 1:5), 1:5))
  a$domain <- c(r, r)
  expect_equal(a$domain, c(r, r))
  expect_true(a$isValid())
  expect_equal(colnames(a$records), c("r_1", "r_2", "value"))
})

# white space removal and user category survival
test_that("test_num_93", {
  recs <- data.frame(uni = paste0("i", 1:3), stringsAsFactors = TRUE)
  levels(recs[, 1]) <- append(levels(recs[, 1]), "j1")
  expect_equal(levels(recs[, 1]), c("i1", "i2", "i3", "j1"))

  m <- Container$new()
  i <- Set$new(m, "i", records = recs)

  expect_equal(levels(i$records$uni), c("i1", "i2", "i3", "j1"))

  recs <- data.frame(uni = paste0("i", 1:3), value = 1:3, stringsAsFactors = TRUE)
  levels(recs[, 1]) <- append(levels(recs[, 1]), "j1")
  expect_equal(levels(recs[, 1]), c("i1", "i2", "i3", "j1"))

  a <- Parameter$new(m, "a", i, records = recs)
  expect_equal(levels(a$records$uni), c("i1", "i2", "i3", "j1"))

  recs <- data.frame(uni = paste0("i", 1:3), level = 1:3, stringsAsFactors = TRUE)
  levels(recs[, 1]) <- append(levels(recs[, 1]), "j1")
  expect_equal(levels(recs[, 1]), c("i1", "i2", "i3", "j1"))

  v <- Variable$new(m, "v", "free", i, records = recs)
  expect_equal(levels(v$records$uni), c("i1", "i2", "i3", "j1"))

  e <- Equation$new(m, "e", "eq", i, records = recs)
  expect_equal(levels(e$records$uni), c("i1", "i2", "i3", "j1"))
})

test_that("test_num_94", {
  m <- Container$new()
  i <- Set$new(m, "i", records = c(" i1 ", "i2", "i3"))
  expect_equal(i$getUELs(), c(" i1", "i2", "i3"))
  i$setUELs(c(" i1 ", " i2 ", "i3"))
  expect_equal(i$getUELs(), c(" i1", " i2", "i3"))

  m <- Container$new()
  i <- Set$new(m, "i", records = c(" i1 ", "i2", "i3"))
  ip <- Alias$new(m, "ip", i)
  expect_equal(ip$getUELs(), c(" i1", "i2", "i3"))
  ip$setUELs(c(" i1 ", " i2 ", "i3"))
  expect_equal(i$getUELs(), c(" i1", " i2", "i3"))
  expect_equal(i$getUELs(), ip$getUELs())

  m <- Container$new()
  i <- Set$new(m, "i", records = c(" i1 ", "i2", "i3"))
  i$reorderUELs(c("i2", " i1", "i3"))
  expect_equal(i$getUELs(), c("i2", " i1", "i3"))

  m <- Container$new()
  i <- Set$new(m, "i", records = c(" i1 ", "i2", "i3"))
  ip <- Alias$new(m, "ip", i)
  ip$reorderUELs(c("i2", " i1", "i3"))
  expect_equal(ip$getUELs(), c("i2", " i1", "i3"))
  expect_equal(i$getUELs(), ip$getUELs())

  m <- Container$new()
  i <- Set$new(m, "i", records = c(" i1 ", "i2", "i3"))
  i$renameUELs(c("i1   ", "  i2   ", " i3   "))
  expect_equal(i$getUELs(), c("i1", "  i2", " i3"))

  m$renameUELs(c("i1" = "cheeseburgerz "))
  expect_equal(i$getUELs(), c("cheeseburgerz", "  i2", " i3"))

  m <- Container$new()
  i <- Set$new(m, "i", records = c(" i1 ", "i2", "i3"))
  ip <- Alias$new(m, "ip", i)
  ip$renameUELs(c("i1   ", "  i2   ", " i3   "))
  expect_equal(ip$getUELs(), c("i1", "  i2", " i3"))
  expect_equal(i$getUELs(), ip$getUELs())

  m <- Container$new()
  i <- Set$new(m, "i", records = c(" i1 ", "i2", "i3"))
  i$addUELs("i4   ")
  expect_equal(i$getUELs(), c(" i1", "i2", "i3", "i4"))
  m$renameUELs(c("i1" = "cheeseburgerz "))
  expect_equal(i$getUELs(), c(" i1", "i2", "i3", "i4"))

  m <- Container$new()
  i <- Set$new(m, "i", records = c(" i1 ", "i2", "i3"))
  ip <- Alias$new(m, "ip", i)
  ip$addUELs("i4   ")
  expect_equal(ip$getUELs(), c(" i1", "i2", "i3", "i4"))
  m$renameUELs(c("i1" = "cheeseburgerz "))
  expect_equal(i$getUELs(), ip$getUELs())
})

# test reading and writing UniverseAlias with Container
test_that("test_num_95", {
  skip_if_no_gams()
  m <- Container$new()

  # read all symbols
  m$read(testthat::test_path("testdata", "test95.gdx"))

  # test supercall read
  rl <- readGDX(testthat::test_path("testdata", "test95.gdx"))
  m2 <- Container$new()
  m2$readList(rl)
  expect_equal(m$equals(m2), TRUE)

  # write everything
  m$write(testthat::test_path("gt.gdx"))

  expect_true(inherits(m["h"], "UniverseAlias"))
  expect_true(inherits(m["ip"], "Alias"))
  expect_true(inherits(m["i"], "Set"))

  expect_equal(m$listSets(), "i")
  expect_equal(m$listAliases(), c("ip", "h"))

  ret <- system2(
    command = "gdxdiff", args =
      paste0(testthat::test_path("testdata", "test95.gdx"), " ", testthat::test_path("gt.gdx")),
    stdout = FALSE
  )
  expect_equal(ret, 0)

  # write everything
  m$write(testthat::test_path("gt.gdx"), mode = "string")

  expect_true(inherits(m["h"], "UniverseAlias"))
  expect_true(inherits(m["ip"], "Alias"))
  expect_true(inherits(m["i"], "Set"))

  expect_equal(m$listSets(), "i")
  expect_equal(m$listAliases(), c("ip", "h"))

  ret <- system2(
    command = "gdxdiff", args =
      paste0(testthat::test_path("testdata", "test95.gdx"), " ", testthat::test_path("gt.gdx")),
    stdout = FALSE
  )
  expect_equal(ret, 0)

  # test the super call write
  writeList <- m$asList()
  writeGDX(writeList, "gt.gdx")

  ret <- system2(
    command = "gdxdiff", args =
      paste0(testthat::test_path("testdata", "test95.gdx"), " ", testthat::test_path("gt.gdx")),
    stdout = FALSE
  )
  expect_equal(ret, 0)
})

# test reading and writing UniverseAlias with Container
test_that("test_num_96", {
  skip_if_no_gams()
  m <- Container$new()

  # read all symbols
  # uses the same gdx from test95
  m$read(testthat::test_path("testdata", "test95.gdx"))

  m2 <- Container$new(m)
  # write everything
  m2$write(testthat::test_path("gt.gdx"))

  expect_true(inherits(m2["h"], "UniverseAlias"))
  expect_true(inherits(m2["ip"], "Alias"))
  expect_true(inherits(m2["i"], "Set"))

  ret <- system2(
    command = "gdxdiff", args =
      paste0(testthat::test_path("testdata", "test95.gdx"), " ", testthat::test_path("gt.gdx")),
    stdout = FALSE
  )
  expect_equal(ret, 0)

  # write everything
  m2$write(testthat::test_path("gt.gdx"), mode = "string")

  expect_true(inherits(m2["h"], "UniverseAlias"))
  expect_true(inherits(m2["ip"], "Alias"))
  expect_true(inherits(m2["i"], "Set"))

  ret <- system2(
    command = "gdxdiff", args =
      paste0(testthat::test_path("testdata", "test95.gdx"), " ", testthat::test_path("gt.gdx")),
    stdout = FALSE
  )
  expect_equal(ret, 0)

  # test the super call write
  writeList <- m$asList()
  writeGDX(writeList, "gt.gdx")

  ret <- system2(
    command = "gdxdiff", args =
      paste0(testthat::test_path("testdata", "test95.gdx"), " ", testthat::test_path("gt.gdx")),
    stdout = FALSE
  )
  expect_equal(ret, 0)
})

# UniverseAlias UEL functions
test_that("test_num_97", {
  m <- Container$new()
  i <- Set$new(m, "i", records = paste0("i", 1:5))
  ip <- UniverseAlias$new(m, "ip")
  p0 <- Parameter$new(m, "p0", ip, records = data.frame(paste0("i", 1:5), 1:5))

  expect_equal(m$getUELs(), paste0("i", 1:5))
  m$renameUELs(c("i1" = "cheeseburgerz"))
  expect_equal(m$getUELs(), c("cheeseburgerz", "i2", "i3", "i4", "i5"))

  p0$addUELs("mustard")
  expect_equal(p0$getUELs(), c("cheeseburgerz", "i2", "i3", "i4", "i5", "mustard"))

  m$removeUELs()

  expect_equal(m$getUELs(), c("cheeseburgerz", "i2", "i3", "i4", "i5"))

  m$renameUELs(c("i2 " = "cheeseburgerz"))
  expect_equal(m$getUELs(), c("cheeseburgerz", "i2", "i3", "i4", "i5"))
})

# UniverseAlias as domain
test_that("test_num_98", {
  m <- Container$new()
  i <- Set$new(m, "i", records = paste0("i", 1:5))
  ip <- UniverseAlias$new(m, "ip")
  p0 <- Parameter$new(m, "p0", ip, records = data.frame(paste0("i", 1:5), 1:5))

  expect_true(p0$isValid())
  expect_equal(p0$domain[[1]], ip)
  expect_equal(p0$domainType, "regular")
  expect_equal(p0$dimension, 1)
  expect_true(is.null(p0$getDomainViolations()))
  expect_equal(nrow(p0$findDomainViolations()), 0)
  expect_true(!p0$hasDomainViolations())
  expect_equal(p0$countDomainViolations(), 0)
  expect_true(!p0$hasDuplicateRecords())
  expect_equal(p0$findDuplicateRecords(), data.frame())
  expect_equal(p0$countDuplicateRecords(), 0)
  expect_equal(
    p0$summary,
    list(
      name = "p0", description = "", domain = "ip", domainType = "regular",
      dimension = 1, numberRecords = 5
    )
  )

  m$removeSymbols("ip")
  expect_true(p0$isValid())
  expect_equal(p0$domain[[1]], "*")
  expect_equal(p0$domainType, "none")
  expect_equal(p0$dimension, 1)
  expect_true(is.null(p0$getDomainViolations()))
  expect_true(!p0$hasDomainViolations())
  expect_equal(nrow(p0$findDomainViolations()), 0)
  expect_equal(p0$countDomainViolations(), 0)
  expect_true(!p0$hasDuplicateRecords())
  expect_equal(p0$findDuplicateRecords(), data.frame())
  expect_equal(p0$countDuplicateRecords(), 0)
  expect_equal(
    p0$summary,
    list(
      name = "p0", description = "", domain = "*", domainType = "none",
      dimension = 1, numberRecords = 5
    )
  )

  expect_true(!ip$isValid())
  expect_equal(
    ip$summary,
    list(
      "name" = "ip",
      description = "Aliased with *",
      aliasWith = "*"
    )
  )
})

# remove symbols including alias
test_that("test_num_99", {
  m <- Container$new()
  i <- Set$new(m, "i")
  ii <- Alias$new(m, "ii", i)
  j <- Set$new(m, "j", domain = ii)

  m$removeSymbols("ii")
  # should affect j
  expect_equal(j$domain, "*")

  ii <- Alias$new(m, "ii", i)
  m$removeSymbols("i")

  expect_true(is.null(m["ii"]))
  expect_equal(j$domain, "*")
})

# GDX read errors
test_that("test_num_100", {
  m <- Container$new()
  i <- Set$new(m, "i")

  # read all symbols: expect error because i already exists
  expect_error(m$read(testthat::test_path("testdata", "test95.gdx")))

  m2 <- Container$new()
  m2$read(testthat::test_path("testdata", "test95.gdx"))

  # read all symbols: expect error because i already exists
  expect_error(m$read(m2))

  # read container into container
  m <- Container$new(m2)
  expect_equal(m$listSymbols(), m2$listSymbols())

  # expect error on reading only alias
  m <- Container$new()
  expect_error(m$read(testthat::test_path("testdata", "test95.gdx"), symbols = "ip"))

  # expect error if user wants to read a symbol from another container but it doesn't exist
  m <- Container$new()
  expect_error(m$read(m2, symols = "j"))

  # expect error on reading only alias
  m2 <- Container$new()
  expect_error(m2$read(testthat::test_path("testdata", "test95.gdx"), symols = "ip"))
})

# alias duplicaterecords
test_that("test_num_101", {
  m <- Container$new()
  i <- Set$new(m, "i", records = replicate(5, "i1"))
  ip <- Alias$new(m, "ip", i)

  expect_equal(ip$countDuplicateRecords(), 4)
  expect_equal(ip$findDuplicateRecords(), ip$records[2:5, , drop = FALSE])
  expect_true(ip$hasDuplicateRecords())
  ip$dropDuplicateRecords()
  expect_equal(nrow(i$records), 1)
})

# summary test
test_that("test_num_102", {
  m <- Container$new()
  # expect_error(m$read(testthat::test_path("testdata", "trnsport_with_alias.gdx"), records="true"))

  m <- Container$new()
  m$read(testthat::test_path("testdata", "trnsport_with_alias.gdx"))

  # test supercall read
  rl <- readGDX(testthat::test_path("testdata", "trnsport_with_alias.gdx"))
  m2 <- Container$new()
  m2$readList(rl)
  expect_equal(m$equals(m2), TRUE)

  expect_equal(m["i"]$summary, list(
    name = "i",
    description = "canning plants",
    isSingleton = FALSE,
    domain = "*",
    domainType = "none",
    dimension = 1,
    numberRecords = 2
  ))

  expect_equal(m["d"]$summary, list(
    name = "d",
    description = "distance in thousands of miles",
    domain = c("i", "j"),
    domainType = "regular",
    dimension = 2,
    numberRecords = 6
  ))

  expect_equal(m["x"]$summary, list(
    name = "x",
    description = "shipment quantities in cases",
    type = "positive",
    domain = c("i", "j"),
    domainType = "regular",
    dimension = 2,
    numberRecords = 6
  ))

  expect_equal(m["demand"]$summary, list(
    name = "demand",
    description = "satisfy demand at market j",
    type = "geq",
    domain = "j",
    domainType = "regular",
    dimension = 1,
    numberRecords = 3
  ))

  expect_equal(m["ip"]$summary, list(
    name = "ip",
    description = "canning plants",
    aliasWith = "i",
    isSingleton = FALSE,
    domain = "*",
    domainType = "none",
    dimension = 1,
    numberRecords = 2
  ))

  # container
  m <- Container$new()

  m <- Container$new()
  m$read(testthat::test_path("testdata", "trnsport_with_alias.gdx"))
  expect_equal(m["i"]$summary, list(
    name = "i",
    description = "canning plants",
    isSingleton = FALSE,
    domain = "*",
    domainType = "none",
    dimension = 1,
    numberRecords = 2
  ))

  expect_equal(m["d"]$summary, list(
    name = "d",
    description = "distance in thousands of miles",
    domain = c("i", "j"),
    domainType = "regular",
    dimension = 2,
    numberRecords = 6
  ))

  expect_equal(m["x"]$summary, list(
    name = "x",
    description = "shipment quantities in cases",
    type = "positive",
    domain = c("i", "j"),
    domainType = "regular",
    dimension = 2,
    numberRecords = 6
  ))

  expect_equal(m["demand"]$summary, list(
    name = "demand",
    description = "satisfy demand at market j",
    type = "geq",
    domain = "j",
    domainType = "regular",
    dimension = 1,
    numberRecords = 3
  ))

  expect_equal(m["ip"]$summary, list(
    name = "ip",
    description = "canning plants",
    aliasWith = "i",
    isSingleton = FALSE,
    domain = "*",
    domainType = "none",
    dimension = 1,
    numberRecords = 2
  ))
})

# test partial write
test_that("test_num_103", {
  m <- Container$new(testthat::test_path("testdata", "trnsport.gdx"))
  m$write("partial_write.gdx", symbols = "a")

  m1 <- Container$new("partial_write.gdx")
  expect_equal(m1["a"]$domain, "i")
  expect_equal(m1["a"]$domainType, "relaxed")

  m$write("partial_write.gdx", symbols = "a", mode = "string")

  m1 <- Container$new("partial_write.gdx")
  expect_equal(m1["a"]$domain, "i")
  expect_equal(m1["a"]$domainType, "relaxed")

  # test the super call write
  writeList <- m$asList()
  writeGDX(writeList, "partial_write.gdx", symbols = "a")

  m1 <- Container$new("partial_write.gdx")
  expect_equal(m1["a"]$domain, "i")
  expect_equal(m1["a"]$domainType, "relaxed")
})

# test symbols argument container methods
test_that("test_num_104", {
  m <- Container$new()
  i <- Set$new(m, "i", records = paste0("i", 1:10))
  j <- Set$new(m, "j", records = paste0("j", 1:5))
  p_dv <- Parameter$new(m, "p_dv", domain = c(i, j), records = data.frame(c("i1", "i12", "i0", "i5"), c("j2", "j6", "j1", "j0"), 11:14))
  p_dup <- Parameter$new(m, "p_dup", domain = c(i, j), records = data.frame(c("i1", "i1", "i3", "i5"), c("j2", "j2", "j1", "j2"), c(11, 13, 12, 14)))
  dv <- m$getDomainViolations(symbols = "p_dv")
  expect_equal(length(dv), 2)

  expect_true(m$hasDomainViolations())
  expect_true(!m$hasDomainViolations(symbols = "p_dup"))
  expect_true(m$hasDomainViolations(symbols = "p_dv"))

  expect_true(m$hasDuplicateRecords())
  expect_true(!m$hasDuplicateRecords(symbols = "p_dv"))
  expect_true(m$hasDuplicateRecords(symbols = "p_dup"))

  m$dropDomainViolations(symbols = "p_dup") # should do nothing
  expect_true(m$hasDomainViolations())
  dv <- m$getDomainViolations(symbols = "p_dv")
  expect_equal(length(dv), 2)

  m$dropDuplicateRecords(symbols = "p_dv") # should do nothing
  dups <- m$countDuplicateRecords(symbols = "p_dup")
  expect_equal(dups, list(p_dup = 1))

  m$dropDomainViolations(symbols = "p_dv")
  expect_true(!m$hasDomainViolations())
  dv <- m$getDomainViolations(symbols = "p_dv")
  expect_true(is.null(dv))

  m$dropDuplicateRecords(symbols = "p_dv") # should do nothing
  dups <- m$countDuplicateRecords(symbols = "p_dup")
  expect_equal(dups, list(p_dup = 1))
})

# test equals
test_that("test_num_105", {
  # set comparison
  m <- Container$new()
  i <- Set$new(m, "i")
  j <- Set$new(m, "j")
  expect_false(i$equals(j))
  expect_true(i$equals(j, checkMetaData = FALSE))
  expect_error(i$equals(j, checkMetaData = FALSE, verbose = 10))

  # error because of domain type mismatch
  m <- Container$new()
  i <- Set$new(m, "i")
  j <- Set$new(m, "j", i)
  expect_false(i$equals(j, checkMetaData = FALSE))
  expect_error(v1$equals(v2, checkMetaData = FALSE, checkElementText = 6))

  # error because of validity
  j$records <- data.frame(i = c("j1", "j2"), j = c("k1", "k2"), k = c("l1", "l2"))
  expect_error(i$equals(j, checkMetaData = FALSE))
  expect_error(j$equals(i, checkMetaData = FALSE))

  # other type error
  expect_error(i$equals(2))

  # columns arg
  p1 <- Parameter$new(m, "p1")
  p2 <- Parameter$new(m, "p2")

  v1 <- Variable$new(m, "v1")
  v2 <- Variable$new(m, "v2")

  expect_error(v1$equals(v2, checkUELs = 2, checkMetaData = FALSE))
  expect_error(v1$equals(v2, checkMetaData = 6))

  expect_error(v1$equals(v2, checkMetaData = FALSE, atol = TRUE))
  expect_error(v1$equals(v2, checkMetaData = FALSE, rtol = TRUE))

  expect_error(v1$equals(v2, checkMetaData = FALSE, atol = c(1, 2)))

  expect_error(v1$equals(v2, columns = c("blah1", "blah2"), checkMetaData = FALSE, rtol = 0))

  m <- Container$new()
  i <- Set$new(m, "i", records = c("i1", "i2"))
  j <- Set$new(m, "j", records = c("j1", "j2"))

  e0 <- Equation$new(m, "e0", type = "eq", description = "empty eq from m")
  e1 <- Equation$new(m, "e1", type = "eq", domain = c(i, j))
  e2 <- Equation$new(m, "e2", type = "eq", domain = i)
  e2a <- Equation$new(m, "e2a", type = "eq", domain = i, records = data.frame(i = "i1", level = 1))
  e2b <- Equation$new(m, "e2b", type = "eq", domain = i)
  e3 <- Equation$new(m, "e3", type = "eq", domain = j)

  expect_false(e2$equals(e3))
  expect_false(e2$equals(e2a))
  expect_false(e2$equals(e2b))
  expect_true(e2$equals(e2b, checkMetaData = FALSE))

  m2 <- Container$new()
  e02 <- Equation$new(m2, "e0", type = "eq", description = "empty eq from m2")
  expect_true(e02$equals(e0, checkMetaData = FALSE))
  expect_false(e02$equals(e0, checkMetaData = TRUE))

  m2$removeSymbols("e0")
  v02 <- Variable$new(m2, "e0", description = "empty var from m2")
  expect_true(v02$equals(e0, checkMetaData = FALSE))
  expect_false(v02$equals(e0, checkMetaData = TRUE))

  m <- Container$new()
  i <- Set$new(m, "i", records = c("i1", "i2"))
  i$setUELs(c("i1", "i2", "i3", "i4"))

  m2 <- Container$new()
  i2 <- Set$new(m2, "i", records = c("i1", "i2"))
  expect_false(i$equals(i2, checkUELs = TRUE))
  expect_true(i$equals(i2, checkUELs = FALSE))

  # element text
  m <- Container$new()
  i <- Set$new(m, "i", records = data.frame(c("i1", "i2")))

  m2 <- Container$new()
  i2 <- Set$new(m2, "i", records = data.frame(c("i1", "i2"), c("first elemnt", "second element")))

  expect_true(i$equals(i2, checkElementText = FALSE))
  expect_false(i$equals(i2))

  # compare records
  m <- Container$new()
  i1 <- Set$new(m, "i1", records = data.frame(c("i1", "i2")))
  i2 <- Set$new(m, "i2", records = data.frame(c("i2", "i3")))
  expect_false(i1$equals(i2, checkMetaData = FALSE))

  # parameter records comparison
  m <- Container$new()
  p1 <- Parameter$new(m, "p1", records = SpecialValues[["NA"]])
  p2 <- Parameter$new(m, "p2", records = SpecialValues[["NA"]])
  p3 <- Parameter$new(m, "p3", records = SpecialValues[["EPS"]])
  expect_true(p1$equals(p2, checkMetaData = FALSE))
  expect_false(p1$equals(p3, checkMetaData = FALSE))

  m <- Container$new()
  p1 <- Parameter$new(m, "p1", records = SpecialValues[["EPS"]])
  p2 <- Parameter$new(m, "p2", records = SpecialValues[["EPS"]])
  p3 <- Parameter$new(m, "p3", records = SpecialValues[["UNDEF"]])
  expect_true(p1$equals(p2, checkMetaData = FALSE))
  expect_false(p1$equals(p3, checkMetaData = FALSE))

  m <- Container$new()
  p1 <- Parameter$new(m, "p1", records = SpecialValues[["UNDEF"]])
  p2 <- Parameter$new(m, "p2", records = SpecialValues[["UNDEF"]])
  p3 <- Parameter$new(m, "p3", records = SpecialValues[["NA"]])
  expect_true(p1$equals(p2, checkMetaData = FALSE))
  expect_false(p1$equals(p3, checkMetaData = FALSE))

  # scalar
  m <- Container$new()
  p1 <- Parameter$new(m, "p1", records = 10)
  p2 <- Parameter$new(m, "p2", records = 10)
  p3 <- Parameter$new(m, "p3", records = 5)
  expect_true(p1$equals(p2, checkMetaData = FALSE))
  expect_false(p1$equals(p3, checkMetaData = FALSE))

  # 1D param
  m <- Container$new()
  i <- Set$new(m, "i", records = c("i1", "i2", "i3"))
  p1 <- Parameter$new(m, "p1", domain = i, records = data.frame(c("i1", "i2", "i3"), c(2, 4, 5)))
  p2 <- Parameter$new(m, "p2", domain = i, records = data.frame(c("i1", "i2", "i3"), c(3, 5, 5)))
  expect_false(p1$equals(p2, checkMetaData = FALSE))

  # 2D param with special values
  m <- Container$new()
  i <- Set$new(m, "i", records = c("i1", "i2", "i3"))
  j <- Set$new(m, "j", records = c("j1", "j2", "j3"))
  p1 <- Parameter$new(m, "p1", domain = c(i, j), records = data.frame(c("i1", "i2", "i3"), c("j1", "j2", "j3"), c(SpecialValues[["NA"]], 4, SpecialValues$UNDEF)))
  p2 <- Parameter$new(m, "p2", domain = c(i, j), records = data.frame(c("i1", "i2", "i3"), c("j1", "j2", "j3"), c(SpecialValues$UNDEF, 4, SpecialValues[["NA"]])))
  p3 <- Parameter$new(m, "p3", domain = c(i, j), records = data.frame(c("i1", "i2", "i3"), c("j1", "j2", "j3"), c(SpecialValues[["NA"]], 5, SpecialValues$UNDEF)))

  expect_false(p1$equals(p2, checkMetaData = FALSE))
  expect_false(p1$equals(p3, checkMetaData = FALSE))

  # variable
  m <- Container$new()
  v0 <- Variable$new(m, "v0", records = data.frame(level = 3))
  v0p <- Variable$new(m, "v0p", records = data.frame(level = 2.99))
  expect_true(v0$equals(v0p, checkMetaData = FALSE, atol = 0.1))
  expect_true(v0$equals(v0p, columns = "level", checkMetaData = FALSE, atol = 0.1))
  expect_true(v0$equals(v0p, checkMetaData = FALSE, atol = 0.1))
  expect_true(v0$equals(v0p, columns = c("level", "marginal"), checkMetaData = FALSE, atol = 0.1))
  expect_false(v0$equals(v0p, columns = c("level", "marginal"), checkMetaData = FALSE, atol = 0))
  expect_error(v0$equals(v0p, checkMetaData = FALSE, atol = c(level = 0, scale = 0.1), rtol = c(marginal = 0, scale = 0.1)))
  expect_error(v0$equals(v0p, checkMetaData = FALSE, atol = c(level = 0, scale = 0.1), verbose = TRUE))

  m <- Container$new()
  i <- Set$new(m, "i", records = paste0("i", 1:5))
  v1 <- Variable$new(m, "v1", domain = i, records = data.frame(c("i1", "i4", "i5"), level = c(3, 4, 5)))
  v1p <- Variable$new(m, "v1p", domain = i, records = data.frame(c("i1", "i4", "i5"), level = c(2.95, 4.03, 5.09)))
  expect_true(v1$equals(v1p, columns = "level", checkMetaData = FALSE, atol = 0.1))
  expect_true(v1$equals(v1p, checkMetaData = FALSE, atol = 0.1))
  expect_false(v1$equals(v1p, columns = c("level", "marginal"), checkMetaData = FALSE, atol = 0))
  expect_error(v1$equals(v1p, checkMetaData = FALSE, atol = c(level = 0, scale = 0.1), rtol = c(marginal = 0, scale = 0.1)))
  expect_error(v1$equals(v1p, checkMetaData = FALSE, atol = c(level = 0, scale = 0.1), verbose = TRUE))

  m <- Container$new()
  i <- Set$new(m, "i", records = paste0("i", 1:5))
  j <- Set$new(m, "j", records = paste0("j", 1:5))
  v2 <- Variable$new(m, "v2", domain = c(i, j), records = data.frame(c("i1", "i4", "i5"), c("j2", "j4", "j1"), level = c(3, NA, 5), marginal = c(NaN, 4, 5)))
  v2p <- Variable$new(m, "v2p", domain = c(i, j), records = data.frame(c("i1", "i4", "i5"), c("j2", "j4", "j1"), level = c(2.95, NA, 5.09), marginal = c(NaN, 4, 5)))

  expect_true(v1$equals(v1p, columns = "level", checkMetaData = FALSE, atol = 0.1))
  expect_true(v1$equals(v1p, checkMetaData = FALSE, atol = 0.1))
  expect_true(v1$equals(v1p, columns = c("level", "marginal"), checkMetaData = FALSE, atol = 0.1))
  expect_false(v1$equals(v1p, columns = c("level", "marginal"), checkMetaData = FALSE, atol = 0))
  expect_error(v1$equals(v1p, checkMetaData = FALSE, atol = c(level = 0, scale = 0.1), rtol = c(marginal = 0, scale = 0.1)))
  expect_error(v1$equals(v1p, checkMetaData = FALSE, atol = c(level = 0, scale = 0.1), verbose = TRUE))
})

# test equals for alias and unialias
test_that("test_num_106", {
  m <- Container$new()
  i <- Set$new(m, "i", records = c("i1", "i2", "i3"))
  j <- Set$new(m, "j", records = c("i1", "i2", "i3"))

  ip <- Alias$new(m, "ip", i)
  jp <- Alias$new(m, "jp", j)

  expect_true(i$equals(j, checkMetaData = FALSE))
  expect_true(ip$equals(jp, checkMetaData = FALSE))
  expect_false(ip$equals(jp, checkMetaData = TRUE))
  expect_true(ip$equals(j, checkMetaData = FALSE))
  expect_true(i$equals(jp, checkMetaData = FALSE))

  u <- UniverseAlias$new(m, "u")
  up <- UniverseAlias$new(m, "up")

  expect_true(u$equals(up, checkMetaData = FALSE))
  expect_false(u$equals(up))
})

# test equals for container and container
test_that("test_num_107", {
  m <- Container$new()
  i <- Set$new(m, "i")

  m1 <- Container$new()
  i1 <- Set$new(m1, "i")

  expect_true(m$equals(m1))
  j <- Set$new(m1, "j")
  expect_false(m$equals(m1))
  expect_error(m$equals(m1, verbose = TRUE))

  k <- Set$new(m, "k")
  expect_false(m$equals(m1))
  expect_error(m$equals(m1, verbose = TRUE))
})

# test partial domain_forwarding
test_that("test_num_107", {
  m <- Container$new()
  i <- Set$new(m, "i")
  j <- Set$new(m, "j")
  recs <- data.frame(i = c("a", "b", "c"), j = c("d", "e", "f"), val = c(1, 2, 3))
  d <- Parameter$new(m, "d",
    domain = c(i, j), records = recs, domainForwarding =
      c(TRUE, FALSE)
  )

  expect_true(is.null(j$records))
  expect_equal(nrow(i$records), 3)

  m <- Container$new()
  i <- Set$new(m, "i")
  j <- Set$new(m, "j")
  recs <- data.frame(i = c("a", "b", "c"), j = c("d", "e", "f"), val = c(1, 2, 3))
  expect_error(Parameter$new(m, "d1",
    domain = c(i, j), records = recs, domainForwarding =
      2
  ))
  expect_error(Parameter$new(m, "d2",
    domain = c(i, j), records = recs, domainForwarding =
      C(TRUE, TRUE, FALSE)
  ))

  d <- Parameter$new(m, "d",
    domain = c(i, j), records = recs, domainForwarding =
      c(FALSE, TRUE)
  )

  expect_true(is.null(i$records))
  expect_equal(nrow(j$records), 3)

  m <- Container$new()
  i <- Set$new(m, "i")
  j <- Set$new(m, "j")
  recs <- data.frame(i = c("a", "b", "c"), j = c("d", "e", "f"), val = c(1, 2, 3))
  d <- Parameter$new(m, "d",
    domain = c(i, j), records = recs, domainForwarding =
      TRUE
  )

  expect_equal(nrow(i$records), 3)
  expect_equal(nrow(j$records), 3)

  m <- Container$new()
  i <- Set$new(m, "i")
  j <- Set$new(m, "j")
  recs <- data.frame(i = c("a", "b", "c"), j = c("d", "e", "f"), val = c(1, 2, 3))
  d <- Parameter$new(m, "d",
    domain = c(i, j), records = recs, domainForwarding =
      FALSE
  )
  expect_true(is.null(i$records))
  expect_true(is.null(j$records))
})

# test generateRecords
test_that("test_num_108", {
  m <- Container$new()
  i <- Set$new(m, "i", records = paste0("i", 1:5))
  isub <- Set$new(m, "isub", domain = i)
  isub$generateRecords()
  expect_equal(nrow(isub$records), 5)

  p <- Parameter$new(m, "p", domain = i)
  p$generateRecords(density = 1)
  expect_equal(nrow(p$records), 5)

  p$generateRecords(density = 0.5)
  expect_equal(nrow(p$records), 2)

  # error because runif expects argument n and not size
  # expect_error(p$generateRecords(density=1, func=runif))

  rg <- function(size) {
    return(runif(size))
  }

  p$generateRecords(density = 1, func = rg)
  expect_equal(nrow(p$records), 5)

  rg_error <- function() {
    return(1)
  }

  # expect_error(p$generateRecords(func=runif))

  j <- Set$new(m, "j", records = paste0("j", 1:3))
  d <- Parameter$new(m, "d", domain = c(i, j))
  d$generateRecords()
  expect_equal(nrow(d$records), 15)
})

# test generateRecords for variable and equation
test_that("test_num_109", {
  m <- Container$new()
  i <- Set$new(m, "i", records = paste0("i", 1:5))
  e <- Equation$new(m, "e", "eq", domain = i)
  e$generateRecords()
  expect_equal(nrow(e$records), 5)
  expect_true(all(e$records$marginal == 0))
  expect_true(all(e$records$lower == 0))
  expect_true(all(e$records$upper == 0))
  expect_true(all(e$records$scale == 1))

  rg <- function(size) {
    return(runif(n = size))
  }
  e$generateRecords(func = rg)
  expect_equal(nrow(e$records), 5)
  expect_true(all(e$records$marginal == 0))
  expect_true(all(e$records$lower == 0))
  expect_true(all(e$records$upper == 0))
  expect_true(all(e$records$scale == 1))

  e$generateRecords(func = list(scale = rg))
  expect_equal(nrow(e$records), 5)
  expect_true(all(e$records$marginal == 0))
  expect_true(all(e$records$lower == 0))
  expect_true(all(e$records$upper == 0))
  expect_true(all(e$records$level == 0))

  e$generateRecords(func = list(scale = rg, marginal = rg))
  expect_equal(nrow(e$records), 5)
  expect_true(all(e$records$lower == 0))
  expect_true(all(e$records$upper == 0))
  expect_true(all(e$records$level == 0))
  expect_equal(colnames(e$records), c("i", "level", "marginal", "lower", "upper", "scale"))


  # test the same for variables
  m <- Container$new()
  i <- Set$new(m, "i", records = paste0("i", 1:5))
  v <- Variable$new(m, "v", "binary", domain = i)
  v$generateRecords()
  expect_equal(nrow(v$records), 5)
  expect_true(all(v$records$marginal == 0))
  expect_true(all(v$records$lower == 0))
  expect_true(all(v$records$upper == 1))
  expect_true(all(v$records$scale == 1))

  rg <- function(size) {
    return(runif(n = size))
  }
  v$generateRecords(func = rg)
  expect_equal(nrow(v$records), 5)
  expect_true(all(v$records$marginal == 0))
  expect_true(all(v$records$lower == 0))
  expect_true(all(v$records$upper == 1))
  expect_true(all(v$records$scale == 1))

  v$generateRecords(func = list(scale = rg))
  expect_equal(nrow(v$records), 5)
  expect_true(all(v$records$marginal == 0))
  expect_true(all(v$records$lower == 0))
  expect_true(all(v$records$upper == 1))
  expect_true(all(v$records$level == 0))

  v$generateRecords(func = list(scale = rg, marginal = rg))
  expect_equal(nrow(v$records), 5)
  expect_true(all(v$records$lower == 0))
  expect_true(all(v$records$upper == 1))
  expect_true(all(v$records$level == 0))
  expect_equal(colnames(v$records), c("i", "level", "marginal", "lower", "upper", "scale"))

  # try scalar variables and equations
  m <- Container$new()
  e0 <- Equation$new(m, "e0", "eq")
  v0 <- Variable$new(m, "v0", "binary")

  e0$generateRecords()
  expect_equal(colnames(e0$records), c("level", "marginal", "lower", "upper", "scale"))
  expect_true(all(e0$records$marginal == 0))
  expect_true(all(e0$records$lower == 0))
  expect_true(all(e0$records$upper == 0))
  expect_true(all(e0$records$scale == 1))

  v0$generateRecords()
  expect_equal(colnames(v0$records), c("level", "marginal", "lower", "upper", "scale"))
  expect_true(all(v0$records$marginal == 0))
  expect_true(all(v0$records$lower == 0))
  expect_true(all(v0$records$upper == 1))
  expect_true(all(v0$records$scale == 1))
})

# test generateRecords for multidimensional
test_that("test_num_110", {
  m <- Container$new()
  i <- Set$new(m, "i", records = paste0("i", 1:50))
  j <- Set$new(m, "j", records = paste0("j", 1:50))
  k <- Set$new(m, "k", records = paste0("k", 1:50))
  l <- Set$new(m, "l", records = paste0("l", 1:50))

  # create and define the symbol `a` with `regular` domains
  a <- Set$new(m, "a", c(i, j, k, l))

  # generate the records
  a$generateRecords(density = 0.05)
  expect_equal(nrow(a$records), (50**4) / 20)
})

# write empty gdx
test_that("test_num_111", {
  skip_if_no_gams()
  m <- Container$new()
  expect_true(is.null(m$write("empty.gdx")))
  expect_true(is.null(m$write("empty.gdx", mode = "string")))
  # test the super call write
  writeList <- m$asList()
  writeGDX(writeList, "empty.gdx")

  # write empty gdx with uelPriority
  m$write("gt.gdx", uelPriority = c("i1", "i2", "i3"))

  system2(
    command = "gdxdump", args =
      "gt.gdx uelTable=foo",
    stdout = "foo.gms"
  )

  system2(
    command = "gams", args =
      "foo.gms gdx=foo.gdx lo=0",
    stdout = FALSE
  )

  m <- Container$new("foo.gdx")
  expect_equal(m$getUELs(), c("i1", "i2", "i3"))


  writeGDX(writeList, "gt.gdx", uelPriority = c("i1", "i2", "i3"))
  system2(
    command = "gdxdump", args =
      "gt.gdx uelTable=foo",
    stdout = "foo.gms"
  )

  system2(
    command = "gams", args =
      "foo.gms gdx=foo.gdx lo=0",
    stdout = FALSE
  )

  m <- Container$new("foo.gdx")
  expect_equal(m$getUELs(), c("i1", "i2", "i3"))
})

# test copy
test_that("test_num_112", {
  m <- Container$new()
  i <- Set$new(m, "i", records = paste0("i", 1:50))
  p <- Parameter$new(m, "p")
  v <- Variable$new(m, "v")
  e <- Equation$new(m, "e", type = "eq")

  m2 <- Container$new()
  i$copy(m2)
  p$copy(m2)
  v$copy(m2)
  e$copy(m2)

  m3 <- Container$new()
  i <- Set$new(m3, "i")
  p <- Parameter$new(m3, "p")
  v <- Variable$new(m3, "v")
  e <- Equation$new(m3, "e", type = "eq")

  expect_error(i$copy(m2))
  expect_true(is.null(i$copy(m2, overwrite = TRUE)))
  expect_error(p$copy(m2))
  expect_true(is.null(p$copy(m2, overwrite = TRUE)))
  expect_error(v$copy(m2))
  expect_true(is.null(v$copy(m2, overwrite = TRUE)))
  expect_error(e$copy(m2))
  expect_true(is.null(e$copy(m2, overwrite = TRUE)))

  m <- Container$new()
  i <- Set$new(m, "i")
  m2 <- Container$new()
  i1 <- Parameter$new(m2, "i")
  p <- Parameter$new(m2, "p")
  expect_error(i$copy(m2))
  expect_error(i$copy(i))
  expect_error(p$copy(m, overwrite = "true"))

  m <- Container$new()
  i <- Set$new(m, "i")
  p <- Parameter$new(m, "p", domain = i)

  m2 <- Container$new()
  p$copy(m2)

  expect_equal(m2["p"]$domain[[1]], "i")
  expect_equal(m2["p"]$domainType, "relaxed")

  i2 <- Set$new(m2, "i", domain = c("*", "*"))
  i2$copy(m, overwrite = TRUE)

  expect_equal(p$domain[[1]]$dimension, 2)

  # todo
  expect_equal(p$isValid(force = TRUE), FALSE)

  m <- Container$new()
  i <- Set$new(m, "i", records = c("i1", "i2"))
  m2 <- Container$new()
  i2 <- Set$new(m2, "i", records = c("newi", "newi_1"))
  i2$copy(m, overwrite = TRUE)
  expect_equal(as.character(i$records[[1]]), c("newi", "newi_1"))
})

# test copy for alias and universe alias
test_that("test_num_113", {
  m <- Container$new()
  i <- Set$new(m, "i")
  ii <- Alias$new(m, "ii", i)

  m2 <- Container$new()
  # ii$copy(m2)
  # expect_equal(m2$listSymbols(), c("i","ii"))

  u <- UniverseAlias$new(m, "u")
  u$copy(m2)

  # expect_equal(m2$listSymbols(), c("i","ii","u"))
  expect_equal(m2$listSymbols(), c("u"))
})

# test copy container method
test_that("test_num_114", {
  m <- Container$new(testthat::test_path("testdata", "trnsport.gdx"))

  m2 <- Container$new()
  m$copy(m2)

  expect_equal(m2$listSymbols(), m$listSymbols())


  m2 <- Container$new()
  m$copy(m2, symbols = c("f", "d"))

  expect_equal(m2$listSymbols(), c("f", "d"))

  expect_error(m$copy(m2, "d"))
  m$copy(m2, "d", overwrite = TRUE)
  expect_equal(m2$listSymbols(), c("f", "d"))
})

# test copy Container method
test_that("test_num_115", {
  m <- Container$new(testthat::test_path("testdata", "trnsport.gdx"))

  m2 <- Container$new()
  m$copy(m2)

  expect_equal(m2$listSymbols(), m$listSymbols())


  m2 <- Container$new()
  m$copy(m2, symbols = c("f", "d"))

  expect_equal(m2$listSymbols(), c("f", "d"))

  expect_error(m$copy(m2, "d"))
  m$copy(m2, "d", overwrite = TRUE)
  expect_equal(m2$listSymbols(), c("f", "d"))
})

# test copy for alias and universe alias
test_that("test_num_116", {
  m <- Container$new(testthat::test_path("testdata", "test95.gdx"))

  m2 <- Container$new()

  m["h"]$copy(m2)

  # expect_equal(m2$listSymbols(), c("i","ii","u"))
  expect_equal(m2$listSymbols(), c("h"))

  # test supercall read
  rl <- readGDX(testthat::test_path("testdata", "test95.gdx"))
  m2 <- Container$new()
  m2$readList(rl)
  expect_equal(m$equals(m2), TRUE)
})


# test reading symbols with unused uels from gdx
test_that("test_num_117", {
  m <- Container$new()
  i <- Set$new(m, "i", records = paste0("i", 1:5))
  isub <- Set$new(m, "isub", domain = i, records = c("i1", "i2"))
  isub$setUELs(paste0("i", 1:5))
  m$write("gt.gdx")

  m2 <- Container$new(testthat::test_path("gt.gdx"))

  expect_equal(m["isub"]$getUELs(), paste0("i", 1:5))

  m$write("gt.gdx", mode = "string")

  m2 <- Container$new(testthat::test_path("gt.gdx"))

  expect_equal(m["isub"]$getUELs(), paste0("i", 1:5))

  # test the super call write
  writeList <- m$asList()
  writeGDX(writeList, "gt.gdx")

  m2 <- Container$new(testthat::test_path("gt.gdx"))

  expect_equal(m["isub"]$getUELs(), paste0("i", 1:5))
})

# test isScalar for symbols
test_that("test_num_118", {
  m <- Container$new()
  p <- Parameter$new(m, "p")
  expect_true(p$isScalar)

  v <- Variable$new(m, "v", type = "free")
  expect_true(v$isScalar)

  e <- Equation$new(m, "e", type = "eq")
  expect_true(e$isScalar)

  m$write("gt.gdx")
  m2 <- Container$new()
  m2$read(testthat::test_path("gt.gdx"))

  expect_true(m2["p"]$isScalar)
  expect_true(m2["v"]$isScalar)
  expect_true(m2["e"]$isScalar)

  m$write("gt.gdx", mode = "string")
  m2 <- Container$new()
  m2$read(testthat::test_path("gt.gdx"))

  expect_true(m2["p"]$isScalar)
  expect_true(m2["v"]$isScalar)
  expect_true(m2["e"]$isScalar)

  # test the super call write
  writeList <- m$asList()
  writeGDX(writeList, "gt.gdx")
  m2 <- Container$new()
  m2$read(testthat::test_path("gt.gdx"))

  expect_true(m2["p"]$isScalar)
  expect_true(m2["v"]$isScalar)
  expect_true(m2["e"]$isScalar)
})

# test Scalars with more records isvalid
test_that("test_num_119", {
  m <- Container$new()
  p <- Parameter$new(m, "p")
  p$setRecords(data.frame(value = c(1, 2)))
  expect_false(p$isValid())

  v <- Variable$new(m, "v", type = "free")
  v$setRecords(data.frame(level = c(1, 2)))
  expect_false(v$isValid())

  e <- Equation$new(m, "e", type = "eq")
  e$setRecords(data.frame(level = c(1, 2)))
  expect_false(e$isValid())
})

# test description of length > 255
test_that("test_num_119", {
  m <- Container$new()
  i <- Set$new(m, "i")
  a <- paste0(rep("m", 255), collapse = "")
  i$description <- a

  a <- paste0(rep("m", 256), collapse = "")


  expect_error({
    i$description <- a
  })
})

# reorderUELs with null argument
test_that("test_num_120", {
  m <- Container$new()
  i <- Set$new(m, "i", records = paste0("i", c(1, 2, 4, 3)))
  i$setUELs(paste0("i", 1:5))

  expect_equal(i$getUELs(), paste0("i", 1:5))

  i$reorderUELs()
  expect_equal(i$getUELs(), paste0("i", c(1, 2, 4, 3, 5)))

  a <- Parameter$new(m, "p", domain = c(i, i), records = data.frame(i = c("i1", "i5", "i3"), i = c("i2", "i4", "i1"), value = c(1, 3, 4)))
  expect_equal(a$getUELs(1), c("i1", "i5", "i3"))
  expect_equal(a$getUELs(2), c("i2", "i4", "i1"))

  a$setUELs(uels = paste0("i", 1:5), dimension = 1)
  a$setUELs(uels = paste0("i", 1:5), dimension = 2)

  expect_equal(a$getUELs(1), paste0("i", 1:5))
  expect_equal(a$getUELs(2), paste0("i", 1:5))

  a$reorderUELs(dimension = 1)
  expect_equal(a$getUELs(1), c("i1", "i5", "i3", "i2", "i4"))

  a$reorderUELs(dimension = 2)
  expect_equal(a$getUELs(2), c("i2", "i4", "i1", "i3", "i5"))
})

# todense uel checks
test_that("test_num_121", {
  m <- Container$new()
  i <- Set$new(m, "i", records = paste0("i", c(1, 2, 4, 3)))
  a <- Parameter$new(m, "a", domain = i, records = data.frame(i = c("i1", "i3"), value = c(1, 3)))
  expect_equal(a$toDense(), array(c(1, 0, 0, 3)))

  i$setUELs(paste0("i", 1:5))
  i$reorderUELs(paste0("i", c(1, 2, 4, 3, 5)))
  # unused uels at the end are okay
  expect_equal(a$toDense(), array(c(1, 0, 0, 3)))

  i$reorderUELs(paste0("i", c(1, 2, 5, 4, 3)))
  expect_error(a$toDense())

  # now the order of UELs is different from that of the records
  i$setUELs(paste0("i", 1:4))
  expect_error(a$toDense())
})

# case insensitive check
test_that("test_num_122", {
  m <- Container$new()
  m$read(testthat::test_path("testdata", "trnsport.gdx"), "x")
  expect_true(!is.null(m["x"]))
  expect_true(!is.null(m["X"]))
  expect_true(is.null(m["d"]))
})


# describe aliases
test_that("test_num_123", {
  m <- Container$new()
  expect_error(m$read(testthat::test_path("testdata", "trnsport_with_alias.gdx"), "ip"))
  m$read(testthat::test_path("testdata", "trnsport_with_alias.gdx"))
  m$describeAliases()
})

# domain linking test on GDX read
test_that("test_num_124", {
  m <- Container$new()
  m$read(testthat::test_path("testdata", "trnsport.gdx"))
  expect_equal(m["d"]$domain, c(m["i"], m["j"]))

  # subset of symbols in a different order
  m1 <- Container$new()
  m1$read(testthat::test_path("testdata", "trnsport.gdx"), c("d", "i", "j"))
  expect_equal(m1["d"]$domain, c(m1["i"], m1["j"]))

  # check the same for container read
  m1 <- Container$new()
  m1$read(m, c("d", "i", "j"))
  expect_equal(m1["d"]$domain, c(m1["i"], m1["j"]))

  # subset of symbols one string one regular
  m1 <- Container$new()
  m1$read(testthat::test_path("testdata", "trnsport.gdx"), c("d", "i"))
  expect_equal(m1["d"]$domain, c(m1["i"], "j"))

  # check the same for container read
  m1 <- Container$new()
  m1$read(m, c("d", "i"))
  expect_equal(m1["d"]$domain, c(m1["i"], "j"))

  # ensure that symbols are not linked using names
  m <- Container$new()
  j <- Set$new(m, "j", records = paste0("j", 1:10))
  i <- Set$new(m, "i", records = paste0("i", 1:10))
  p <- Parameter$new(m, "p", domain = c("j"), records = data.frame(j = paste0("i", 1:10), 1:10))
  m$write("gt.gdx")
  writeList <- m$asList()

  m <- Container$new("gt.gdx")
  expect_equal(m["p"]$domain, "j")
  expect_false(m["p"]$hasDomainViolations())

  # check the same for container read
  m2 <- Container$new()
  m2$read(m)
  expect_equal(m2["p"]$domain, "j")
  expect_false(m2["p"]$hasDomainViolations())

  m$write("gt.gdx", mode = "string")

  m <- Container$new("gt.gdx")
  expect_equal(m["p"]$domain, "j")
  expect_false(m["p"]$hasDomainViolations())

  # check the same for container read
  m2 <- Container$new()
  m2$read(m)
  expect_equal(m2["p"]$domain, "j")
  expect_false(m2["p"]$hasDomainViolations())

  writeGDX(writeList, "gt.gdx")
  m <- Container$new("gt.gdx")
  expect_equal(m["p"]$domain, "j")
  expect_false(m["p"]$hasDomainViolations())

  # check the same for container read
  m2 <- Container$new()
  m2$read(m)
  expect_equal(m2["p"]$domain, "j")
  expect_false(m2["p"]$hasDomainViolations())
})

# domain linking test on GDX read when domain symbol exists
# in the container but is not read from GDX
test_that("test_num_125", {
  m <- Container$new()
  i <- Set$new(m, "i")
  m$read(testthat::test_path("testdata", "trnsport.gdx"), "d")
  expect_equal(m["d"]$domain, c("i", "j"))
})

# extensive partial column tests
test_that("test_num_126", {
  # data frames with only domain - equation
  for (t in c("eq", "geq", "leq", "nonbinding", "cone", "external", "boolean")) {
    m <- Container$new()
    e <- Equation$new(m, "e", type = t, domain = "*", records = data.frame(i = c("i1", "i2", "i3")))
    expect_equal(m$listSymbols(), c("e"))
    expect_equal(colnames(m["e"]$records), "i")
    expect_equal(length(m["e"]$records), 1)
    expect_true(m["e"]$isValid())
    m$write("partial_equation.gdx")

    m1 <- Container$new("partial_equation.gdx")
    expect_equal(m1$listSymbols(), "e")
    expect_equal(colnames(m1["e"]$records), c("uni", "level", "marginal", "lower", "upper", "scale"))
    expect_equal(length(m1["e"]$records), 6)
    for (i in c("level", "marginal", "lower", "upper", "scale")) {
      expect_equal(m1["e"]$records[, i], replicate(m["e"]$numberRecords, m["e"]$defaultValues[[i]]))
    }

    m$write("partial_equation.gdx", mode = "string")

    m1 <- Container$new("partial_equation.gdx")
    expect_equal(m1$listSymbols(), "e")
    expect_equal(colnames(m1["e"]$records), c("uni", "level", "marginal", "lower", "upper", "scale"))
    expect_equal(length(m1["e"]$records), 6)
    for (i in c("level", "marginal", "lower", "upper", "scale")) {
      expect_equal(m1["e"]$records[, i], replicate(m["e"]$numberRecords, m["e"]$defaultValues[[i]]))
    }

    # test the super call write
    writeList <- m$asList()
    writeGDX(writeList, "partial_equation.gdx")

    m1 <- Container$new("partial_equation.gdx")
    expect_equal(m1$listSymbols(), "e")
    expect_equal(colnames(m1["e"]$records), c("uni", "level", "marginal", "lower", "upper", "scale"))
    expect_equal(length(m1["e"]$records), 6)
    for (i in c("level", "marginal", "lower", "upper", "scale")) {
      expect_equal(m1["e"]$records[, i], replicate(m["e"]$numberRecords, m["e"]$defaultValues[[i]]))
    }
  }

  # data frames with only domain - variable
  for (t in c("binary", "integer", "positive", "negative", "free", "sos1", "sos2", "semicont", "semiint")) {
    m <- Container$new()
    v <- Variable$new(m, "v", type = t, domain = "*", records = data.frame(i = c("i1", "i2", "i3")))
    expect_equal(m$listSymbols(), c("v"))
    expect_equal(colnames(m["v"]$records), "i")
    expect_equal(length(m["v"]$records), 1)
    expect_true(m["v"]$isValid())
    m$write("partial_variable.gdx")

    m1 <- Container$new("partial_variable.gdx")
    expect_equal(m1$listSymbols(), "v")
    expect_equal(colnames(m1["v"]$records), c("uni", "level", "marginal", "lower", "upper", "scale"))
    expect_equal(length(m1["v"]$records), 6)
    for (i in c("level", "marginal", "lower", "upper", "scale")) {
      expect_equal(m1["v"]$records[, i], replicate(m["v"]$numberRecords, m["v"]$defaultValues[[i]]))
    }

    m$write("partial_variable.gdx", mode = "string")

    m1 <- Container$new("partial_variable.gdx")
    expect_equal(m1$listSymbols(), "v")
    expect_equal(colnames(m1["v"]$records), c("uni", "level", "marginal", "lower", "upper", "scale"))
    expect_equal(length(m1["v"]$records), 6)
    for (i in c("level", "marginal", "lower", "upper", "scale")) {
      expect_equal(m1["v"]$records[, i], replicate(m["v"]$numberRecords, m["v"]$defaultValues[[i]]))
    }

    # test the super call write
    writeList <- m$asList()
    writeGDX(writeList, "partial_variable.gdx")

    m1 <- Container$new("partial_variable.gdx")
    expect_equal(m1$listSymbols(), "v")
    expect_equal(colnames(m1["v"]$records), c("uni", "level", "marginal", "lower", "upper", "scale"))
    expect_equal(length(m1["v"]$records), 6)
    for (i in c("level", "marginal", "lower", "upper", "scale")) {
      expect_equal(m1["v"]$records[, i], replicate(m["v"]$numberRecords, m["v"]$defaultValues[[i]]))
    }
  }

  # data frames with only domain - parameter
  m <- Container$new()
  p <- Parameter$new(m, "p", domain = "*", records = data.frame(i = c("i1", "i2", "i3")))
  expect_equal(m$listSymbols(), c("p"))
  expect_equal(colnames(m["p"]$records), "i")
  expect_equal(length(m["p"]$records), 1)
  expect_true(m["p"]$isValid())
  m$write("partial_parameter.gdx")

  m1 <- Container$new("partial_parameter.gdx")
  expect_equal(m1$listSymbols(), "p")
  expect_equal(colnames(m1["p"]$records), c("uni", "value"))
  expect_equal(length(m1["p"]$records), 2)
  expect_equal(m1["p"]$records[, "value"], replicate(m["p"]$numberRecords, 0))


  m$write("partial_parameter.gdx", mode = "string")

  m1 <- Container$new("partial_parameter.gdx")
  expect_equal(m1$listSymbols(), "p")
  expect_equal(colnames(m1["p"]$records), c("uni", "value"))
  expect_equal(length(m1["p"]$records), 2)
  expect_equal(m1["p"]$records[, "value"], replicate(m["p"]$numberRecords, 0))

  # test the super call write
  writeList <- m$asList()
  writeGDX(writeList, "partial_parameter.gdx")

  m1 <- Container$new("partial_parameter.gdx")
  expect_equal(m1$listSymbols(), "p")
  expect_equal(colnames(m1["p"]$records), c("uni", "value"))
  expect_equal(length(m1["p"]$records), 2)
  expect_equal(m1["p"]$records[, "value"], replicate(m["p"]$numberRecords, 0))

  # data frames with only domain - set
  m <- Container$new()
  s <- Set$new(m, "s", records = data.frame(i = c("i1", "i2", "i3")))
  expect_equal(m$listSymbols(), c("s"))
  expect_equal(colnames(m["s"]$records), "i")
  expect_equal(length(m["s"]$records), 1)
  expect_true(m["s"]$isValid())
  m$write("partial_set.gdx")

  m1 <- Container$new("partial_set.gdx")
  expect_equal(m1$listSymbols(), "s")
  expect_equal(colnames(m1["s"]$records), c("uni", "element_text"))
  expect_equal(length(m1["s"]$records), 2)

  m$write("partial_set.gdx", mode = "string")

  m1 <- Container$new("partial_set.gdx")
  expect_equal(m1$listSymbols(), "s")
  expect_equal(colnames(m1["s"]$records), c("uni", "element_text"))
  expect_equal(length(m1["s"]$records), 2)

  # test the super call write
  writeList <- m$asList()
  writeGDX(writeList, "partial_set.gdx")

  m1 <- Container$new("partial_set.gdx")
  expect_equal(m1$listSymbols(), "s")
  expect_equal(colnames(m1["s"]$records), c("uni", "element_text"))
  expect_equal(length(m1["s"]$records), 2)

  # data frames with domain + missing attribute columns - equation
  for (t in c("eq", "geq", "leq", "nonbinding", "cone", "external", "boolean")) {
    m <- Container$new()
    e <- Equation$new(m, "e", type = t, domain = "*", records = data.frame(i = c("i1", "i2", "i3"), marginal = c(10, 10, 10)))
    expect_equal(m$listSymbols(), c("e"))
    expect_equal(colnames(m["e"]$records), c("i", "marginal"))
    expect_equal(length(m["e"]$records), 2)
    expect_true(m["e"]$isValid())
    m$write("partial_equation.gdx")

    m1 <- Container$new("partial_equation.gdx")
    expect_equal(m1$listSymbols(), "e")
    expect_equal(colnames(m1["e"]$records), c("uni", "level", "marginal", "lower", "upper", "scale"))
    expect_equal(length(m1["e"]$records), 6)
    for (i in c("level", "lower", "upper", "scale")) {
      expect_equal(m1["e"]$records[, i], replicate(m["e"]$numberRecords, m["e"]$defaultValues[[i]]))
    }
    expect_equal(m1["e"]$records[, "marginal"], replicate(m["e"]$numberRecords, 10))

    m$write("partial_equation.gdx", mode = "string")

    m1 <- Container$new("partial_equation.gdx")
    expect_equal(m1$listSymbols(), "e")
    expect_equal(colnames(m1["e"]$records), c("uni", "level", "marginal", "lower", "upper", "scale"))
    expect_equal(length(m1["e"]$records), 6)

    for (i in c("level", "lower", "upper", "scale")) {
      expect_equal(m1["e"]$records[, i], replicate(m["e"]$numberRecords, m["e"]$defaultValues[[i]]))
    }
    expect_equal(m1["e"]$records[, "marginal"], replicate(m["e"]$numberRecords, 10))

    # test the super call write
    writeList <- m$asList()
    writeGDX(writeList, "partial_equation.gdx")

    m1 <- Container$new("partial_equation.gdx")
    expect_equal(m1$listSymbols(), "e")
    expect_equal(colnames(m1["e"]$records), c("uni", "level", "marginal", "lower", "upper", "scale"))
    expect_equal(length(m1["e"]$records), 6)

    for (i in c("level", "lower", "upper", "scale")) {
      expect_equal(m1["e"]$records[, i], replicate(m["e"]$numberRecords, m["e"]$defaultValues[[i]]))
    }
    expect_equal(m1["e"]$records[, "marginal"], replicate(m["e"]$numberRecords, 10))
  }

  # data frames with domain + missing attribute columns - variable
  for (t in c("binary", "integer", "positive", "negative", "free", "sos1", "sos2", "semicont", "semiint")) {
    m <- Container$new()
    v <- Variable$new(m, "v", type = t, domain = "*", records = data.frame(i = c("i1", "i2", "i3"), marginal = c(10, 10, 10)))
    expect_equal(m$listSymbols(), c("v"))
    expect_equal(colnames(m["v"]$records), c("i", "marginal"))
    expect_equal(length(m["v"]$records), 2)
    expect_true(m["v"]$isValid())
    m$write("partial_variable.gdx")

    m1 <- Container$new("partial_variable.gdx")
    expect_equal(m1$listSymbols(), "v")
    expect_equal(colnames(m1["v"]$records), c("uni", "level", "marginal", "lower", "upper", "scale"))
    expect_equal(length(m1["v"]$records), 6)
    for (i in c("level", "lower", "upper", "scale")) {
      expect_equal(m1["v"]$records[, i], replicate(m["v"]$numberRecords, m["v"]$defaultValues[[i]]))
    }
    expect_equal(m1["v"]$records[, "marginal"], replicate(m["v"]$numberRecords, 10))

    m$write("partial_variable.gdx", mode = "string")

    m1 <- Container$new("partial_variable.gdx")
    expect_equal(m1$listSymbols(), "v")
    expect_equal(colnames(m1["v"]$records), c("uni", "level", "marginal", "lower", "upper", "scale"))
    expect_equal(length(m1["v"]$records), 6)
    for (i in c("level", "lower", "upper", "scale")) {
      expect_equal(m1["v"]$records[, i], replicate(m["v"]$numberRecords, m["v"]$defaultValues[[i]]))
    }
    expect_equal(m1["v"]$records[, "marginal"], replicate(m["v"]$numberRecords, 10))

    # test the super call write
    writeList <- m$asList()
    writeGDX(writeList, "partial_variable.gdx")

    m1 <- Container$new("partial_variable.gdx")
    expect_equal(m1$listSymbols(), "v")
    expect_equal(colnames(m1["v"]$records), c("uni", "level", "marginal", "lower", "upper", "scale"))
    expect_equal(length(m1["v"]$records), 6)
    for (i in c("level", "lower", "upper", "scale")) {
      expect_equal(m1["v"]$records[, i], replicate(m["v"]$numberRecords, m["v"]$defaultValues[[i]]))
    }
    expect_equal(m1["v"]$records[, "marginal"], replicate(m["v"]$numberRecords, 10))
  }
})

# extensive partial column tests for scalars
test_that("test_num_127", {
  # parameter
  m <- Container$new()
  p <- Parameter$new(m, "p", records = data.frame())
  m$write("partial_scalar.gdx")
  m1 <- Container$new("partial_scalar.gdx")
  expect_equal(m1["p"]$records$value, 0)

  m$write("partial_scalar.gdx", mode = "string")
  m1 <- Container$new("partial_scalar.gdx")
  expect_equal(m1["p"]$records$value, 0)

  # test the super call write
  writeList <- m$asList()
  writeGDX(writeList, "partial_scalar.gdx")
  m1 <- Container$new("partial_scalar.gdx")
  expect_equal(m1["p"]$records$value, 0)

  # variable
  m <- Container$new()
  v <- Variable$new(m, "v", records = data.frame())
  m$write("partial_scalar_variable.gdx")
  m1 <- Container$new("partial_scalar_variable.gdx")
  for (i in c("level", "marginal", "lower", "upper", "scale")) {
    expect_equal(m1["v"]$records[[i]], m["v"]$defaultValues[[i]])
  }

  m$write("partial_scalar_variable.gdx", mode = "string")
  m1 <- Container$new("partial_scalar_variable.gdx")
  for (i in c("level", "marginal", "lower", "upper", "scale")) {
    expect_equal(m1["v"]$records[[i]], m["v"]$defaultValues[[i]])
  }

  # test the super call write
  writeList <- m$asList()
  writeGDX(writeList, "partial_scalar_variable.gdx")
  m1 <- Container$new("partial_scalar_variable.gdx")
  for (i in c("level", "marginal", "lower", "upper", "scale")) {
    expect_equal(m1["v"]$records[[i]], m["v"]$defaultValues[[i]])
  }

  # equation
  m <- Container$new()
  e <- Equation$new(m, "e", type = "eq", records = data.frame())
  m$write("partial_scalar_equation.gdx")
  m1 <- Container$new("partial_scalar_equation.gdx")
  for (i in c("level", "marginal", "lower", "upper", "scale")) {
    expect_equal(m1["e"]$records[[i]], m["e"]$defaultValues[[i]])
  }

  m$write("partial_scalar_equation.gdx", mode = "string")
  m1 <- Container$new("partial_scalar_equation.gdx")
  for (i in c("level", "marginal", "lower", "upper", "scale")) {
    expect_equal(m1["e"]$records[[i]], m["e"]$defaultValues[[i]])
  }

  # test the super call write
  writeList <- m$asList()
  writeGDX(writeList, "partial_scalar_equation.gdx")
  m1 <- Container$new("partial_scalar_equation.gdx")
  for (i in c("level", "marginal", "lower", "upper", "scale")) {
    expect_equal(m1["e"]$records[[i]], m["e"]$defaultValues[[i]])
  }

  # variable partial column
  m <- Container$new()
  v <- Variable$new(m, "v", records = data.frame(marginal = 10))
  m$write("partial_scalar_variable.gdx")
  m1 <- Container$new("partial_scalar_variable.gdx")
  for (i in c("level", "lower", "upper", "scale")) {
    expect_equal(m1["v"]$records[[i]], m["v"]$defaultValues[[i]])
  }
  expect_equal(m1["v"]$records[["marginal"]], 10)

  writeList <- m$asList()
  writeGDX(writeList, "partial_scalar_variable.gdx")
  for (i in c("level", "lower", "upper", "scale")) {
    expect_equal(m1["v"]$records[[i]], m["v"]$defaultValues[[i]])
  }
  expect_equal(m1["v"]$records[["marginal"]], 10)

  # equation
  m <- Container$new()
  e <- Equation$new(m, "e", type = "eq", records = data.frame(marginal = 10))
  m$write("partial_scalar_equation.gdx")
  m1 <- Container$new("partial_scalar_equation.gdx")
  for (i in c("level", "lower", "upper", "scale")) {
    expect_equal(m1["e"]$records[[i]], m["e"]$defaultValues[[i]])
  }
  expect_equal(m1["e"]$records[["marginal"]], 10)

  m$write("partial_scalar_equation.gdx", mode = "string")
  m1 <- Container$new("partial_scalar_equation.gdx")
  for (i in c("level", "lower", "upper", "scale")) {
    expect_equal(m1["e"]$records[[i]], m["e"]$defaultValues[[i]])
  }
  expect_equal(m1["e"]$records[["marginal"]], 10)
})

# test count* and isvalid methods with partial columns
test_that("test_num_128", {
  # count* methods
  m <- Container$new()
  i <- Set$new(m, "i", records = paste0("i", 1:10))
  p <- Parameter$new(m, "p", domain = i, records = data.frame(i = paste0("i", 2:6)))
  expect_true(p$isValid())

  flist <- c(p$countNA, p$countEps, p$countNegInf, p$countPosInf, p$countUndef)
  for (f in flist) {
    expect_equal(f(), 0)
  }

  v <- Variable$new(m, "v", domain = i, records = data.frame(i = paste0("i", 2:6)))
  expect_true(v$isValid())
  flist <- c(v$countNA, v$countEps, v$countNegInf, v$countPosInf, v$countUndef)
  for (f in flist) {
    expect_equal(f(columns = "level"), 0)
  }

  flist <- c(v$countNA, v$countEps, v$countNegInf, v$countPosInf, v$countUndef)
  for (f in flist) {
    expect_equal(f(columns = c("level", "scale")), 0)
  }

  expect_equal(v$countPosInf(columns = "upper"), 5)
  expect_equal(v$countNegInf(columns = "lower"), 5)

  e <- Equation$new(m, "e", type = "eq", domain = i, records = data.frame(i = paste0("i", 2:6)))
  expect_true(e$isValid())
  flist <- c(e$countNA, e$countEps, e$countNegInf, e$countPosInf, e$countUndef)
  for (f in flist) {
    expect_equal(f(columns = "level"), 0)
  }

  expect_equal(e$countPosInf(columns = "upper"), 0)
  expect_equal(e$countNegInf(columns = "lower"), 0)


  # scalars count* methods
  m <- Container$new()
  p <- Parameter$new(m, "p", records = data.frame())
  expect_true(p$isValid())
  flist <- c(p$countNA, p$countEps, p$countNegInf, p$countPosInf, p$countUndef)
  for (f in flist) {
    expect_equal(f(), 0)
  }

  v <- Variable$new(m, "v", records = data.frame())
  expect_true(v$isValid())
  flist <- c(v$countNA, v$countEps, v$countNegInf, v$countPosInf, v$countUndef)
  for (f in flist) {
    expect_equal(f(columns = "level"), 0)
  }

  flist <- c(v$countNA, v$countEps, v$countNegInf, v$countPosInf, v$countUndef)
  for (f in flist) {
    expect_equal(f(columns = c("level", "scale")), 0)
  }

  expect_equal(v$countPosInf(columns = "upper"), 1)
  expect_equal(v$countNegInf(columns = "lower"), 1)

  e <- Equation$new(m, "e", type = "eq", records = data.frame())
  expect_true(e$isValid())
  flist <- c(e$countNA, e$countEps, e$countNegInf, e$countPosInf, e$countUndef)
  for (f in flist) {
    expect_equal(f(columns = "level"), 0)
  }

  expect_equal(e$countPosInf(columns = "upper"), 0)
  expect_equal(e$countNegInf(columns = "lower"), 0)
})

# test get* and isvalid methods with partial columns
test_that("test_num_129", {
  # get* methods
  m <- Container$new()
  i <- Set$new(m, "i", records = paste0("i", 1:10))
  p <- Parameter$new(m, "p", domain = i, records = data.frame(i = paste0("i", 2:6)))
  expect_true(p$isValid())

  flist <- c(p$getMaxValue, p$getMinValue, p$getMaxAbsValue, p$getMeanValue)
  for (f in flist) {
    expect_equal(f(), 0)
  }

  v <- Variable$new(m, "v", domain = i, records = data.frame(i = paste0("i", 2:6)))
  expect_true(v$isValid())
  flist <- c(v$getMaxValue, v$getMinValue, v$getMaxAbsValue, v$getMeanValue)
  for (f in flist) {
    expect_equal(f(columns = "level"), 0)
  }

  flist <- c(v$getMaxValue, v$getMinValue, v$getMaxAbsValue, v$getMeanValue)
  for (f in flist) {
    expect_equal(f(columns = c("level", "marginal")), 0)
  }

  expect_equal(v$getMaxValue(columns = "upper"), Inf)
  expect_equal(v$getMaxValue(columns = "lower"), -Inf)

  e <- Equation$new(m, "e", type = "eq", domain = i, records = data.frame(i = paste0("i", 2:6)))
  expect_true(e$isValid())
  flist <- c(e$getMaxValue, e$getMinValue, e$getMaxAbsValue, e$getMeanValue)
  for (f in flist) {
    expect_equal(f(columns = "level"), 0)
  }

  expect_equal(e$getMaxValue(columns = "upper"), 0)
  expect_equal(e$getMinValue(columns = "lower"), 0)


  # scalars get* methods
  m <- Container$new()
  p <- Parameter$new(m, "p", records = data.frame())
  expect_true(p$isValid())
  flist <- c(p$getMaxValue, p$getMinValue, p$getMaxAbsValue, p$getMeanValue)
  for (f in flist) {
    expect_equal(f(), 0)
  }

  v <- Variable$new(m, "v", records = data.frame())
  expect_true(v$isValid())
  flist <- c(v$getMaxValue, v$getMinValue, v$getMaxAbsValue, v$getMeanValue)
  for (f in flist) {
    expect_equal(f(columns = "level"), 0)
  }

  flist <- c(v$getMaxValue, v$getMinValue, v$getMaxAbsValue, v$getMeanValue)
  for (f in flist) {
    expect_equal(f(columns = c("level", "marginal")), 0)
  }

  expect_equal(v$getMaxValue(columns = "upper"), Inf)
  expect_equal(v$getMaxValue(columns = "lower"), -Inf)

  e <- Equation$new(m, "e", type = "eq", records = data.frame())
  expect_true(e$isValid())
  flist <- c(e$getMaxValue, e$getMinValue, e$getMaxAbsValue, e$getMeanValue)
  for (f in flist) {
    expect_equal(f(columns = "level"), 0)
  }

  expect_equal(e$getMaxValue(columns = "upper"), 0)
  expect_equal(e$getMinValue(columns = "lower"), 0)
})

# test where* and isvalid methods with partial columns
test_that("test_num_130", {
  # where* methods
  m <- Container$new()
  i <- Set$new(m, "i", records = paste0("i", 1:10))
  p <- Parameter$new(m, "p", domain = i, records = data.frame(i = paste0("i", 2:6)))
  expect_equal(p$getSparsity(), 0.5)

  flist <- c(p$whereMax, p$whereMaxAbs, p$whereMin)
  for (f in flist) {
    expect_equal(f(), 1)
  }

  v <- Variable$new(m, "v", domain = i, records = data.frame(i = paste0("i", 2:6)))
  expect_equal(v$getSparsity(), 0.5)
  flist <- c(v$whereMax, v$whereMaxAbs, v$whereMin)
  for (f in flist) {
    expect_equal(f(column = "level"), 1)
  }

  expect_equal(v$whereMax(column = "upper"), 1)
  expect_equal(v$whereMaxAbs(column = "lower"), 1)

  e <- Equation$new(m, "e", type = "eq", domain = i, records = data.frame(i = paste0("i", 2:6)))
  expect_equal(e$getSparsity(), 0.5)
  flist <- c(e$whereMax, e$whereMaxAbs, e$whereMin)
  for (f in flist) {
    expect_equal(f(column = "level"), 1)
  }

  expect_equal(e$whereMax(column = "upper"), 1)
  expect_equal(e$whereMin(column = "lower"), 1)


  # scalars where* methods
  m <- Container$new()
  p <- Parameter$new(m, "p", records = data.frame())
  expect_equal(p$getSparsity(), NA)
  flist <- c(p$whereMax, p$whereMaxAbs, p$whereMin)
  for (f in flist) {
    expect_equal(f(), 1)
  }

  v <- Variable$new(m, "v", records = data.frame())
  expect_equal(v$getSparsity(), NA)
  flist <- c(v$whereMax, v$whereMaxAbs, v$whereMin)
  for (f in flist) {
    expect_equal(f(column = "level"), 1)
  }

  expect_equal(v$whereMax(column = "upper"), 1)
  expect_equal(v$whereMin(column = "lower"), 1)

  e <- Equation$new(m, "e", type = "eq", records = data.frame())
  expect_equal(e$getSparsity(), NA)
  flist <- c(e$whereMax, e$whereMaxAbs, e$whereMin)
  for (f in flist) {
    expect_equal(f(column = "level"), 1)
  }

  expect_equal(e$whereMaxAbs(column = "upper"), 1)
  expect_equal(e$whereMin(column = "lower"), 1)

  # toDense
})

# test toDense* and isvalid methods with partial columns
test_that("test_num_131", {
  m <- Container$new()
  i <- Set$new(m, "i", records = paste0("i", 1:10))
  p <- Parameter$new(m, "p", domain = i, records = data.frame(i = paste0("i", 2:6)))
  expect_equal(p$toDense(), as.array(replicate(10, 0)))

  v <- Variable$new(m, "v", domain = i, records = data.frame(i = paste0("i", 2:6)))
  expect_equal(v$toDense(), as.array(replicate(10, 0)))
  expect_equal(v$toDense(column = "upper"), as.array(c(0, replicate(5, Inf), 0, 0, 0, 0)))
  expect_equal(v$toDense(column = "lower"), as.array(c(0, replicate(5, -Inf), 0, 0, 0, 0)))

  e <- Equation$new(m, "e", type = "eq", domain = i, records = data.frame(i = paste0("i", 2:6)))
  expect_equal(e$toDense(), as.array(replicate(10, 0)))
  expect_equal(e$toDense(column = "upper"), as.array(replicate(10, 0)))
  expect_equal(e$toDense(column = "lower"), as.array(replicate(10, 0)))
})

# equals
# test equals method with partial columns
test_that("test_num_132", {
  m <- Container$new()
  i <- Set$new(m, "i", records = paste0("i", 1:10))
  p <- Parameter$new(m, "p", domain = i, records = data.frame(i = paste0("i", 2:6)))

  m2 <- Container$new()
  i2 <- Set$new(m2, "i", records = data.frame(uni = paste0("i", 1:10), element_text = ""))
  p2 <- Parameter$new(m2, "p", domain = i2, records = data.frame(i = paste0("i", 2:6), replicate(5, 0)))
  expect_true(p$equals(p2))
  expect_true(p2$equals(p))

  v <- Variable$new(m, "v", domain = i, records = data.frame(i = paste0("i", 2:6)))
  v2 <- Variable$new(m2, "v", domain = i2, records = data.frame(i = paste0("i", 2:6), level = 0))
  expect_true(v$equals(v2))
  expect_true(v2$equals(v))

  e <- Equation$new(m, "e", type = "eq", domain = i, records = data.frame(i = paste0("i", 2:6)))
  e2 <- Equation$new(m2, "e", type = "eq", domain = i2, records = data.frame(i = paste0("i", 2:6), level = 0))
  expect_true(e$equals(e2))
  expect_true(e2$equals(e))
})

# dataframe with no rows still have column names and factors
test_that("test_num_133", {
  m <- Container$new()
  i <- Set$new(m, "i", records = paste0("i", 1:3))
  p <- Parameter$new(m, "p", domain = i, records = c(0, 0, 0))
  expect_true(is.factor(p$records[, 1]))
  expect_equal(colnames(p$records), "i")
  expect_equal(levels(p$records[, 1]), c("i1", "i2", "i3"))

  v <- Variable$new(m, "v", domain = i, records = c(0, 0, 0))
  expect_true(is.factor(v$records[, 1]))
  expect_equal(colnames(v$records), "i")
  expect_equal(levels(v$records[, 1]), c("i1", "i2", "i3"))

  e <- Equation$new(m, "e", type = "eq", domain = i, records = c(0, 0, 0))
  expect_true(is.factor(e$records[, 1]))
  expect_equal(colnames(e$records), "i")
  expect_equal(levels(e$records[, 1]), c("i1", "i2", "i3"))
})

# dataframe with no rows still have column names and factors
test_that("test_num_134", {
  skip_if_no_gams()
  m <- Container$new()
  i <- Set$new(m, "i", records = paste0("i", 1:3))
  p <- Parameter$new(m, "p", domain = i, records = c(0, 0, 0))
  expect_true(is.factor(p$records[, 1]))
  expect_equal(colnames(p$records), "i")
  expect_equal(levels(p$records[, 1]), c("i1", "i2", "i3"))

  writeList <- m$asList()
  m$write("gt.gdx", symbols = "p")

  system2(
    command = "gdxdump", args =
      "gt.gdx uelTable=foo",
    stdout = "foo.gms"
  )

  system2(
    command = "gams", args =
      "foo.gms gdx=foo.gdx lo=0",
    stdout = FALSE
  )

  m <- Container$new("foo.gdx")

  expect_equal(m$getUELs(), c("i1", "i2", "i3"))

  writeGDX(writeList, "gt.gdx")
  system2(
    command = "gdxdump", args =
      "gt.gdx uelTable=foo",
    stdout = "foo.gms"
  )

  system2(
    command = "gams", args =
      "foo.gms gdx=foo.gdx lo=0",
    stdout = FALSE
  )

  m <- Container$new("foo.gdx")

  expect_equal(m$getUELs(), c("i1", "i2", "i3"))

  m <- Container$new()
  i <- Set$new(m, "i", records = paste0("i", 1:3))
  p <- Parameter$new(m, "p", domain = i, records = c(0, 0, 0))
  expect_true(is.factor(p$records[, 1]))
  expect_equal(colnames(p$records), "i")
  expect_equal(levels(p$records[, 1]), c("i1", "i2", "i3"))
  writeList <- m$asList()
  m$write("gt.gdx", symbols = "p", mode = "string")

  system2(
    command = "gdxdump", args =
      "gt.gdx uelTable=foo",
    stdout = "foo.gms"
  )

  system2(
    command = "gams", args =
      "foo.gms gdx=foo.gdx lo=0",
    stdout = FALSE
  )

  m <- Container$new("foo.gdx")

  expect_equal(m$getUELs(), c("i1", "i2", "i3"))

  writeGDX(writeList, "gt.gdx")
  system2(
    command = "gdxdump", args =
      "gt.gdx uelTable=foo",
    stdout = "foo.gms"
  )

  system2(
    command = "gams", args =
      "foo.gms gdx=foo.gdx lo=0",
    stdout = FALSE
  )

  m <- Container$new("foo.gdx")

  expect_equal(m$getUELs(), c("i1", "i2", "i3"))
})

# mapped write
test_that("test_num_135", {
  m <- Container$new(testthat::test_path("testdata", "trnsport.gdx"))
  expect_error(m$write("gt.gdx", mode = 1))
  m$write("gt.gdx", mode = "string")
  ms <- Container$new("gt.gdx")
  m$write("gt.gdx", mode = "mapped")
  mm <- Container$new("gt.gdx")
  expect_true(ms$equals(mm))

  m <- Container$new()
  m$read(testthat::test_path("testdata", "trnsport.gdx"), records = FALSE)
  m$write("gt.gdx", mode = "mapped")
  m$write("gt.gdx", mode = "string")
  writeList <- m$asList()
  writeGDX(writeList, "gt.gdx")
})

# symbol shouldn't be added to the container if the constructor call fails
test_that("test_num_136", {
  m <- Container$new()
  expect_error(Set$new(m, "i", domain = j, records = paste0("i", 1:3)))
  expect_equal(length(m$listSymbols()), 0)
})

# get* methods
test_that("test_num_137", {
  m <- Container$new(testthat::test_path("testdata", "trnsport_with_alias.gdx"))

  expect_equal(m$getSymbols(m$listSets()), m$getSets())
  expect_equal(m$getSymbols(m$listAliases()), m$getAliases())
  expect_equal(m$getSymbols(m$listParameters()), m$getParameters())
  expect_equal(m$getSymbols(m$listVariables()), m$getVariables())
  expect_equal(m$getSymbols(m$listEquations()), m$getEquations())
})

# get* methods
test_that("test_num_138", {
  m <- Container$new()
  a <- Parameter$new(m, "a", c("*", "*"), records = data.frame(i = c("i1", "i2"), j = c("j1", "j2"), val = 1:2))
  a$setUELs(c("new", "i1", "i2"), 1)
  expect_equal(a$getUELs(1), c("new", "i1", "i2"))
  expect_error(a$toDense())
  a$reorderUELs()
  expect_equal(a$getUELs(1), c("i1", "i2", "new"))
})

# read test
test_that("test_num_139", {
  m <- Container$new(testthat::test_path("testdata", "trnsport.gdx"))
  expect_equal(m["i"]$getUELs(), c("seattle", "san-diego"))
  expect_equal(m["j"]$getUELs(), c("new-york", "chicago", "topeka"))
  expect_equal(m["d"]$toDense(), matrix(data = c(2.5, 1.7, 1.8, 2.5, 1.8, 1.4), nrow = 2, ncol = 3, byrow = TRUE))
})

# getUELs for NULL records
test_that("test_num_140", {
m = Container$new()
i = Set$new(m, "i")
j = Set$new(m, "j")
d = Parameter$new(m, "p", domain=c(i, j), 
      records=data.frame(i=c("i1","i2","i3"), 
      j=c("j1","j2","j3"), val=1:3))
dv = d$getDomainViolations()
expect_equal(length(dv), 2)
}
)

# getUELs order
test_that("test_num_141", {
m = Container$new(testthat::test_path("testdata", "universe_order.gdx"))
expect_equal(m["p"]$getUELs(), c("i2","i5","i9","i1","i3"))
expect_equal(m["p"]$getUELs(1), c("i2","i5","i9"))
expect_equal(m["p"]$getUELs(2), c("i1", "i2", "i3"))

  # test supercall read
  rl <- readGDX(testthat::test_path("testdata", "universe_order.gdx"))
  m2 <- Container$new()
  m2$readList(rl)
  expect_equal(m$equals(m2), TRUE)
})

# acronyms
test_that("test_num_142", {
  f = function() {
    return(Container$new(testthat::test_path("testdata", "acronym_test.gdx")))
  }
expect_warning(m <- f())
expect_equal(m["shutdown"]$records[["value"]], replicate(5, as.numeric(NA)))
expect_equal(m["v"]$records[["level"]], c(1, NA, NA, NA, 2))
expect_equal(m["e"]$records[["marginal"]], c(1, NA, NA, NA, 2))

}
)

# duplicate columns in records
test_that("test_num_143", {
m = Container$new()
i = Set$new(m, "i", records = c("i1","i2","i3"))

p = Parameter$new(m, "p", c(i, i))
i2 = Set$new(m, "i2", c(i, i))

df_p = data.frame(i= c("i1","i2"), i_1 = c("i2","i3"), val = c(0, 1))
df_s = data.frame(i= c("i1","i2"), i_1 = c("i2","i3"), txt = c("a", "b"))

colnames(df_p) = c("i", "i", "value")
colnames(df_s) = c("i", "i", "txt")

p$setRecords(df_p)
i2$setRecords(df_s)
expect_equal(colnames(p$records), c("i_1", "i_2", "value"))
expect_equal(colnames(i2$records), c("i_1", "i_2", "element_text"))

# domain sets with keyword names
m = Container$new()
value = Set$new(m, "value", records = c("l1","l2","l3"))
p = Parameter$new(m, "p", domain = value, records = c(1,2,3))
expect_equal(colnames(p$records), c("value_1", "value"))
}
)

# read gdx files with keywords as domains
test_that("test_num_144", {
m = Container$new()
level = Set$new(m, "level", records = c("foo","bar"))

foo = Variable$new(m, "foo", domain = level, records = c(1, 1))
m$write("foo.gdx")
c = Container$new("foo.gdx")
expect_equal(colnames(c["foo"]$records), c("level_1", "level", "marginal", "lower", "upper", "scale"))
}
)