blockly/tests/generators/golden/generated.lua

function unittest_report()
  -- Create test report.
  local report = {}
  local summary = {}
  local fails = 0
  for _, v in pairs(unittestResults) do
    if v["success"] then
      table.insert(summary, ".")
    else
      table.insert(summary, "F")
      fails = fails + 1
      table.insert(report, "FAIL: " .. v["title"])
      table.insert(report, v["log"])
    end
  end
  table.insert(report, 1, table.concat(summary))
  table.insert(report, "")
  table.insert(report, "Number of tests run: " .. #unittestResults)
  table.insert(report, "")
  if fails > 0 then
    table.insert(report, "FAILED (failures=" .. fails .. ")")
  else
    table.insert(report, "OK")
  end
  return table.concat(report, "\n")
end

function assertEquals(actual, expected, message)
  -- Asserts that a value equals another value.
  assert(unittestResults ~= nil, "Orphaned assert equals: " ..  message)
  if type(actual) == "table" and type(expected) == "table" then
    local lists_match = #actual == #expected
    if lists_match then
      for i, v1 in ipairs(actual) do
        local v2 = expected[i]
        if type(v1) == "number" and type(v2) == "number" then
          if math.abs(v1 - v2) > 1e-9 then
            lists_match = false
          end
        elseif v1 ~= v2 then
          lists_match = false
        end
      end
    end
    if lists_match then
      table.insert(unittestResults, {success=true, log="OK", title=message})
      return
    else
      -- produce the non-matching strings for a human-readable error
      expected = "{" .. table.concat(expected, ", ") .. "}"
      actual = "{" .. table.concat(actual, ", ") .. "}"
    end
  end
  if actual == expected or (type(actual) == "number" and type(expected) == "number" and math.abs(actual - expected) < 1e-9) then
    table.insert(unittestResults, {success=true, log="OK", title=message})
  else
    table.insert(unittestResults, {success=false, log=string.format("Expected: %s\nActual: %s", tostring(expected), tostring(actual)), title=message})
  end
end

function unittest_fail(message)
  -- Always assert an error.
  assert(unittestResults ~= nil, "Orphaned assert fail: " .. message)
  table.insert(unittestResults, {success=false, log="Fail.", title=message})
end

-- Describe this function...
function test_if()
  if false then
    unittest_fail('if false')
  end
  ok = false
  if true then
    ok = true
  end
  assertEquals(ok, true, 'if true')
  ok = false
  if false then
    unittest_fail('if/else false')
  else
    ok = true
  end
  assertEquals(ok, true, 'if/else false')
  ok = false
  if true then
    ok = true
  else
    unittest_fail('if/else true')
  end
  assertEquals(ok, true, 'if/else true')
  ok = false
  if false then
    unittest_fail('elseif 1')
  elseif true then
    ok = true
  elseif true then
    unittest_fail('elseif 2')
  else
    unittest_fail('elseif 3')
  end
  assertEquals(ok, true, 'elseif 4')
end


-- Describe this function...
function test_ifelse()
  ok = false
  if true then
    ok = true
  else
    unittest_fail('ifelse true')
  end
  assertEquals(ok, true, 'ifelse true')
  ok = false
  if false then
    unittest_fail('ifelse false')
  else
    ok = true
  end
  assertEquals(ok, true, 'ifelse false')
end


-- Describe this function...
function test_equalities()
  assertEquals(2 == 2, true, 'Equal yes')
  assertEquals(3 == 4, false, 'Equal no')
  assertEquals(5 ~= 6, true, 'Not equal yes')
  assertEquals(3 == 4, false, 'Not equal no')
  assertEquals(5 < 6, true, 'Smaller yes')
  assertEquals(7 < 7, false, 'Smaller no')
  assertEquals(9 > 8, true, 'Greater yes')
  assertEquals(10 > 10, false, 'Greater no')
  assertEquals(11 <= 11, true, 'Smaller-equal yes')
  assertEquals(13 <= 12, false, 'Smaller-equal no')
  assertEquals(14 >= 14, true, 'Greater-equal yes')
  assertEquals(15 >= 16, false, 'Greater-equal no')
end


-- Describe this function...
function test_and()
  assertEquals(true and true, true, 'And true/true')
  assertEquals(false and true, false, 'And false/true')
  assertEquals(true and false, false, 'And true/false')
  assertEquals(false and false, false, 'And false/false')
end


-- Describe this function...
function test_or()
  assertEquals(true or true, true, 'Or true/true')
  assertEquals(false or true, true, 'Or false/true')
  assertEquals(true or false, true, 'Or true/false')
  assertEquals(false or false, false, 'Or false/false')
end


-- Describe this function...
function test_ternary()
  assertEquals(true and 42 or 99, 42, 'if true')
  assertEquals(false and 42 or 99, 99, 'if true')
end


-- Describe this function...
function test_foreach()
  log = ''
  for _, x in ipairs({'a', 'b', 'c'}) do
    log = log .. x
  end
  assertEquals(log, 'abc', 'for loop')
end


-- Describe this function...
function test_repeat()
  count = 0
  for count2 = 1, 10 do
    count = count + 1
  end
  assertEquals(count, 10, 'repeat 10')
end


-- Describe this function...
function test_while()
  while false do
    unittest_fail('while 0')
  end
  while not true do
    unittest_fail('until 0')
  end
  count = 1
  while count ~= 10 do
    count = count + 1
  end
  assertEquals(count, 10, 'while 10')
  count = 1
  while not (count == 10) do
    count = count + 1
  end
  assertEquals(count, 10, 'until 10')
end


-- Describe this function...
function test_repeat_ext()
  count = 0
  for count3 = 1, 10 do
    count = count + 1
  end
  assertEquals(count, 10, 'repeat 10')
end


-- Describe this function...
function test_count_by()
  log = ''
  for x = 1, 8, 2 do
    log = log .. x
  end
  assertEquals(log, '1357', 'count up ints')
  log = ''
  for x = 8, 1, -2 do
    log = log .. x
  end
  assertEquals(log, '8642', 'count down ints')
  loglist = {}
  for x = 1, 8, 1.5 do
    table.insert(loglist, #loglist + 1, x)
  end
  assertEquals(loglist, {1, 2.5, 4, 5.5, 7}, 'count with floats')
  loglist = {}
  x_inc = math.abs(1 - 2)
  if (1 + 0) > (8 + 0) then
    x_inc = -x_inc
  end
  for x = 1 + 0, 8 + 0, x_inc do
    table.insert(loglist, #loglist + 1, x)
  end
  assertEquals(loglist, {1, 2, 3, 4, 5, 6, 7, 8}, 'count up non-trivial ints')
  loglist = {}
  x_inc2 = 2
  if (8 + 0) > (1 + 0) then
    x_inc2 = -x_inc2
  end
  for x = 8 + 0, 1 + 0, x_inc2 do
    table.insert(loglist, #loglist + 1, x)
  end
  assertEquals(loglist, {8, 6, 4, 2}, 'count down non-trivial ints')
  loglist = {}
  x_inc3 = math.abs(1 + 0)
  if (5 + 0.5) > (1 + 0) then
    x_inc3 = -x_inc3
  end
  for x = 5 + 0.5, 1 + 0, x_inc3 do
    table.insert(loglist, #loglist + 1, x)
  end
  assertEquals(loglist, {5.5, 4.5, 3.5, 2.5, 1.5}, 'count with floats')
end


-- Describe this function...
function test_count_loops()
  log = ''
  for x = 1, 8, 1 do
    log = log .. x
  end
  assertEquals(log, '12345678', 'count up')
  log = ''
  for x = 8, 1, -1 do
    log = log .. x
  end
  assertEquals(log, '87654321', 'count down')
  loglist = {}
  x_inc4 = 1
  if (1 + 0) > (4 + 0) then
    x_inc4 = -x_inc4
  end
  for x = 1 + 0, 4 + 0, x_inc4 do
    table.insert(loglist, #loglist + 1, x)
  end
  assertEquals(loglist, {1, 2, 3, 4}, 'count up non-trivial')
  loglist = {}
  x_inc5 = 1
  if (3 + 1) > (1 + 0) then
    x_inc5 = -x_inc5
  end
  for x = 3 + 1, 1 + 0, x_inc5 do
    table.insert(loglist, #loglist + 1, x)
  end
  assertEquals(loglist, {4, 3, 2, 1}, 'count down non-trivial')
end


-- Describe this function...
function test_continue()
  log = ''
  count = 0
  while count ~= 8 do
    count = count + 1
    if count == 5 then
      goto continue
    end
    log = log .. count
    ::continue::
  end
  assertEquals(log, '1234678', 'while continue')
  log = ''
  count = 0
  while not (count == 8) do
    count = count + 1
    if count == 5 then
      goto continue
    end
    log = log .. count
    ::continue::
  end
  assertEquals(log, '1234678', 'until continue')
  log = ''
  for x = 1, 8, 1 do
    if x == 5 then
      goto continue
    end
    log = log .. x
    ::continue::
  end
  assertEquals(log, '1234678', 'count continue')
  log = ''
  for _, x in ipairs({'a', 'b', 'c', 'd'}) do
    if x == 'c' then
      goto continue
    end
    log = log .. x
    ::continue::
  end
  assertEquals(log, 'abd', 'for continue')
end


-- Describe this function...
function test_break()
  count = 1
  while count ~= 10 do
    if count == 5 then
      break
    end
    count = count + 1
  end
  assertEquals(count, 5, 'while break')
  count = 1
  while not (count == 10) do
    if count == 5 then
      break
    end
    count = count + 1
  end
  assertEquals(count, 5, 'until break')
  log = ''
  for x = 1, 8, 1 do
    if x == 5 then
      break
    end
    log = log .. x
  end
  assertEquals(log, '1234', 'count break')
  log = ''
  for _, x in ipairs({'a', 'b', 'c', 'd'}) do
    if x == 'c' then
      break
    end
    log = log .. x
  end
  assertEquals(log, 'ab', 'for break')
end


-- Tests the "single" block.
function test_single()
  assertEquals(math.sqrt(25), 5, 'sqrt')
  assertEquals(math.abs(-25), 25, 'abs')
  assertEquals(-(-25), 25, 'negate')
  assertEquals(math.log(1), 0, 'ln')
  assertEquals(math.log(100, 10), 2, 'log10')
  assertEquals(math.exp(2), 7.38905609893065, 'exp')
  assertEquals(10 ^ 2, 100, 'power10')
end


-- Tests the "arithmetic" block for all operations and checks
-- parenthesis are properly generated for different orders.
function test_arithmetic()
  assertEquals(1 + 2, 3, 'add')
  assertEquals(1 - 2, -1, 'subtract')
  assertEquals(1 - (0 + 2), -1, 'subtract order with add')
  assertEquals(1 - (0 - 2), 3, 'subtract order with subtract')
  assertEquals(4 * 2.5, 10, 'multiply')
  assertEquals(4 * (0 + 2.5), 10, 'multiply order')
  assertEquals(8.2 / -5, -1.64, 'divide')
  assertEquals(8.2 / (0 + -5), -1.64, 'divide order')
  assertEquals(10 ^ 4, 10000, 'power')
  assertEquals(10 ^ (0 + 4), 10000, 'power order')
end


-- Tests the "trig" block.
function test_trig()
  assertEquals(math.sin(math.rad(90)), 1, 'sin')
  assertEquals(math.cos(math.rad(180)), -1, 'cos')
  assertEquals(math.tan(math.rad(0)), 0, 'tan')
  assertEquals(math.deg(math.asin(-1)), -90, 'asin')
  assertEquals(math.deg(math.acos(1)), 0, 'acos')
  assertEquals(math.deg(math.atan(1)), 45, 'atan')
end


-- Tests the "constant" blocks.
function test_constant()
  assertEquals(math.floor(math.pi * 1000), 3141, 'const pi')
  assertEquals(math.floor(math.exp(1) * 1000), 2718, 'const e')
  assertEquals(math.floor(((1 + math.sqrt(5)) / 2) * 1000), 1618, 'const golden')
  assertEquals(math.floor(math.sqrt(2) * 1000), 1414, 'const sqrt 2')
  assertEquals(math.floor(math.sqrt(1 / 2) * 1000), 707, 'const sqrt 0.5')
  assertEquals(9999 < math.huge, true, 'const infinity')
end


function math_isPrime(n)
  -- https://en.wikipedia.org/wiki/Primality_test#Naive_methods
  if n == 2 or n == 3 then
    return true
  end
  -- False if n is NaN, negative, is 1, or not whole.
  -- And false if n is divisible by 2 or 3.
  if not(n > 1) or n % 1 ~= 0 or n % 2 == 0 or n % 3 == 0 then
    return false
  end
  -- Check all the numbers of form 6k +/- 1, up to sqrt(n).
  for x = 6, math.sqrt(n) + 1.5, 6 do
    if n % (x - 1) == 0 or n % (x + 1) == 0 then
      return false
    end
  end
  return true
end

-- Tests the "number property" blocks.
function test_number_properties()
  assertEquals(42 % 2 == 0, true, 'even')
  assertEquals(42.1 % 2 == 1, false, 'odd')
  assertEquals(math_isPrime(5), true, 'prime 5')
  assertEquals(math_isPrime(5 + 2), true, 'prime 5 + 2 (extra parentheses)')
  assertEquals(math_isPrime(25), false, 'prime 25')
  assertEquals(math_isPrime(-31.1), false, 'prime negative')
  assertEquals(math.pi % 1 == 0, false, 'whole')
  assertEquals(math.huge > 0, true, 'positive')
  assertEquals(5 + 2 > 0, true, '5 + 2 is positive (extra parentheses)')
  assertEquals(-42 < 0, true, 'negative')
  assertEquals(3 + 2 < 0, false, '3 + 2 is negative (extra parentheses)')
  assertEquals(42 % 2 == 0, true, 'divisible')
  assertEquals(not nil, true, 'divisible by 0')
end


-- Tests the "round" block.
function test_round()
  assertEquals(math.floor(42.42 + .5), 42, 'round')
  assertEquals(math.ceil(-42.42), -42, 'round up')
  assertEquals(math.floor(42.42), 42, 'round down')
end


-- Tests the "change" block.
function test_change()
  varToChange = 100
  varToChange = varToChange + 42
  assertEquals(varToChange, 142, 'change')
end


function math_sum(t)
  local result = 0
  for _, v in ipairs(t) do
    result = result + v
  end
  return result
end

function math_min(t)
  if #t == 0 then
    return 0
  end
  local result = math.huge
  for _, v in ipairs(t) do
    if v < result then
      result = v
    end
  end
  return result
end

function math_max(t)
  if #t == 0 then
    return 0
  end
  local result = -math.huge
  for _, v in ipairs(t) do
    if v > result then
      result = v
    end
  end
  return result
end

function math_average(t)
  if #t == 0 then
    return 0
  end
  return math_sum(t) / #t
end

function math_median(t)
  -- Source: http://lua-users.org/wiki/SimpleStats
  if #t == 0 then
    return 0
  end
  local temp = {}
  for _, v in ipairs(t) do
    if type(v) == 'number' then
      table.insert(temp, v)
    end
  end
  table.sort(temp)
  if #temp % 2 == 0 then
    return (temp[#temp / 2] + temp[(#temp / 2) + 1]) / 2
  else
    return temp[math.ceil(#temp / 2)]
  end
end

function math_modes(t)
  -- Source: http://lua-users.org/wiki/SimpleStats
  local counts = {}
  for _, v in ipairs(t) do
    if counts[v] == nil then
      counts[v] = 1
    else
      counts[v] = counts[v] + 1
    end
  end
  local biggestCount = 0
  for _, v  in pairs(counts) do
    if v > biggestCount then
      biggestCount = v
    end
  end
  local temp = {}
  for k, v in pairs(counts) do
    if v == biggestCount then
      table.insert(temp, k)
    end
  end
  return temp
end

function math_standard_deviation(t)
  local m
  local vm
  local total = 0
  local count = 0
  local result
  m = #t == 0 and 0 or math_sum(t) / #t
  for _, v in ipairs(t) do
    if type(v) == 'number' then
      vm = v - m
      total = total + (vm * vm)
      count = count + 1
    end
  end
  result = math.sqrt(total / (count-1))
  return result
end

function math_random_list(t)
  if #t == 0 then
    return nil
  end
  return t[math.random(#t)]
end

function first_index(t, elem)
  for k, v in ipairs(t) do
    if v == elem then
      return k
    end
  end
  return 0
end

-- Tests the "list operation" blocks.
function test_operations_on_list()
  assertEquals(math_sum({3, 4, 5}), 12, 'sum')
  assertEquals(math_min({3, 4, 5}), 3, 'min')
  assertEquals(math_max({3, 4, 5}), 5, 'max')
  assertEquals(math_average({3, 4, 5}), 4, 'average')
  assertEquals(math_median({3, 4, 5, 1}), 3.5, 'median')
  assertEquals(math_modes({3, 4, 3}), {3}, 'modes')
  assertEquals(math_modes({3, 4, 3, 1, 4}), {3, 4}, 'modes multiple')
  assertEquals(math_standard_deviation({3, 3, 3}), 0, 'standard dev')
  assertEquals(first_index({3, 4, 5}, math_random_list({3, 4, 5})) > 0, true, 'random')
end


-- Tests the "mod" block.
function test_mod()
  assertEquals(42 % 5, 2, 'mod')
end


-- Tests the "constrain" block.
function test_constraint()
  assertEquals(math.min(math.max(100, 0), 42), 42, 'constraint')
end


-- Tests the "random integer" block.
function test_random_integer()
  rand = math.random(5, 10)
  assertEquals(rand >= 5 and rand <= 10, true, 'randRange')
  assertEquals(rand % 1 == 0, true, 'randInteger')
end


-- Tests the "random fraction" block.
function test_random_fraction()
  rand = math.random()
  assertEquals(rand >= 0 and rand <= 1, true, 'randFloat')
end


-- Describe this function...
function test_atan2()
  assertEquals(math.deg(math.atan2(5, -5)), 135, 'atan2')
  assertEquals(math.deg(math.atan2(-12, 0)), -90, 'atan2')
end


-- Checks that the number of calls is one in order
-- to confirm that a function was only called once.
function check_number_of_calls(test_name)
  test_name = test_name .. 'number of calls'
  assertEquals(number_of_calls, 1, test_name)
end


-- Tests the "create text with" block with varying number of inputs.
function test_create_text()
  assertEquals('', '', 'no text')
  assertEquals(tostring('Hello'), 'Hello', 'create single')
  assertEquals(tostring(-1), '-1', 'create single number')
  assertEquals('K' .. 9, 'K9', 'create double text')
  assertEquals(4 .. 2, '42', 'create double text numbers')
  assertEquals(table.concat({1, 2, 3}), '123', 'create triple')
  assertEquals(table.concat({1, true and 0 or nil, 'M'}), '10M', 'create order')
end


-- Creates an empty string for use with the empty test.
function get_empty()
  return ''
end


-- Tests the "is empty" block".
function test_empty_text()
  assertEquals(#'Google' == 0, false, 'not empty')
  assertEquals(#'' == 0, true, 'empty')
  assertEquals(#get_empty() == 0, true, 'empty complex')
  assertEquals(#(true and '' or nil) == 0, true, 'empty order')
end


-- Tests the "length" block.
function test_text_length()
  assertEquals(#'', 0, 'zero length')
  assertEquals(#'Google', 6, 'non-zero length')
  assertEquals(#(true and 'car' or nil), 3, 'length order')
end


-- Tests the "append text" block with different types of parameters.
function test_append()
  item = 'Miserable'
  item = item .. 'Failure'
  assertEquals(item, 'MiserableFailure', 'append text')
  item = 12
  item = item .. 34
  assertEquals(item, '1234', 'append number')
  item = 'Something '
  item = item .. (true and 'Positive' or nil)
  assertEquals(item, 'Something Positive', 'append order')
end


function firstIndexOf(str, substr)
  local i = string.find(str, substr, 1, true)
  if i == nil then
    return 0
  end
  return i
end

function lastIndexOf(str, substr)
  local i = string.find(string.reverse(str), string.reverse(substr), 1, true)
  if i then
    return #str + 2 - i - #substr
  end
  return 0
end

-- Tests the "find" block with a variable.
function test_find_text_simple()
  text = 'Banana'
  assertEquals(firstIndexOf(text, 'an'), 2, 'find first simple')
  assertEquals(lastIndexOf(text, 'an'), 4, 'find last simple')
  assertEquals(firstIndexOf(text, 'Peel'), 0, 'find none simple')
end


-- Creates a string for use with the find test.
function get_fruit()
  number_of_calls = number_of_calls + 1
  return 'Banana'
end


-- Tests the "find" block with a function call.
function test_find_text_complex()
  number_of_calls = 0
  assertEquals(firstIndexOf(get_fruit(), 'an'), 2, 'find first complex')
  check_number_of_calls('find first complex')
  number_of_calls = 0
  assertEquals(firstIndexOf(true and get_fruit() or nil, 'an'), 2, 'find first order complex')
  check_number_of_calls('find first order complex')
  number_of_calls = 0
  assertEquals(lastIndexOf(get_fruit(), 'an'), 4, 'find last complex')
  check_number_of_calls('find last complex')
  number_of_calls = 0
  assertEquals(lastIndexOf(true and get_fruit() or nil, 'an'), 4, 'find last order complex')
  check_number_of_calls('find last order complex')
  number_of_calls = 0
  assertEquals(firstIndexOf(get_fruit(), 'Peel'), 0, 'find none complex')
  check_number_of_calls('find none complex')
  number_of_calls = 0
  assertEquals(firstIndexOf(true and get_fruit() or nil, 'Peel'), 0, 'find none order complex')
  check_number_of_calls('find none order complex')
end


function text_random_letter(str)
  local index = math.random(string.len(str))
  return string.sub(str, index, index)
end

function text_char_at(str, index)
  return string.sub(str, index, index)
end

-- Tests the "get letter" block with a variable.
function test_get_text_simple()
  text = 'Blockly'
  assertEquals(string.sub(text, 1, 1), 'B', 'get first simple')
  assertEquals(string.sub(text, -1, -1), 'y', 'get last simple')
  assertEquals(firstIndexOf(text, text_random_letter(text)) > 0, true, 'get random simple')
  assertEquals(string.sub(text, 3, 3), 'o', 'get # simple')
  assertEquals(text_char_at(text, true and 3 or nil), 'o', 'get # order simple')
  assertEquals(string.sub(text, -3, -3), 'k', 'get #-end simple')
  -- The order for index for #-end is addition because this will catch errors in generators where most perform the operation ... - index.
  assertEquals(text_char_at(text, -(0 + 3)), 'k', 'get #-end order simple')
end


-- Creates a string for use with the get test.
function get_Blockly()
  number_of_calls = number_of_calls + 1
  return 'Blockly'
end


-- Tests the "get letter" block with a function call.
function test_get_text_complex()
  text = 'Blockly'
  number_of_calls = 0
  assertEquals(string.sub(get_Blockly(), 1, 1), 'B', 'get first complex')
  check_number_of_calls('get first complex')
  number_of_calls = 0
  assertEquals(string.sub(true and get_Blockly() or nil, 1, 1), 'B', 'get first order complex')
  check_number_of_calls('get first order complex')
  number_of_calls = 0
  assertEquals(string.sub(get_Blockly(), -1, -1), 'y', 'get last complex')
  check_number_of_calls('get last complex')
  number_of_calls = 0
  assertEquals(string.sub(true and get_Blockly() or nil, -1, -1), 'y', 'get last order complex')
  check_number_of_calls('get last order complex')
  number_of_calls = 0
  assertEquals(firstIndexOf(text, text_random_letter(get_Blockly())) > 0, true, 'get random complex')
  check_number_of_calls('get random complex')
  number_of_calls = 0
  assertEquals(firstIndexOf(text, text_random_letter(true and get_Blockly() or nil)) > 0, true, 'get random order complex')
  check_number_of_calls('get random order complex')
  number_of_calls = 0
  assertEquals(string.sub(get_Blockly(), 3, 3), 'o', 'get # complex')
  check_number_of_calls('get # complex')
  number_of_calls = 0
  assertEquals(text_char_at(true and get_Blockly() or nil, true and 3 or nil), 'o', 'get # order complex')
  check_number_of_calls('get # order complex')
  number_of_calls = 0
  assertEquals(string.sub(get_Blockly(), -3, -3), 'k', 'get #-end complex')
  check_number_of_calls('get #-end complex')
  number_of_calls = 0
  -- The order for index for #-end is addition because this will catch errors in generators where most perform the operation ... - index.
  assertEquals(text_char_at(true and get_Blockly() or nil, -(0 + 3)), 'k', 'get #-end order complex')
  check_number_of_calls('get #-end order complex')
end


-- Creates a string for use with the substring test.
function get_numbers()
  number_of_calls = number_of_calls + 1
  return '123456789'
end


-- Tests the "get substring" block with a variable.
function test_substring_simple()
  text = '123456789'
  assertEquals(string.sub(text, 2, 3), '23', 'substring # simple')
  assertEquals(string.sub(text, true and 2 or nil, true and 3 or nil), '23', 'substring # simple order')
  assertEquals(string.sub(text, -3, -2), '78', 'substring #-end simple')
  -- The order for index for #-end is addition because this will catch errors in generators where most perform the operation ... - index.
  assertEquals(string.sub(text, -(0 + 3), -(0 + 2)), '78', 'substring #-end simple order')
  assertEquals(string.sub(text, 1, -1), text, 'substring first-last simple')
  assertEquals(string.sub(text, 2, -2), '2345678', 'substring # #-end simple')
  assertEquals(string.sub(text, -7, 4), '34', 'substring #-end # simple')
  assertEquals(string.sub(text, 1, 4), '1234', 'substring first # simple')
  assertEquals(string.sub(text, 1, -2), '12345678', 'substring first #-end simple')
  assertEquals(string.sub(text, 7, -1), '789', 'substring # last simple')
  assertEquals(string.sub(text, -3, -1), '789', 'substring #-end last simple')
  assertEquals(string.sub(text, 1, -1), '123456789', 'substring all with # #-end simple')
  assertEquals(string.sub(text, -9, 9), '123456789', 'substring all with #-end # simple')
  -- Checks that the whole string is properly retrieved even if the value for start and end is not a simple number. This is especially important in generators where substring uses [x:length - y] for # #-end.
  assertEquals(string.sub(text, 0 + 1, -(0 + 1)), '123456789', 'substring all with # #-end math simple')
end


-- Tests the "get substring" block with a function call.
function test_substring_complex()
  number_of_calls = 0
  assertEquals(string.sub(get_numbers(), 2, 3), '23', 'substring # complex')
  check_number_of_calls('substring # complex')
  number_of_calls = 0
  assertEquals(string.sub(true and get_numbers() or nil, true and 2 or nil, true and 3 or nil), '23', 'substring # complex order')
  check_number_of_calls('substring # complex order')
  number_of_calls = 0
  -- The order for index for #-end is addition because this will catch errors in generators where most perform the operation ... - index.
  assertEquals(string.sub(get_numbers(), -3, -2), '78', 'substring #-end complex')
  check_number_of_calls('substring #-end complex')
  number_of_calls = 0
  assertEquals(string.sub(true and get_numbers() or nil, -(0 + 3), -(0 + 2)), '78', 'substring #-end order order')
  check_number_of_calls('substring #-end order order')
  number_of_calls = 0
  assertEquals(string.sub(get_numbers(), 1, -1), text, 'substring first-last')
  check_number_of_calls('substring first-last')
  number_of_calls = 0
  assertEquals(string.sub(get_numbers(), 2, -2), '2345678', 'substring # #-end complex')
  check_number_of_calls('substring # #-end complex')
  number_of_calls = 0
  assertEquals(string.sub(get_numbers(), -7, 4), '34', 'substring #-end # complex')
  check_number_of_calls('substring #-end # complex')
  number_of_calls = 0
  assertEquals(string.sub(get_numbers(), 1, 4), '1234', 'substring first # complex')
  check_number_of_calls('substring first # complex')
  number_of_calls = 0
  assertEquals(string.sub(get_numbers(), 1, -2), '12345678', 'substring first #-end complex')
  check_number_of_calls('substring first #-end complex')
  number_of_calls = 0
  assertEquals(string.sub(get_numbers(), 7, -1), '789', 'substring # last complex')
  check_number_of_calls('substring # last complex')
  number_of_calls = 0
  assertEquals(string.sub(get_numbers(), -3, -1), '789', 'substring #-end last complex')
  check_number_of_calls('substring #-end last complex')
  number_of_calls = 0
  assertEquals(string.sub(get_numbers(), 1, -1), '123456789', 'substring all with # #-end complex')
  check_number_of_calls('substring all with # #-end complex')
  number_of_calls = 0
  assertEquals(string.sub(get_numbers(), -9, 9), '123456789', 'substring all with #-end # complex')
  check_number_of_calls('substring all with #-end # complex')
  number_of_calls = 0
  -- Checks that the whole string is properly retrieved even if the value for start and end is not a simple number. This is especially important in generators where substring uses [x:length - y] for # #-end.
  assertEquals(string.sub(get_numbers(), 0 + 1, -(0 + 1)), '123456789', 'substring all with # #-end math complex')
  check_number_of_calls('substring all with # #-end math complex')
end


function text_titlecase(str)
  local buf = {}
  local inWord = false
  for i = 1, #str do
    local c = string.sub(str, i, i)
    if inWord then
      table.insert(buf, string.lower(c))
      if string.find(c, "%s") then
        inWord = false
      end
    else
      table.insert(buf, string.upper(c))
      inWord = true
    end
  end
  return table.concat(buf)
end

-- Tests the "change casing" block.
function test_case()
  text = 'Hello World'
  assertEquals(string.upper(text), 'HELLO WORLD', 'uppercase')
  assertEquals(string.upper(true and text or nil), 'HELLO WORLD', 'uppercase order')
  text = 'Hello World'
  assertEquals(string.lower(text), 'hello world', 'lowercase')
  assertEquals(string.lower(true and text or nil), 'hello world', 'lowercase order')
  text = 'heLLo WorlD'
  assertEquals(text_titlecase(text), 'Hello World', 'titlecase')
  assertEquals(text_titlecase(true and text or nil), 'Hello World', 'titlecase order')
end


-- Tests the "trim" block.
function test_trim()
  text = '   abc def   '
  assertEquals(string.gsub(text, "^%s*(.-)%s*$", "%1"), 'abc def', 'trim both')
  assertEquals(string.gsub(true and text or nil, "^%s*(.-)%s*$", "%1"), 'abc def', 'trim both order')
  assertEquals(string.gsub(text, "^%s*(,-)", "%1"), 'abc def   ', 'trim left')
  assertEquals(string.gsub(true and text or nil, "^%s*(,-)", "%1"), 'abc def   ', 'trim left order')
  assertEquals(string.gsub(text, "(.-)%s*$", "%1"), '   abc def', 'trim right')
  assertEquals(string.gsub(true and text or nil, "(.-)%s*$", "%1"), '   abc def', 'trim right order')
end


function text_count(haystack, needle)
  if #needle == 0 then
    return #haystack + 1
  end
  local i = 1
  local count = 0
  while true do
    i = string.find(haystack, needle, i, true)
    if i == nil then
      break
    end
    count = count + 1
    i = i + #needle
  end
  return count
end

-- Tests the "trim" block.
function test_count_text()
  text = 'woolloomooloo'
  assertEquals(text_count(text, 'o'), 8, 'len 1')
  assertEquals(text_count(text, 'oo'), 4, 'len 2')
  assertEquals(text_count(text, 'loo'), 2, 'len 3')
  assertEquals(text_count(text, 'wool'), 1, 'start')
  assertEquals(text_count(text, 'chicken'), 0, 'missing')
  assertEquals(text_count(text, ''), 14, 'empty needle')
  assertEquals(text_count('', 'chicken'), 0, 'empty source')
end


-- Tests the "trim" block.
function test_text_reverse()
  assertEquals(string.reverse(''), '', 'empty string')
  assertEquals(string.reverse('a'), 'a', 'len 1')
  assertEquals(string.reverse('ab'), 'ba', 'len 2')
  assertEquals(string.reverse('woolloomooloo'), 'ooloomoolloow', 'longer')
end


function text_replace(haystack, needle, replacement)
  local buf = {}
  local i = 1
  while i <= #haystack do
    if string.sub(haystack, i, i + #needle - 1) == needle then
      for j = 1, #replacement do
        table.insert(buf, string.sub(replacement, j, j))
      end
      i = i + #needle
    else
      table.insert(buf, string.sub(haystack, i, i))
      i = i + 1
    end
  end
  return table.concat(buf)
end

-- Tests the "trim" block.
function test_replace()
  assertEquals(text_replace('woolloomooloo', 'oo', '123'), 'w123ll123m123l123', 'replace all instances 1')
  assertEquals(text_replace('woolloomooloo', '.oo', 'X'), 'woolloomooloo', 'literal string replacement')
  assertEquals(text_replace('woolloomooloo', 'abc', 'X'), 'woolloomooloo', 'not found')
  assertEquals(text_replace('woolloomooloo', 'o', ''), 'wllml', 'empty replacement 1')
  assertEquals(text_replace('aaaaa', 'aaaaa', ''), '', 'empty replacement 2')
  assertEquals(text_replace('aaaaa', 'a', ''), '', 'empty replacement 3')
  assertEquals(text_replace('', 'a', 'chicken'), '', 'empty source')
end


-- Checks that the number of calls is one in order
-- to confirm that a function was only called once.
function check_number_of_calls2(test_name)
  test_name = test_name .. 'number of calls'
  assertEquals(number_of_calls, 1, test_name)
end


function create_list_repeated(item, count)
  local t = {}
  for i = 1, count do
    table.insert(t, item)
  end
  return t
end

-- Tests the "create list with" and "create empty list" blocks.
function test_create_lists()
  assertEquals({}, {}, 'create empty')
  assertEquals({true, 'love'}, {true, 'love'}, 'create items')
  assertEquals(create_list_repeated('Eject', 3), {'Eject', 'Eject', 'Eject'}, 'create repeated')
  assertEquals(create_list_repeated('Eject', 0 + 3), {'Eject', 'Eject', 'Eject'}, 'create repeated order')
end


-- Creates an empty list for use with the empty test.
function get_empty_list()
  return {}
end


-- Tests the "is empty" block.
function test_lists_empty()
  assertEquals(#{0} == 0, false, 'not empty')
  assertEquals(#{} == 0, true, 'empty')
  assertEquals(#get_empty_list() == 0, true, 'empty complex')
  assertEquals(#(true and {} or nil) == 0, true, 'empty order')
end


-- Tests the "length" block.
function test_lists_length()
  assertEquals(#{}, 0, 'zero length')
  assertEquals(#{'cat'}, 1, 'one length')
  assertEquals(#{'cat', true, {}}, 3, 'three length')
  assertEquals(#(true and {'cat', true} or nil), 2, 'two length order')
end


function last_index(t, elem)
  for i = #t, 1, -1 do
    if t[i] == elem then
      return i
    end
  end
  return 0
end

-- Tests the "find" block with a variable.
function test_find_lists_simple()
  list = {'Alice', 'Eve', 'Bob', 'Eve'}
  assertEquals(first_index(list, 'Eve'), 2, 'find first simple')
  assertEquals(last_index(list, 'Eve'), 4, 'find last simple')
  assertEquals(first_index(list, 'Dave'), 0, 'find none simple')
end


-- Creates a list for use with the find test.
function get_names()
  number_of_calls = number_of_calls + 1
  return {'Alice', 'Eve', 'Bob', 'Eve'}
end


-- Tests the "find" block with a function call.
function test_find_lists_complex()
  number_of_calls = 0
  assertEquals(first_index(get_names(), 'Eve'), 2, 'find first complex')
  check_number_of_calls('find first complex')
  number_of_calls = 0
  assertEquals(first_index(true and get_names() or nil, 'Eve'), 2, 'find first order complex')
  check_number_of_calls('find first order complex')
  number_of_calls = 0
  assertEquals(last_index(get_names(), 'Eve'), 4, 'find last complex')
  check_number_of_calls('find last complex')
  number_of_calls = 0
  assertEquals(last_index(true and get_names() or nil, 'Eve'), 4, 'find last order complex')
  check_number_of_calls('find last order complex')
  number_of_calls = 0
  assertEquals(first_index(get_names(), 'Dave'), 0, 'find none complex')
  check_number_of_calls('find none complex')
  number_of_calls = 0
  assertEquals(first_index(true and get_names() or nil, 'Dave'), 0, 'find none order complex')
  check_number_of_calls('find none order complex')
end


-- Tests the "get" block with a variable.
function test_get_lists_simple()
  list = {'Kirk', 'Spock', 'McCoy'}
  assertEquals(list[1], 'Kirk', 'get first simple')
  assertEquals(list[#list], 'McCoy', 'get last simple')
  assertEquals(first_index(list, list[math.random(#list)]) > 0, true, 'get random simple')
  assertEquals(list[2], 'Spock', 'get # simple')
  assertEquals(list[true and 2 or nil], 'Spock', 'get # order simple')
  assertEquals(list[#list + 1 - 3], 'Kirk', 'get #-end simple')
  -- The order for index for #-end is addition because this will catch errors in generators where most perform the operation ... - index.
  assertEquals(list[#list + 1 - (0 + 3)], 'Kirk', 'get #-end order simple')
end


function list_get_last(t)
  return t[#t]
end

function list_get_random(t)
  return t[math.random(#t)]
end

function list_get_from_end(t, at)
  return t[#t + 1 - at]
end

-- Tests the "get" block with create list call.
function test_get_lists_create_list()
  assertEquals(({'Kirk', 'Spock', 'McCoy'})[1], 'Kirk', 'get first create list')
  assertEquals(list_get_last(({'Kirk', 'Spock', 'McCoy'})), 'McCoy', 'get last simple')
  assertEquals(first_index({'Kirk', 'Spock', 'McCoy'}, list_get_random(({'Kirk', 'Spock', 'McCoy'}))) > 0, true, 'get random simple')
  assertEquals(({'Kirk', 'Spock', 'McCoy'})[2], 'Spock', 'get # simple')
  assertEquals(({'Kirk', 'Spock', 'McCoy'})[true and 2 or nil], 'Spock', 'get # order simple')
  assertEquals(list_get_from_end(({'Kirk', 'Spock', 'McCoy'}), 3), 'Kirk', 'get #-end simple')
  -- The order for index for #-end is addition because this will catch errors in generators where most perform the operation ... - index.
  assertEquals(list_get_from_end(({'Kirk', 'Spock', 'McCoy'}), 0 + 3), 'Kirk', 'get #-end order simple')
end


-- Creates a list for use with the get test.
function get_star_wars()
  number_of_calls = number_of_calls + 1
  return {'Kirk', 'Spock', 'McCoy'}
end


-- Tests the "get" block with a function call.
function test_get_lists_complex()
  list = {'Kirk', 'Spock', 'McCoy'}
  number_of_calls = 0
  assertEquals((get_star_wars())[1], 'Kirk', 'get first complex')
  check_number_of_calls('get first complex')
  number_of_calls = 0
  assertEquals((true and get_star_wars() or nil)[1], 'Kirk', 'get first order complex')
  check_number_of_calls('get first order complex')
  number_of_calls = 0
  assertEquals(list_get_last((get_star_wars())), 'McCoy', 'get last complex')
  check_number_of_calls('get last complex')
  number_of_calls = 0
  assertEquals(list_get_last((true and get_star_wars() or nil)), 'McCoy', 'get last order complex')
  check_number_of_calls('get last order complex')
  number_of_calls = 0
  assertEquals(first_index(list, list_get_random((get_star_wars()))) > 0, true, 'get random complex')
  check_number_of_calls('get random complex')
  number_of_calls = 0
  assertEquals(first_index(list, list_get_random((true and get_star_wars() or nil))) > 0, true, 'get random order complex')
  check_number_of_calls('get random order complex')
  number_of_calls = 0
  assertEquals((get_star_wars())[2], 'Spock', 'get # complex')
  check_number_of_calls('get # complex')
  number_of_calls = 0
  assertEquals((true and get_star_wars() or nil)[true and 2 or nil], 'Spock', 'get # order complex')
  check_number_of_calls('get # order complex')
  number_of_calls = 0
  assertEquals(list_get_from_end((get_star_wars()), 3), 'Kirk', 'get #-end complex')
  check_number_of_calls('get #-end complex')
  number_of_calls = 0
  -- The order for index for #-end is addition because this will catch errors in generators where most perform the operation ... - index.
  assertEquals(list_get_from_end((true and get_star_wars() or nil), 0 + 3), 'Kirk', 'get #-end order complex')
  check_number_of_calls('get #-end order complex')
end


function list_remove_last(t)
  return table.remove(t, #t)
end

function list_remove_random(t)
  return table.remove(t, math.random(#t))
end

function list_remove_from_end(t, at)
  return table.remove(t, #t + 1 - at)
end

-- Tests the "get and remove" block.
function test_getRemove()
  list = {'Kirk', 'Spock', 'McCoy'}
  assertEquals(table.remove(list, 1), 'Kirk', 'getremove first')
  assertEquals(list, {'Spock', 'McCoy'}, 'getremove first list')
  list = {'Kirk', 'Spock', 'McCoy'}
  assertEquals(table.remove((true and list or nil), 1), 'Kirk', 'getremove first order')
  assertEquals(list, {'Spock', 'McCoy'}, 'getremove first order list')
  list = {'Kirk', 'Spock', 'McCoy'}
  assertEquals(table.remove(list, #list), 'McCoy', 'getremove last')
  assertEquals(list, {'Kirk', 'Spock'}, 'getremove last list')
  list = {'Kirk', 'Spock', 'McCoy'}
  assertEquals(list_remove_last((true and list or nil)), 'McCoy', 'getremove last order')
  assertEquals(list, {'Kirk', 'Spock'}, 'getremove last order list')
  list = {'Kirk', 'Spock', 'McCoy'}
  assertEquals(first_index(list, table.remove(list, math.random(#list))) == 0, true, 'getremove random')
  assertEquals(#list, 2, 'getremove random list')
  list = {'Kirk', 'Spock', 'McCoy'}
  assertEquals(first_index(list, list_remove_random((true and list or nil))) == 0, true, 'getremove random order')
  assertEquals(#list, 2, 'getremove random order list')
  list = {'Kirk', 'Spock', 'McCoy'}
  assertEquals(table.remove(list, 2), 'Spock', 'getremove #')
  assertEquals(list, {'Kirk', 'McCoy'}, 'getremove # list')
  list = {'Kirk', 'Spock', 'McCoy'}
  assertEquals(table.remove((true and list or nil), true and 2 or nil), 'Spock', 'getremove # order')
  assertEquals(list, {'Kirk', 'McCoy'}, 'getremove # order list')
  list = {'Kirk', 'Spock', 'McCoy'}
  assertEquals(table.remove(list, #list + 1 - 3), 'Kirk', 'getremove #-end')
  assertEquals(list, {'Spock', 'McCoy'}, 'getremove #-end list')
  list = {'Kirk', 'Spock', 'McCoy'}
  -- The order for index for #-end is addition because this will catch errors in generators where most perform the operation ... - index.
  assertEquals(list_remove_from_end((true and list or nil), 0 + 3), 'Kirk', 'getremove #-end order')
  assertEquals(list, {'Spock', 'McCoy'}, 'getremove #-end order list')
end


-- Tests the "remove" block.
function test_remove()
  list = {'Kirk', 'Spock', 'McCoy'}
  table.remove(list, 1)
  assertEquals(list, {'Spock', 'McCoy'}, 'remove first list')
  list = {'Kirk', 'Spock', 'McCoy'}
  table.remove((true and list or nil), 1)
  assertEquals(list, {'Spock', 'McCoy'}, 'remove first order list')
  list = {'Kirk', 'Spock', 'McCoy'}
  table.remove(list, #list)
  assertEquals(list, {'Kirk', 'Spock'}, 'remove last list')
  list = {'Kirk', 'Spock', 'McCoy'}
  tmp_list = (true and list or nil)
  table.remove(tmp_list, #tmp_list)
  assertEquals(list, {'Kirk', 'Spock'}, 'remove last order list')
  list = {'Kirk', 'Spock', 'McCoy'}
  table.remove(list, math.random(#list))
  assertEquals(#list, 2, 'remove random list')
  list = {'Kirk', 'Spock', 'McCoy'}
  tmp_list2 = (true and list or nil)
  table.remove(tmp_list2, math.random(#tmp_list2))
  assertEquals(#list, 2, 'remove random order list')
  list = {'Kirk', 'Spock', 'McCoy'}
  table.remove(list, 2)
  assertEquals(list, {'Kirk', 'McCoy'}, 'remove # list')
  list = {'Kirk', 'Spock', 'McCoy'}
  table.remove((true and list or nil), true and 2 or nil)
  assertEquals(list, {'Kirk', 'McCoy'}, 'remove # order list')
  list = {'Kirk', 'Spock', 'McCoy'}
  table.remove(list, #list + 1 - 3)
  assertEquals(list, {'Spock', 'McCoy'}, 'remove #-end list')
  list = {'Kirk', 'Spock', 'McCoy'}
  -- The order for index for #-end is addition because this will catch
  -- errors in generators where most perform the operation ... - index.
  tmp_list3 = (true and list or nil)
  table.remove(tmp_list3, #tmp_list3 + 1 - (0 + 3))
  assertEquals(list, {'Spock', 'McCoy'}, 'remove #-end order list')
end


-- Tests the "set" block.
function test_set()
  list = {'Picard', 'Riker', 'Crusher'}
  list[1] = 'Jean-Luc'
  assertEquals(list, {'Jean-Luc', 'Riker', 'Crusher'}, 'set first list')
  list = {'Picard', 'Riker', 'Crusher'}
  (true and list or nil)[1] = 'Jean-Luc'
  assertEquals(list, {'Jean-Luc', 'Riker', 'Crusher'}, 'set first order list')
  list = {'Picard', 'Riker', 'Crusher'}
  list[#list] = 'Beverly'
  assertEquals(list, {'Picard', 'Riker', 'Beverly'}, 'set last list')
  list = {'Picard', 'Riker', 'Crusher'}
  tmp_list4 = (true and list or nil)
  tmp_list4[#tmp_list4] = 'Beverly'
  assertEquals(list, {'Picard', 'Riker', 'Beverly'}, 'set last order list')
  list = {'Picard', 'Riker', 'Crusher'}
  list[math.random(#list)] = 'Data'
  assertEquals(#list, 3, 'set random list')
  list = {'Picard', 'Riker', 'Crusher'}
  tmp_list5 = (true and list or nil)
  tmp_list5[math.random(#tmp_list5)] = 'Data'
  assertEquals(#list, 3, 'set random order list')
  list = {'Picard', 'Riker', 'Crusher'}
  list[3] = 'Pulaski'
  assertEquals(list, {'Picard', 'Riker', 'Pulaski'}, 'set # list')
  list = {'Picard', 'Riker', 'Crusher'}
  (true and list or nil)[(true and 3 or nil)] = 'Pulaski'
  assertEquals(list, {'Picard', 'Riker', 'Pulaski'}, 'set # order list')
  list = {'Picard', 'Riker', 'Crusher'}
  list[#list + 1 - 1] = 'Pulaski'
  assertEquals(list, {'Picard', 'Riker', 'Pulaski'}, 'set #-end list')
  list = {'Picard', 'Riker', 'Crusher'}
  -- The order for index for #-end is addition because this will catch
  -- errors in generators where most perform the operation ... - index.
  tmp_list6 = (true and list or nil)
  tmp_list6[#tmp_list6 + 1 - (0 + 2)] = 'Pulaski'
  assertEquals(list, {'Picard', 'Pulaski', 'Crusher'}, 'set #-end order list')
end


-- Tests the "insert" block.
function test_insert()
  list = {'Picard', 'Riker', 'Crusher'}
  table.insert(list, 1, 'Data')
  assertEquals(list, {'Data', 'Picard', 'Riker', 'Crusher'}, 'insert first list')
  list = {'Picard', 'Riker', 'Crusher'}
  table.insert((true and list or nil), 1, 'Data')
  assertEquals(list, {'Data', 'Picard', 'Riker', 'Crusher'}, 'insert first order list')
  list = {'Picard', 'Riker', 'Crusher'}
  table.insert(list, #list + 1, 'Data')
  assertEquals(list, {'Picard', 'Riker', 'Crusher', 'Data'}, 'insert last list')
  list = {'Picard', 'Riker', 'Crusher'}
  tmp_list7 = (true and list or nil)
  table.insert(tmp_list7, #tmp_list7 + 1, 'Data')
  assertEquals(list, {'Picard', 'Riker', 'Crusher', 'Data'}, 'insert last order list')
  list = {'Picard', 'Riker', 'Crusher'}
  table.insert(list, math.random(#list), 'Data')
  assertEquals(#list, 4, 'insert random list')
  list = {'Picard', 'Riker', 'Crusher'}
  tmp_list8 = (true and list or nil)
  table.insert(tmp_list8, math.random(#tmp_list8), 'Data')
  assertEquals(#list, 4, 'insert random order list')
  list = {'Picard', 'Riker', 'Crusher'}
  table.insert(list, 3, 'Data')
  assertEquals(list, {'Picard', 'Riker', 'Data', 'Crusher'}, 'insert # list')
  list = {'Picard', 'Riker', 'Crusher'}
  table.insert((true and list or nil), (true and 3 or nil), 'Data')
  assertEquals(list, {'Picard', 'Riker', 'Data', 'Crusher'}, 'insert # order list')
  list = {'Picard', 'Riker', 'Crusher'}
  table.insert(list, #list + 1 - 1, 'Data')
  assertEquals(list, {'Picard', 'Riker', 'Data', 'Crusher'}, 'insert #-end list')
  list = {'Picard', 'Riker', 'Crusher'}
  -- The order for index for #-end is addition because this will catch
  -- errors in generators where most perform the operation ... - index.
  tmp_list9 = (true and list or nil)
  table.insert(tmp_list9, #tmp_list9 + 1 - (0 + 2), 'Data')
  assertEquals(list, {'Picard', 'Data', 'Riker', 'Crusher'}, 'insert #-end order list')
end


function list_sublist_from_start_from_start(source, at1, at2)
  local t = {}
  local start = at1
  local finish = at2
  for i = start, finish do
    table.insert(t, source[i])
  end
  return t
end

function list_sublist_from_end_from_end(source, at1, at2)
  local t = {}
  local start = #source + 1 - at1
  local finish = #source + 1 - at2
  for i = start, finish do
    table.insert(t, source[i])
  end
  return t
end

function list_sublist_first_last(source)
  local t = {}
  local start = 1
  local finish = #source
  for i = start, finish do
    table.insert(t, source[i])
  end
  return t
end

function list_sublist_from_start_from_end(source, at1, at2)
  local t = {}
  local start = at1
  local finish = #source + 1 - at2
  for i = start, finish do
    table.insert(t, source[i])
  end
  return t
end

function list_sublist_from_end_from_start(source, at1, at2)
  local t = {}
  local start = #source + 1 - at1
  local finish = at2
  for i = start, finish do
    table.insert(t, source[i])
  end
  return t
end

function list_sublist_first_from_start(source, at2)
  local t = {}
  local start = 1
  local finish = at2
  for i = start, finish do
    table.insert(t, source[i])
  end
  return t
end

function list_sublist_first_from_end(source, at2)
  local t = {}
  local start = 1
  local finish = #source + 1 - at2
  for i = start, finish do
    table.insert(t, source[i])
  end
  return t
end

function list_sublist_from_start_last(source, at1)
  local t = {}
  local start = at1
  local finish = #source
  for i = start, finish do
    table.insert(t, source[i])
  end
  return t
end

function list_sublist_from_end_last(source, at1)
  local t = {}
  local start = #source + 1 - at1
  local finish = #source
  for i = start, finish do
    table.insert(t, source[i])
  end
  return t
end

-- Tests the "get sub-list" block with a variable.
function test_sublist_simple()
  list = {'Columbia', 'Challenger', 'Discovery', 'Atlantis', 'Endeavour'}
  assertEquals(list_sublist_from_start_from_start(list, 2, 3), {'Challenger', 'Discovery'}, 'sublist # simple')
  assertEquals(list_sublist_from_start_from_start(list, true and 2 or nil, true and 3 or nil), {'Challenger', 'Discovery'}, 'sublist # simple order')
  assertEquals(list_sublist_from_end_from_end(list, 3, 2), {'Discovery', 'Atlantis'}, 'sublist #-end simple')
  -- The order for index for #-end is addition because this will catch errors in generators where most perform the operation ... - index.
  assertEquals(list_sublist_from_end_from_end(list, 0 + 3, 0 + 2), {'Discovery', 'Atlantis'}, 'sublist #-end simple order')
  assertEquals(list_sublist_first_last(list), list, 'sublist first-last simple')
  changing_list = {'Columbia', 'Challenger', 'Discovery', 'Atlantis', 'Endeavour'}
  list_copy = list_sublist_first_last(changing_list)
  table.remove(changing_list, math.random(#changing_list))
  assertEquals(list_copy, list, 'sublist first-last simple copy check')
  assertEquals(list_sublist_from_start_from_end(list, 2, 2), {'Challenger', 'Discovery', 'Atlantis'}, 'sublist # #-end simple')
  assertEquals(list_sublist_from_end_from_start(list, 3, 4), {'Discovery', 'Atlantis'}, 'sublist #-end # simple')
  assertEquals(list_sublist_first_from_start(list, 4), {'Columbia', 'Challenger', 'Discovery', 'Atlantis'}, 'sublist first # simple')
  assertEquals(list_sublist_first_from_end(list, 4), {'Columbia', 'Challenger'}, 'sublist first #-end simple')
  assertEquals(list_sublist_from_start_last(list, 4), {'Atlantis', 'Endeavour'}, 'sublist # last simple')
  assertEquals(list_sublist_from_end_last(list, 4), {'Challenger', 'Discovery', 'Atlantis', 'Endeavour'}, 'sublist #-end last simple')
  assertEquals(list_sublist_from_start_from_end(list, 1, 1), list, 'sublist all with # #-end simple')
  assertEquals(list_sublist_from_end_from_start(list, 5, 5), list, 'sublist all with #-end # simple')
  -- Checks that the whole list is properly retrieved even if the value for start and end is not a simple number. This is especially important in generators where sublist uses [x:length - y] for # #-end.
  assertEquals(list_sublist_from_start_from_end(list, 0 + 1, 0 + 1), list, 'sublist all with # #-end math simple')
end


-- Creates a list for use with the sublist test.
function get_space_shuttles()
  number_of_calls = number_of_calls + 1
  return {'Columbia', 'Challenger', 'Discovery', 'Atlantis', 'Endeavour'}
end


-- Tests the "get sub-list" block with a function call.
function test_sublist_complex()
  number_of_calls = 0
  assertEquals(list_sublist_from_start_from_start(get_space_shuttles(), 2, 3), {'Challenger', 'Discovery'}, 'sublist # start complex')
  check_number_of_calls('sublist # start complex')
  number_of_calls = 0
  assertEquals(list_sublist_from_start_from_start(true and get_space_shuttles() or nil, true and 2 or nil, true and 3 or nil), {'Challenger', 'Discovery'}, 'sublist # start order complex')
  check_number_of_calls('sublist # start order complex')
  number_of_calls = 0
  -- The order for index for #-end is addition because this will catch errors in generators where most perform the operation ... - index.
  assertEquals(list_sublist_from_end_from_end(get_space_shuttles(), 3, 2), {'Discovery', 'Atlantis'}, 'sublist # end complex')
  assertEquals(number_of_calls, 1, 'sublist # end complex number of calls')
  number_of_calls = 0
  assertEquals(list_sublist_from_end_from_end(true and get_space_shuttles() or nil, 0 + 3, 0 + 2), {'Discovery', 'Atlantis'}, 'sublist # end order complex')
  check_number_of_calls('sublist # end order complex')
  number_of_calls = 0
  assertEquals(list_sublist_first_last(get_space_shuttles()), list, 'sublist first-last complex')
  check_number_of_calls('sublist first-last complex')
  number_of_calls = 0
  assertEquals(list_sublist_from_start_from_end(get_space_shuttles(), 2, 2), {'Challenger', 'Discovery', 'Atlantis'}, 'sublist # #-end complex')
  check_number_of_calls('sublist # #-end complex')
  number_of_calls = 0
  assertEquals(list_sublist_from_end_from_start(get_space_shuttles(), 3, 4), {'Discovery', 'Atlantis'}, 'sublist #-end # complex')
  check_number_of_calls('sublist #-end # complex')
  number_of_calls = 0
  assertEquals(list_sublist_first_from_start(get_space_shuttles(), 4), {'Columbia', 'Challenger', 'Discovery', 'Atlantis'}, 'sublist first # complex')
  check_number_of_calls('sublist first # complex')
  number_of_calls = 0
  assertEquals(list_sublist_first_from_end(get_space_shuttles(), 4), {'Columbia', 'Challenger'}, 'sublist first #-end complex')
  check_number_of_calls('sublist first #-end complex')
  number_of_calls = 0
  assertEquals(list_sublist_from_start_last(get_space_shuttles(), 4), {'Atlantis', 'Endeavour'}, 'sublist # last complex')
  check_number_of_calls('sublist # last complex')
  number_of_calls = 0
  assertEquals(list_sublist_from_end_last(get_space_shuttles(), 4), {'Challenger', 'Discovery', 'Atlantis', 'Endeavour'}, 'sublist #-end last simple')
  check_number_of_calls('sublist #-end last simple')
  number_of_calls = 0
  assertEquals(list_sublist_from_start_from_end(get_space_shuttles(), 1, 1), list, 'sublist all with # #-end complex')
  check_number_of_calls('sublist all with # #-end complex')
  number_of_calls = 0
  assertEquals(list_sublist_from_end_from_start(get_space_shuttles(), 5, 5), list, 'sublist all with #-end # complex')
  check_number_of_calls('sublist all with #-end # complex')
  number_of_calls = 0
  -- Checks that the whole list is properly retrieved even if the value for start and end is not a simple number. This is especially important in generators where sublist uses [x:length - y] for # #-end.
  assertEquals(list_sublist_from_start_from_end(get_space_shuttles(), 0 + 1, 0 + 1), list, 'sublist all with # #-end math complex')
  check_number_of_calls('sublist all with # #-end math complex')
end


-- Tests the "join" block.
function test_join()
  list = {'Vulcan', 'Klingon', 'Borg'}
  assertEquals(table.concat(list, ','), 'Vulcan,Klingon,Borg', 'join')
  assertEquals(table.concat(true and list or nil, ','), 'Vulcan,Klingon,Borg', 'join order')
end


function list_string_split(input, delim)
  local t = {}
  local pos = 1
  while true do
    next_delim = string.find(input, delim, pos)
    if next_delim == nil then
      table.insert(t, string.sub(input, pos))
      break
    else
      table.insert(t, string.sub(input, pos, next_delim-1))
      pos = next_delim + #delim
    end
  end
  return t
end

-- Tests the "split" block.
function test_split()
  text = 'Vulcan,Klingon,Borg'
  assertEquals(list_string_split(text, ','), {'Vulcan', 'Klingon', 'Borg'}, 'split')
  assertEquals(list_string_split(true and text or nil, ','), {'Vulcan', 'Klingon', 'Borg'}, 'split order')
end


function list_sort(list, typev, direction)
  local t = {}
  for n,v in pairs(list) do table.insert(t, v) end
  local compareFuncs = {
    NUMERIC = function(a, b)
      return (tonumber(tostring(a)) or 0)
          < (tonumber(tostring(b)) or 0) end,
    TEXT = function(a, b)
      return tostring(a) < tostring(b) end,
    IGNORE_CASE = function(a, b)
      return string.lower(tostring(a)) < string.lower(tostring(b)) end
  }
  local compareTemp = compareFuncs[typev]
  local compare = compareTemp
  if direction == -1
  then compare = function(a, b) return compareTemp(b, a) end
  end
  table.sort(t, compare)
  return t
end

-- Tests the "alphabetic sort" block.
function test_sort_alphabetic()
  list = {'Vulcan', 'klingon', 'Borg'}
  assertEquals(list_sort(list,"TEXT", 1), {'Borg', 'Vulcan', 'klingon'}, 'sort alphabetic ascending')
  assertEquals(list_sort(true and list or nil,"TEXT", 1), {'Borg', 'Vulcan', 'klingon'}, 'sort alphabetic ascending order')
end


-- Tests the "alphabetic sort ignore case" block.
function test_sort_ignoreCase()
  list = {'Vulcan', 'klingon', 'Borg'}
  assertEquals(list_sort(list,"IGNORE_CASE", 1), {'Borg', 'klingon', 'Vulcan'}, 'sort ignore case ascending')
  assertEquals(list_sort(true and list or nil,"IGNORE_CASE", 1), {'Borg', 'klingon', 'Vulcan'}, 'sort ignore case ascending order')
end


-- Tests the "numeric sort" block.
function test_sort_numeric()
  list = {8, 18, -1}
  assertEquals(list_sort(list,"NUMERIC", -1), {18, 8, -1}, 'sort numeric descending')
  assertEquals(list_sort(true and list or nil,"NUMERIC", -1), {18, 8, -1}, 'sort numeric descending order')
end


function list_reverse(input)
  local reversed = {}
  for i = #input, 1, -1 do
    table.insert(reversed, input[i])
  end
  return reversed
end

-- Tests the "list reverse" block.
function test_lists_reverse()
  list = {8, 18, -1, 64}
  assertEquals(list_reverse(list), {64, -1, 18, 8}, 'reverse a copy')
  assertEquals(list, {8, 18, -1, 64}, 'reverse a copy original')
  list = {}
  assertEquals(list_reverse(list), {}, 'empty list')
end


-- Describe this function...
function test_procedure()
  procedure_1(8, 2)
  assertEquals(proc_z, 4, 'procedure with global')
  proc_w = false
  procedure_2(false)
  assertEquals(proc_w, true, 'procedure no return')
  proc_w = false
  procedure_2(true)
  assertEquals(proc_w, false, 'procedure return')
end


-- Describe this function...
function procedure_1(proc_x, proc_y)
  proc_z = proc_x / proc_y
end


-- Describe this function...
function procedure_2(proc_x)
  if proc_x then
    return
  end
  proc_w = true
end


-- Describe this function...
function test_function()
  assertEquals(function_1(2, 3), -1, 'function with arguments')
  assertEquals(func_z, 'side effect', 'function with side effect')
  func_a = 'unchanged'
  func_c = 'global'
  assertEquals(function_2(2), '3global', 'function with global')
  assertEquals(func_a, 'unchanged', 'function with scope')
  assertEquals(function_3(true), true, 'function return')
  assertEquals(function_3(false), false, 'function no return')
end


-- Describe this function...
function function_1(func_x, func_y)
  func_z = 'side effect'
  return func_x - func_y
end


-- Describe this function...
function function_2(func_a)
  func_a = func_a + 1
  return func_a .. func_c
end


-- Describe this function...
function function_3(func_a)
  if func_a then
    return true
  end
  return false
end


-- Describe this function...
function recurse(n)
  if n > 0 then
    text = table.concat({recurse(n - 1), n, recurse(n - 1)})
  else
    text = '-'
  end
  return text
end



unittestResults = {}
print('\n====================\n\nRunning suite: Logic')
assertEquals(true, true, 'True')
assertEquals(false, false, 'False')
assertEquals(not false, true, 'Not true')
assertEquals(not true, false, 'Not false')
test_if()
test_ifelse()
test_equalities()
test_and()
test_or()
test_ternary()
print(unittest_report())
unittestResults = nil

unittestResults = {}
print('\n====================\n\nRunning suite: Loops 1')
test_repeat()
test_repeat_ext()
test_while()
test_foreach()
print(unittest_report())
unittestResults = nil

unittestResults = {}
print('\n====================\n\nRunning suite: Loops 2')
test_count_loops()
test_count_by()
print(unittest_report())
unittestResults = nil

unittestResults = {}
print('\n====================\n\nRunning suite: Loops 3')
test_break()
test_continue()
print(unittest_report())
unittestResults = nil

unittestResults = {}
print('\n====================\n\nRunning suite: Math')
test_arithmetic()
test_single()
test_trig()
test_constant()
test_change()
test_number_properties()
test_round()
test_operations_on_list()
test_constraint()
test_mod()
test_random_integer()
test_random_fraction()
test_atan2()
print(unittest_report())
unittestResults = nil

unittestResults = {}
print('\n====================\n\nRunning suite: Text')
test_text_length()
test_empty_text()
test_create_text()
test_append()
test_find_text_simple()
test_find_text_complex()
test_get_text_simple()
test_get_text_complex()
test_substring_simple()
test_substring_complex()
test_case()
test_trim()
test_count_text()
test_text_reverse()
test_replace()
print(unittest_report())
unittestResults = nil

unittestResults = {}
print('\n====================\n\nRunning suite: Lists')
test_create_lists()
test_lists_empty()
test_lists_length()
test_find_lists_simple()
test_find_lists_complex()
test_get_lists_simple()
test_get_lists_create_list()
test_get_lists_complex()
test_getRemove()
test_remove()
test_set()
test_insert()
test_sublist_simple()
test_sublist_complex()
test_join()
test_split()
test_sort_alphabetic()
test_sort_ignoreCase()
test_sort_numeric()
test_lists_reverse()
print(unittest_report())
unittestResults = nil

unittestResults = {}
print('\n====================\n\nRunning suite: Variables')
item = 123
assertEquals(item, 123, 'variable')
if2 = 123
assertEquals(if2, 123, 'reserved variable')
print(unittest_report())
unittestResults = nil

local _ = -- Intentionally non-connected variable.
naked

unittestResults = {}
print('\n====================\n\nRunning suite: Functions')
test_procedure()
test_function()
assertEquals(recurse(3), '-1-2-1-3-1-2-1-', 'test recurse')
print(unittest_report())
unittestResults = nil