scratch-blocks 1.1.206 → 2.0.0-beta.1

package/blockly-rc/tests/generators/golden/generated.lua

@@ -0,0 +1,1828 @@
+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