scratch-blocks 1.1.206 → 2.0.0-beta.1

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

@@ -0,0 +1,1407 @@
+from numbers import Number
+import math
+import random
+import sys
+
+unittestResults = None
+test_name = None
+naked = None
+proc_x = None
+proc_y = None
+func_x = None
+func_y = None
+func_a = None
+n = None
+ok = None
+log = None
+count = None
+varToChange = None
+rand = None
+item = None
+text = None
+number_of_calls = None
+list2 = None
+proc_z = None
+func_z = None
+x = None
+proc_w = None
+func_c = None
+if2 = None
+loglist = None
+changing_list = None
+list_copy = None
+
+def unittest_report():
+  # Create test report.
+  report = []
+  summary = []
+  fails = 0
+  for (success, log, message) in unittestResults:
+    if success:
+      summary.append(".")
+    else:
+      summary.append("F")
+      fails += 1
+      report.append("")
+      report.append("FAIL: " + message)
+      report.append(log)
+  report.insert(0, "".join(summary))
+  report.append("")
+  report.append("Number of tests run: %d" % len(unittestResults))
+  report.append("")
+  if fails:
+    report.append("FAILED (failures=%d)" % fails)
+  else:
+    report.append("OK")
+  return "\n".join(report)
+
+def assertEquals(actual, expected, message):
+  # Asserts that a value equals another value.
+  if unittestResults == None:
+    raise Exception("Orphaned assert equals: " + message)
+  if actual == expected:
+    unittestResults.append((True, "OK", message))
+  else:
+    unittestResults.append((False, "Expected: %s\nActual: %s" % (expected, actual), message))
+
+def fail(message):
+  # Always assert an error.
+  if unittestResults == None:
+    raise Exception("Orphaned assert equals: " + message)
+  unittestResults.append((False, "Fail.", message))
+
+# Describe this function...
+def test_if():
+  global test_name, naked, proc_x, proc_y, func_x, func_y, func_a, n, ok, log, count, varToChange, rand, item, text, number_of_calls, list2, proc_z, func_z, x, proc_w, func_c, if2, loglist, changing_list, list_copy, unittestResults
+  if False:
+    fail('if false')
+  ok = False
+  if True:
+    ok = True
+  assertEquals(ok, True, 'if true')
+  ok = False
+  if False:
+    fail('if/else false')
+  else:
+    ok = True
+  assertEquals(ok, True, 'if/else false')
+  ok = False
+  if True:
+    ok = True
+  else:
+    fail('if/else true')
+  assertEquals(ok, True, 'if/else true')
+  ok = False
+  if False:
+    fail('elseif 1')
+  elif True:
+    ok = True
+  elif True:
+    fail('elseif 2')
+  else:
+    fail('elseif 3')
+  assertEquals(ok, True, 'elseif 4')
+
+# Describe this function...
+def test_ifelse():
+  global test_name, naked, proc_x, proc_y, func_x, func_y, func_a, n, ok, log, count, varToChange, rand, item, text, number_of_calls, list2, proc_z, func_z, x, proc_w, func_c, if2, loglist, changing_list, list_copy, unittestResults
+  ok = False
+  if True:
+    ok = True
+  else:
+    fail('ifelse true')
+  assertEquals(ok, True, 'ifelse true')
+  ok = False
+  if False:
+    fail('ifelse false')
+  else:
+    ok = True
+  assertEquals(ok, True, 'ifelse false')
+
+# Describe this function...
+def test_equalities():
+  global test_name, naked, proc_x, proc_y, func_x, func_y, func_a, n, ok, log, count, varToChange, rand, item, text, number_of_calls, list2, proc_z, func_z, x, proc_w, func_c, if2, loglist, changing_list, list_copy, unittestResults
+  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')
+
+# Describe this function...
+def test_and():
+  global test_name, naked, proc_x, proc_y, func_x, func_y, func_a, n, ok, log, count, varToChange, rand, item, text, number_of_calls, list2, proc_z, func_z, x, proc_w, func_c, if2, loglist, changing_list, list_copy, unittestResults
+  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')
+
+# Describe this function...
+def test_or():
+  global test_name, naked, proc_x, proc_y, func_x, func_y, func_a, n, ok, log, count, varToChange, rand, item, text, number_of_calls, list2, proc_z, func_z, x, proc_w, func_c, if2, loglist, changing_list, list_copy, unittestResults
+  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')
+
+# Describe this function...
+def test_ternary():
+  global test_name, naked, proc_x, proc_y, func_x, func_y, func_a, n, ok, log, count, varToChange, rand, item, text, number_of_calls, list2, proc_z, func_z, x, proc_w, func_c, if2, loglist, changing_list, list_copy, unittestResults
+  assertEquals(42 if True else 99, 42, 'if true')
+  assertEquals(42 if False else 99, 99, 'if true')
+
+# Describe this function...
+def test_foreach():
+  global test_name, naked, proc_x, proc_y, func_x, func_y, func_a, n, ok, log, count, varToChange, rand, item, text, number_of_calls, list2, proc_z, func_z, x, proc_w, func_c, if2, loglist, changing_list, list_copy, unittestResults
+  log = ''
+  for x in ['a', 'b', 'c']:
+    log = str(log) + str(x)
+  assertEquals(log, 'abc', 'for loop')
+
+# Describe this function...
+def test_repeat():
+  global test_name, naked, proc_x, proc_y, func_x, func_y, func_a, n, ok, log, count, varToChange, rand, item, text, number_of_calls, list2, proc_z, func_z, x, proc_w, func_c, if2, loglist, changing_list, list_copy, unittestResults
+  count = 0
+  for count2 in range(10):
+    count = (count if isinstance(count, Number) else 0) + 1
+  assertEquals(count, 10, 'repeat 10')
+
+# Describe this function...
+def test_while():
+  global test_name, naked, proc_x, proc_y, func_x, func_y, func_a, n, ok, log, count, varToChange, rand, item, text, number_of_calls, list2, proc_z, func_z, x, proc_w, func_c, if2, loglist, changing_list, list_copy, unittestResults
+  while False:
+    fail('while 0')
+  while not True:
+    fail('until 0')
+  count = 1
+  while count != 10:
+    count = (count if isinstance(count, Number) else 0) + 1
+  assertEquals(count, 10, 'while 10')
+  count = 1
+  while not count == 10:
+    count = (count if isinstance(count, Number) else 0) + 1
+  assertEquals(count, 10, 'until 10')
+
+# Describe this function...
+def test_repeat_ext():
+  global test_name, naked, proc_x, proc_y, func_x, func_y, func_a, n, ok, log, count, varToChange, rand, item, text, number_of_calls, list2, proc_z, func_z, x, proc_w, func_c, if2, loglist, changing_list, list_copy, unittestResults
+  count = 0
+  for count3 in range(10):
+    count = (count if isinstance(count, Number) else 0) + 1
+  assertEquals(count, 10, 'repeat 10')
+
+def upRange(start, stop, step):
+  while start <= stop:
+    yield start
+    start += abs(step)
+
+def downRange(start, stop, step):
+  while start >= stop:
+    yield start
+    start -= abs(step)
+
+# Describe this function...
+def test_count_by():
+  global test_name, naked, proc_x, proc_y, func_x, func_y, func_a, n, ok, log, count, varToChange, rand, item, text, number_of_calls, list2, proc_z, func_z, x, proc_w, func_c, if2, loglist, changing_list, list_copy, unittestResults
+  log = ''
+  for x in range(1, 9, 2):
+    log = str(log) + str(x)
+  assertEquals(log, '1357', 'count up ints')
+  log = ''
+  for x in range(8, 0, -2):
+    log = str(log) + str(x)
+  assertEquals(log, '8642', 'count down ints')
+  loglist = []
+  for x in upRange(1, 8, 1.5):
+    loglist.append(x)
+  assertEquals(loglist, [1, 2.5, 4, 5.5, 7], 'count with floats')
+  loglist = []
+  x_start = 1 + 0
+  x_end = 8 + 0
+  x_inc = 1 - 2
+  for x in (x_start <= x_end) and upRange(x_start, x_end, x_inc) or downRange(x_start, x_end, x_inc):
+    loglist.append(x)
+  assertEquals(loglist, [1, 2, 3, 4, 5, 6, 7, 8], 'count up non-trivial ints')
+  loglist = []
+  x_start2 = 8 + 0
+  x_end2 = 1 + 0
+  for x in (x_start2 <= x_end2) and upRange(x_start2, x_end2, 2) or downRange(x_start2, x_end2, 2):
+    loglist.append(x)
+  assertEquals(loglist, [8, 6, 4, 2], 'count down non-trivial ints')
+  loglist = []
+  x_start3 = 5 + 0.5
+  x_end3 = 1 + 0
+  x_inc2 = 1 + 0
+  for x in (x_start3 <= x_end3) and upRange(x_start3, x_end3, x_inc2) or downRange(x_start3, x_end3, x_inc2):
+    loglist.append(x)
+  assertEquals(loglist, [5.5, 4.5, 3.5, 2.5, 1.5], 'count with floats')
+
+# Describe this function...
+def test_count_loops():
+  global test_name, naked, proc_x, proc_y, func_x, func_y, func_a, n, ok, log, count, varToChange, rand, item, text, number_of_calls, list2, proc_z, func_z, x, proc_w, func_c, if2, loglist, changing_list, list_copy, unittestResults
+  log = ''
+  for x in range(1, 9):
+    log = str(log) + str(x)
+  assertEquals(log, '12345678', 'count up')
+  log = ''
+  for x in range(8, 0, -1):
+    log = str(log) + str(x)
+  assertEquals(log, '87654321', 'count down')
+  loglist = []
+  x_start4 = 1 + 0
+  x_end4 = 4 + 0
+  for x in (x_start4 <= x_end4) and upRange(x_start4, x_end4, 1) or downRange(x_start4, x_end4, 1):
+    loglist.append(x)
+  assertEquals(loglist, [1, 2, 3, 4], 'count up non-trivial')
+  loglist = []
+  x_start5 = 3 + 1
+  x_end5 = 1 + 0
+  for x in (x_start5 <= x_end5) and upRange(x_start5, x_end5, 1) or downRange(x_start5, x_end5, 1):
+    loglist.append(x)
+  assertEquals(loglist, [4, 3, 2, 1], 'count down non-trivial')
+
+# Describe this function...
+def test_continue():
+  global test_name, naked, proc_x, proc_y, func_x, func_y, func_a, n, ok, log, count, varToChange, rand, item, text, number_of_calls, list2, proc_z, func_z, x, proc_w, func_c, if2, loglist, changing_list, list_copy, unittestResults
+  log = ''
+  count = 0
+  while count != 8:
+    count = (count if isinstance(count, Number) else 0) + 1
+    if count == 5:
+      continue
+    log = str(log) + str(count)
+  assertEquals(log, '1234678', 'while continue')
+  log = ''
+  count = 0
+  while not count == 8:
+    count = (count if isinstance(count, Number) else 0) + 1
+    if count == 5:
+      continue
+    log = str(log) + str(count)
+  assertEquals(log, '1234678', 'until continue')
+  log = ''
+  for x in range(1, 9):
+    if x == 5:
+      continue
+    log = str(log) + str(x)
+  assertEquals(log, '1234678', 'count continue')
+  log = ''
+  for x in ['a', 'b', 'c', 'd']:
+    if x == 'c':
+      continue
+    log = str(log) + str(x)
+  assertEquals(log, 'abd', 'for continue')
+
+# Describe this function...
+def test_break():
+  global test_name, naked, proc_x, proc_y, func_x, func_y, func_a, n, ok, log, count, varToChange, rand, item, text, number_of_calls, list2, proc_z, func_z, x, proc_w, func_c, if2, loglist, changing_list, list_copy, unittestResults
+  count = 1
+  while count != 10:
+    if count == 5:
+      break
+    count = (count if isinstance(count, Number) else 0) + 1
+  assertEquals(count, 5, 'while break')
+  count = 1
+  while not count == 10:
+    if count == 5:
+      break
+    count = (count if isinstance(count, Number) else 0) + 1
+  assertEquals(count, 5, 'until break')
+  log = ''
+  for x in range(1, 9):
+    if x == 5:
+      break
+    log = str(log) + str(x)
+  assertEquals(log, '1234', 'count break')
+  log = ''
+  for x in ['a', 'b', 'c', 'd']:
+    if x == 'c':
+      break
+    log = str(log) + str(x)
+  assertEquals(log, 'ab', 'for break')
+
+# Tests the "single" block.
+def test_single():
+  global test_name, naked, proc_x, proc_y, func_x, func_y, func_a, n, ok, log, count, varToChange, rand, item, text, number_of_calls, list2, proc_z, func_z, x, proc_w, func_c, if2, loglist, changing_list, list_copy, unittestResults
+  assertEquals(math.sqrt(25), 5, 'sqrt')
+  assertEquals(math.fabs(-25), 25, 'abs')
+  assertEquals(-(-25), 25, 'negate')
+  assertEquals(math.log(1), 0, 'ln')
+  assertEquals(math.log10(100), 2, 'log10')
+  assertEquals(math.exp(2), 7.38905609893065, 'exp')
+  assertEquals(math.pow(10,2), 100, 'power10')
+
+# Tests the "arithmetic" block for all operations and checks
+# parenthesis are properly generated for different orders.
+def test_arithmetic():
+  global test_name, naked, proc_x, proc_y, func_x, func_y, func_a, n, ok, log, count, varToChange, rand, item, text, number_of_calls, list2, proc_z, func_z, x, proc_w, func_c, if2, loglist, changing_list, list_copy, unittestResults
+  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')
+
+# Tests the "trig" block.
+def test_trig():
+  global test_name, naked, proc_x, proc_y, func_x, func_y, func_a, n, ok, log, count, varToChange, rand, item, text, number_of_calls, list2, proc_z, func_z, x, proc_w, func_c, if2, loglist, changing_list, list_copy, unittestResults
+  assertEquals(math.sin(90 / 180.0 * math.pi), 1, 'sin')
+  assertEquals(math.cos(180 / 180.0 * math.pi), -1, 'cos')
+  assertEquals(math.tan(0 / 180.0 * math.pi), 0, 'tan')
+  assertEquals(math.asin(-1) / math.pi * 180, -90, 'asin')
+  assertEquals(math.acos(1) / math.pi * 180, 0, 'acos')
+  assertEquals(math.atan(1) / math.pi * 180, 45, 'atan')
+
+# Tests the "constant" blocks.
+def test_constant():
+  global test_name, naked, proc_x, proc_y, func_x, func_y, func_a, n, ok, log, count, varToChange, rand, item, text, number_of_calls, list2, proc_z, func_z, x, proc_w, func_c, if2, loglist, changing_list, list_copy, unittestResults
+  assertEquals(math.floor(math.pi * 1000), 3141, 'const pi')
+  assertEquals(math.floor(math.e * 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.0 / 2) * 1000), 707, 'const sqrt 0.5')
+  assertEquals(9999 < float('inf'), True, 'const infinity')
+
+def math_isPrime(n):
+  # https://en.wikipedia.org/wiki/Primality_test#Naive_methods
+  # If n is not a number but a string, try parsing it.
+  if not isinstance(n, Number):
+    try:
+      n = float(n)
+    except:
+      return False
+  if n == 2 or n == 3:
+    return True
+  # False if n is negative, is 1, or not whole, or if n is divisible by 2 or 3.
+  if n <= 1 or n % 1 != 0 or n % 2 == 0 or n % 3 == 0:
+    return False
+  # Check all the numbers of form 6k +/- 1, up to sqrt(n).
+  for x in range(6, int(math.sqrt(n)) + 2, 6):
+    if n % (x - 1) == 0 or n % (x + 1) == 0:
+      return False
+  return True
+
+# Tests the "number property" blocks.
+def test_number_properties():
+  global test_name, naked, proc_x, proc_y, func_x, func_y, func_a, n, ok, log, count, varToChange, rand, item, text, number_of_calls, list2, proc_z, func_z, x, proc_w, func_c, if2, loglist, changing_list, list_copy, unittestResults
+  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(float('inf') > 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 False, True, 'divisible by 0')
+
+# Tests the "round" block.
+def test_round():
+  global test_name, naked, proc_x, proc_y, func_x, func_y, func_a, n, ok, log, count, varToChange, rand, item, text, number_of_calls, list2, proc_z, func_z, x, proc_w, func_c, if2, loglist, changing_list, list_copy, unittestResults
+  assertEquals(round(42.42), 42, 'round')
+  assertEquals(math.ceil(-42.42), -42, 'round up')
+  assertEquals(math.floor(42.42), 42, 'round down')
+
+# Tests the "change" block.
+def test_change():
+  global test_name, naked, proc_x, proc_y, func_x, func_y, func_a, n, ok, log, count, varToChange, rand, item, text, number_of_calls, list2, proc_z, func_z, x, proc_w, func_c, if2, loglist, changing_list, list_copy, unittestResults
+  varToChange = 100
+  varToChange = (varToChange if isinstance(varToChange, Number) else 0) + 42
+  assertEquals(varToChange, 142, 'change')
+
+def math_mean(myList):
+  localList = [e for e in myList if isinstance(e, Number)]
+  if not localList: return
+  return float(sum(localList)) / len(localList)
+
+def math_median(myList):
+  localList = sorted([e for e in myList if isinstance(e, Number)])
+  if not localList: return
+  if len(localList) % 2 == 0:
+    return (localList[len(localList) // 2 - 1] + localList[len(localList) // 2]) / 2.0
+  else:
+    return localList[(len(localList) - 1) // 2]
+
+def math_modes(some_list):
+  modes = []
+  # Using a lists of [item, count] to keep count rather than dict
+  # to avoid "unhashable" errors when the counted item is itself a list or dict.
+  counts = []
+  maxCount = 1
+  for item in some_list:
+    found = False
+    for count in counts:
+      if count[0] == item:
+        count[1] += 1
+        maxCount = max(maxCount, count[1])
+        found = True
+    if not found:
+      counts.append([item, 1])
+  for counted_item, item_count in counts:
+    if item_count == maxCount:
+      modes.append(counted_item)
+  return modes
+
+def math_standard_deviation(numbers):
+  n = len(numbers)
+  if n == 0: return
+  mean = float(sum(numbers)) / n
+  variance = sum((x - mean) ** 2 for x in numbers) / n
+  return math.sqrt(variance)
+
+def first_index(my_list, elem):
+  try: index = my_list.index(elem) + 1
+  except: index = 0
+  return index
+
+# Tests the "list operation" blocks.
+def test_operations_on_list():
+  global test_name, naked, proc_x, proc_y, func_x, func_y, func_a, n, ok, log, count, varToChange, rand, item, text, number_of_calls, list2, proc_z, func_z, x, proc_w, func_c, if2, loglist, changing_list, list_copy, unittestResults
+  assertEquals(sum([3, 4, 5]), 12, 'sum')
+  assertEquals(min([3, 4, 5]), 3, 'min')
+  assertEquals(max([3, 4, 5]), 5, 'max')
+  assertEquals(math_mean([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], random.choice([3, 4, 5])) > 0, True, 'random')
+
+# Tests the "mod" block.
+def test_mod():
+  global test_name, naked, proc_x, proc_y, func_x, func_y, func_a, n, ok, log, count, varToChange, rand, item, text, number_of_calls, list2, proc_z, func_z, x, proc_w, func_c, if2, loglist, changing_list, list_copy, unittestResults
+  assertEquals(42 % 5, 2, 'mod')
+
+# Tests the "constrain" block.
+def test_constraint():
+  global test_name, naked, proc_x, proc_y, func_x, func_y, func_a, n, ok, log, count, varToChange, rand, item, text, number_of_calls, list2, proc_z, func_z, x, proc_w, func_c, if2, loglist, changing_list, list_copy, unittestResults
+  assertEquals(min(max(100, 0), 42), 42, 'constraint')
+
+# Tests the "random integer" block.
+def test_random_integer():
+  global test_name, naked, proc_x, proc_y, func_x, func_y, func_a, n, ok, log, count, varToChange, rand, item, text, number_of_calls, list2, proc_z, func_z, x, proc_w, func_c, if2, loglist, changing_list, list_copy, unittestResults
+  rand = random.randint(5, 10)
+  assertEquals(rand >= 5 and rand <= 10, True, 'randRange')
+  assertEquals(rand % 1 == 0, True, 'randInteger')
+
+# Tests the "random fraction" block.
+def test_random_fraction():
+  global test_name, naked, proc_x, proc_y, func_x, func_y, func_a, n, ok, log, count, varToChange, rand, item, text, number_of_calls, list2, proc_z, func_z, x, proc_w, func_c, if2, loglist, changing_list, list_copy, unittestResults
+  rand = random.random()
+  assertEquals(rand >= 0 and rand <= 1, True, 'randFloat')
+
+# Describe this function...
+def test_atan2():
+  global test_name, naked, proc_x, proc_y, func_x, func_y, func_a, n, ok, log, count, varToChange, rand, item, text, number_of_calls, list2, proc_z, func_z, x, proc_w, func_c, if2, loglist, changing_list, list_copy, unittestResults
+  assertEquals(math.atan2(5, -5) / math.pi * 180, 135, 'atan2')
+  assertEquals(math.atan2(-12, 0) / math.pi * 180, -90, 'atan2')
+
+# Checks that the number of calls is one in order
+# to confirm that a function was only called once.
+def check_number_of_calls(test_name):
+  global naked, proc_x, proc_y, func_x, func_y, func_a, n, ok, log, count, varToChange, rand, item, text, number_of_calls, list2, proc_z, func_z, x, proc_w, func_c, if2, loglist, changing_list, list_copy, unittestResults
+  test_name = str(test_name) + 'number of calls'
+  assertEquals(number_of_calls, 1, test_name)
+
+# Tests the "create text with" block with varying number of inputs.
+def test_create_text():
+  global test_name, naked, proc_x, proc_y, func_x, func_y, func_a, n, ok, log, count, varToChange, rand, item, text, number_of_calls, list2, proc_z, func_z, x, proc_w, func_c, if2, loglist, changing_list, list_copy, unittestResults
+  assertEquals('', '', 'no text')
+  assertEquals('Hello', 'Hello', 'create single')
+  assertEquals(str(-1), '-1', 'create single number')
+  assertEquals('K' + str(9), 'K9', 'create double text')
+  assertEquals(str(4) + str(2), '42', 'create double text numbers')
+  assertEquals(''.join([str(x2) for x2 in [1, 2, 3]]), '123', 'create triple')
+  assertEquals(''.join([str(x3) for x3 in [1, 0 if True else None, 'M']]), '10M', 'create order')
+
+# Creates an empty string for use with the empty test.
+def get_empty():
+  global test_name, naked, proc_x, proc_y, func_x, func_y, func_a, n, ok, log, count, varToChange, rand, item, text, number_of_calls, list2, proc_z, func_z, x, proc_w, func_c, if2, loglist, changing_list, list_copy, unittestResults
+  return ''
+
+# Tests the "is empty" block".
+def test_empty_text():
+  global test_name, naked, proc_x, proc_y, func_x, func_y, func_a, n, ok, log, count, varToChange, rand, item, text, number_of_calls, list2, proc_z, func_z, x, proc_w, func_c, if2, loglist, changing_list, list_copy, unittestResults
+  assertEquals(not len('Google'), False, 'not empty')
+  assertEquals(not len(''), True, 'empty')
+  assertEquals(not len(get_empty()), True, 'empty complex')
+  assertEquals(not len('' if True else None), True, 'empty order')
+
+# Tests the "length" block.
+def test_text_length():
+  global test_name, naked, proc_x, proc_y, func_x, func_y, func_a, n, ok, log, count, varToChange, rand, item, text, number_of_calls, list2, proc_z, func_z, x, proc_w, func_c, if2, loglist, changing_list, list_copy, unittestResults
+  assertEquals(len(''), 0, 'zero length')
+  assertEquals(len('Google'), 6, 'non-zero length')
+  assertEquals(len('car' if True else None), 3, 'length order')
+
+# Tests the "append text" block with different types of parameters.
+def test_append():
+  global test_name, naked, proc_x, proc_y, func_x, func_y, func_a, n, ok, log, count, varToChange, rand, item, text, number_of_calls, list2, proc_z, func_z, x, proc_w, func_c, if2, loglist, changing_list, list_copy, unittestResults
+  item = 'Miserable'
+  item = str(item) + 'Failure'
+  assertEquals(item, 'MiserableFailure', 'append text')
+  item = 12
+  item = str(item) + str(34)
+  assertEquals(item, '1234', 'append number')
+  item = 'Something '
+  item = str(item) + str('Positive' if True else None)
+  assertEquals(item, 'Something Positive', 'append order')
+
+# Tests the "find" block with a variable.
+def test_find_text_simple():
+  global test_name, naked, proc_x, proc_y, func_x, func_y, func_a, n, ok, log, count, varToChange, rand, item, text, number_of_calls, list2, proc_z, func_z, x, proc_w, func_c, if2, loglist, changing_list, list_copy, unittestResults
+  text = 'Banana'
+  assertEquals(text.find('an') + 1, 2, 'find first simple')
+  assertEquals(text.rfind('an') + 1, 4, 'find last simple')
+  assertEquals(text.find('Peel') + 1, 0, 'find none simple')
+
+# Creates a string for use with the find test.
+def get_fruit():
+  global test_name, naked, proc_x, proc_y, func_x, func_y, func_a, n, ok, log, count, varToChange, rand, item, text, number_of_calls, list2, proc_z, func_z, x, proc_w, func_c, if2, loglist, changing_list, list_copy, unittestResults
+  number_of_calls = (number_of_calls if isinstance(number_of_calls, Number) else 0) + 1
+  return 'Banana'
+
+# Tests the "find" block with a function call.
+def test_find_text_complex():
+  global test_name, naked, proc_x, proc_y, func_x, func_y, func_a, n, ok, log, count, varToChange, rand, item, text, number_of_calls, list2, proc_z, func_z, x, proc_w, func_c, if2, loglist, changing_list, list_copy, unittestResults
+  number_of_calls = 0
+  assertEquals(get_fruit().find('an') + 1, 2, 'find first complex')
+  check_number_of_calls('find first complex')
+  number_of_calls = 0
+  assertEquals((get_fruit() if True else None).find('an') + 1, 2, 'find first order complex')
+  check_number_of_calls('find first order complex')
+  number_of_calls = 0
+  assertEquals(get_fruit().rfind('an') + 1, 4, 'find last complex')
+  check_number_of_calls('find last complex')
+  number_of_calls = 0
+  assertEquals((get_fruit() if True else None).rfind('an') + 1, 4, 'find last order complex')
+  check_number_of_calls('find last order complex')
+  number_of_calls = 0
+  assertEquals(get_fruit().find('Peel') + 1, 0, 'find none complex')
+  check_number_of_calls('find none complex')
+  number_of_calls = 0
+  assertEquals((get_fruit() if True else None).find('Peel') + 1, 0, 'find none order complex')
+  check_number_of_calls('find none order complex')
+
+def text_random_letter(text):
+  x = int(random.random() * len(text))
+  return text[x]
+
+# Tests the "get letter" block with a variable.
+def test_get_text_simple():
+  global test_name, naked, proc_x, proc_y, func_x, func_y, func_a, n, ok, log, count, varToChange, rand, item, text, number_of_calls, list2, proc_z, func_z, x, proc_w, func_c, if2, loglist, changing_list, list_copy, unittestResults
+  text = 'Blockly'
+  assertEquals(text[0], 'B', 'get first simple')
+  assertEquals(text[-1], 'y', 'get last simple')
+  assertEquals(text.find(text_random_letter(text)) + 1 > 0, True, 'get random simple')
+  assertEquals(text[2], 'o', 'get # simple')
+  assertEquals(text[int((3 if True else None) - 1)], 'o', 'get # order simple')
+  assertEquals(text[-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[-int(0 + 3)], 'k', 'get #-end order simple')
+
+# Creates a string for use with the get test.
+def get_Blockly():
+  global test_name, naked, proc_x, proc_y, func_x, func_y, func_a, n, ok, log, count, varToChange, rand, item, text, number_of_calls, list2, proc_z, func_z, x, proc_w, func_c, if2, loglist, changing_list, list_copy, unittestResults
+  number_of_calls = (number_of_calls if isinstance(number_of_calls, Number) else 0) + 1
+  return 'Blockly'
+
+# Tests the "get letter" block with a function call.
+def test_get_text_complex():
+  global test_name, naked, proc_x, proc_y, func_x, func_y, func_a, n, ok, log, count, varToChange, rand, item, text, number_of_calls, list2, proc_z, func_z, x, proc_w, func_c, if2, loglist, changing_list, list_copy, unittestResults
+  text = 'Blockly'
+  number_of_calls = 0
+  assertEquals(get_Blockly()[0], 'B', 'get first complex')
+  check_number_of_calls('get first complex')
+  number_of_calls = 0
+  assertEquals((get_Blockly() if True else None)[0], 'B', 'get first order complex')
+  check_number_of_calls('get first order complex')
+  number_of_calls = 0
+  assertEquals(get_Blockly()[-1], 'y', 'get last complex')
+  check_number_of_calls('get last complex')
+  number_of_calls = 0
+  assertEquals((get_Blockly() if True else None)[-1], 'y', 'get last order complex')
+  check_number_of_calls('get last order complex')
+  number_of_calls = 0
+  assertEquals(text.find(text_random_letter(get_Blockly())) + 1 > 0, True, 'get random complex')
+  check_number_of_calls('get random complex')
+  number_of_calls = 0
+  assertEquals(text.find(text_random_letter(get_Blockly() if True else None)) + 1 > 0, True, 'get random order complex')
+  check_number_of_calls('get random order complex')
+  number_of_calls = 0
+  assertEquals(get_Blockly()[2], 'o', 'get # complex')
+  check_number_of_calls('get # complex')
+  number_of_calls = 0
+  assertEquals((get_Blockly() if True else None)[int((3 if True else None) - 1)], 'o', 'get # order complex')
+  check_number_of_calls('get # order complex')
+  number_of_calls = 0
+  assertEquals(get_Blockly()[-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((get_Blockly() if True else None)[-int(0 + 3)], 'k', 'get #-end order complex')
+  check_number_of_calls('get #-end order complex')
+
+# Creates a string for use with the substring test.
+def get_numbers():
+  global test_name, naked, proc_x, proc_y, func_x, func_y, func_a, n, ok, log, count, varToChange, rand, item, text, number_of_calls, list2, proc_z, func_z, x, proc_w, func_c, if2, loglist, changing_list, list_copy, unittestResults
+  number_of_calls = (number_of_calls if isinstance(number_of_calls, Number) else 0) + 1
+  return '123456789'
+
+# Tests the "get substring" block with a variable.
+def test_substring_simple():
+  global test_name, naked, proc_x, proc_y, func_x, func_y, func_a, n, ok, log, count, varToChange, rand, item, text, number_of_calls, list2, proc_z, func_z, x, proc_w, func_c, if2, loglist, changing_list, list_copy, unittestResults
+  text = '123456789'
+  assertEquals(text[1 : 3], '23', 'substring # simple')
+  assertEquals(text[int((2 if True else None) - 1) : int(3 if True else None)], '23', 'substring # simple order')
+  assertEquals(text[-3 : -1], '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(text[-int(0 + 3) : -int((0 + 2) - 1) or sys.maxsize], '78', 'substring #-end simple order')
+  assertEquals(text[ : ], text, 'substring first-last simple')
+  assertEquals(text[1 : -1], '2345678', 'substring # #-end simple')
+  assertEquals(text[-7 : 4], '34', 'substring #-end # simple')
+  assertEquals(text[ : 4], '1234', 'substring first # simple')
+  assertEquals(text[ : -1], '12345678', 'substring first #-end simple')
+  assertEquals(text[6 : ], '789', 'substring # last simple')
+  assertEquals(text[-3 : ], '789', 'substring #-end last simple')
+  assertEquals(text[ : ], '123456789', 'substring all with # #-end simple')
+  assertEquals(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(text[int((0 + 1) - 1) : -int((0 + 1) - 1) or sys.maxsize], '123456789', 'substring all with # #-end math simple')
+
+# Tests the "get substring" block with a function call.
+def test_substring_complex():
+  global test_name, naked, proc_x, proc_y, func_x, func_y, func_a, n, ok, log, count, varToChange, rand, item, text, number_of_calls, list2, proc_z, func_z, x, proc_w, func_c, if2, loglist, changing_list, list_copy, unittestResults
+  number_of_calls = 0
+  assertEquals(get_numbers()[1 : 3], '23', 'substring # complex')
+  check_number_of_calls('substring # complex')
+  number_of_calls = 0
+  assertEquals((get_numbers() if True else None)[int((2 if True else None) - 1) : int(3 if True else None)], '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(get_numbers()[-3 : -1], '78', 'substring #-end complex')
+  check_number_of_calls('substring #-end complex')
+  number_of_calls = 0
+  assertEquals((get_numbers() if True else None)[-int(0 + 3) : -int((0 + 2) - 1) or sys.maxsize], '78', 'substring #-end order order')
+  check_number_of_calls('substring #-end order order')
+  number_of_calls = 0
+  assertEquals(get_numbers()[ : ], text, 'substring first-last')
+  check_number_of_calls('substring first-last')
+  number_of_calls = 0
+  assertEquals(get_numbers()[1 : -1], '2345678', 'substring # #-end complex')
+  check_number_of_calls('substring # #-end complex')
+  number_of_calls = 0
+  assertEquals(get_numbers()[-7 : 4], '34', 'substring #-end # complex')
+  check_number_of_calls('substring #-end # complex')
+  number_of_calls = 0
+  assertEquals(get_numbers()[ : 4], '1234', 'substring first # complex')
+  check_number_of_calls('substring first # complex')
+  number_of_calls = 0
+  assertEquals(get_numbers()[ : -1], '12345678', 'substring first #-end complex')
+  check_number_of_calls('substring first #-end complex')
+  number_of_calls = 0
+  assertEquals(get_numbers()[6 : ], '789', 'substring # last complex')
+  check_number_of_calls('substring # last complex')
+  number_of_calls = 0
+  assertEquals(get_numbers()[-3 : ], '789', 'substring #-end last complex')
+  check_number_of_calls('substring #-end last complex')
+  number_of_calls = 0
+  assertEquals(get_numbers()[ : ], '123456789', 'substring all with # #-end complex')
+  check_number_of_calls('substring all with # #-end complex')
+  number_of_calls = 0
+  assertEquals(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(get_numbers()[int((0 + 1) - 1) : -int((0 + 1) - 1) or sys.maxsize], '123456789', 'substring all with # #-end math complex')
+  check_number_of_calls('substring all with # #-end math complex')
+
+# Tests the "change casing" block.
+def test_case():
+  global test_name, naked, proc_x, proc_y, func_x, func_y, func_a, n, ok, log, count, varToChange, rand, item, text, number_of_calls, list2, proc_z, func_z, x, proc_w, func_c, if2, loglist, changing_list, list_copy, unittestResults
+  text = 'Hello World'
+  assertEquals(text.upper(), 'HELLO WORLD', 'uppercase')
+  assertEquals((text if True else None).upper(), 'HELLO WORLD', 'uppercase order')
+  text = 'Hello World'
+  assertEquals(text.lower(), 'hello world', 'lowercase')
+  assertEquals((text if True else None).lower(), 'hello world', 'lowercase order')
+  text = 'heLLo WorlD'
+  assertEquals(text.title(), 'Hello World', 'titlecase')
+  assertEquals((text if True else None).title(), 'Hello World', 'titlecase order')
+
+# Tests the "trim" block.
+def test_trim():
+  global test_name, naked, proc_x, proc_y, func_x, func_y, func_a, n, ok, log, count, varToChange, rand, item, text, number_of_calls, list2, proc_z, func_z, x, proc_w, func_c, if2, loglist, changing_list, list_copy, unittestResults
+  text = '   abc def   '
+  assertEquals(text.strip(), 'abc def', 'trim both')
+  assertEquals((text if True else None).strip(), 'abc def', 'trim both order')
+  assertEquals(text.lstrip(), 'abc def   ', 'trim left')
+  assertEquals((text if True else None).lstrip(), 'abc def   ', 'trim left order')
+  assertEquals(text.rstrip(), '   abc def', 'trim right')
+  assertEquals((text if True else None).rstrip(), '   abc def', 'trim right order')
+
+# Tests the "trim" block.
+def test_count_text():
+  global test_name, naked, proc_x, proc_y, func_x, func_y, func_a, n, ok, log, count, varToChange, rand, item, text, number_of_calls, list2, proc_z, func_z, x, proc_w, func_c, if2, loglist, changing_list, list_copy, unittestResults
+  text = 'woolloomooloo'
+  assertEquals(text.count('o'), 8, 'len 1')
+  assertEquals(text.count('oo'), 4, 'len 2')
+  assertEquals(text.count('loo'), 2, 'len 3')
+  assertEquals(text.count('wool'), 1, 'start')
+  assertEquals(text.count('chicken'), 0, 'missing')
+  assertEquals(text.count(''), 14, 'empty needle')
+  assertEquals(''.count('chicken'), 0, 'empty source')
+
+# Tests the "trim" block.
+def test_text_reverse():
+  global test_name, naked, proc_x, proc_y, func_x, func_y, func_a, n, ok, log, count, varToChange, rand, item, text, number_of_calls, list2, proc_z, func_z, x, proc_w, func_c, if2, loglist, changing_list, list_copy, unittestResults
+  assertEquals(''[::-1], '', 'empty string')
+  assertEquals('a'[::-1], 'a', 'len 1')
+  assertEquals('ab'[::-1], 'ba', 'len 2')
+  assertEquals('woolloomooloo'[::-1], 'ooloomoolloow', 'longer')
+
+# Tests the "trim" block.
+def test_replace():
+  global test_name, naked, proc_x, proc_y, func_x, func_y, func_a, n, ok, log, count, varToChange, rand, item, text, number_of_calls, list2, proc_z, func_z, x, proc_w, func_c, if2, loglist, changing_list, list_copy, unittestResults
+  assertEquals('woolloomooloo'.replace('oo', '123'), 'w123ll123m123l123', 'replace all instances 1')
+  assertEquals('woolloomooloo'.replace('.oo', 'X'), 'woolloomooloo', 'literal string replacement')
+  assertEquals('woolloomooloo'.replace('abc', 'X'), 'woolloomooloo', 'not found')
+  assertEquals('woolloomooloo'.replace('o', ''), 'wllml', 'empty replacement 1')
+  assertEquals('aaaaa'.replace('aaaaa', ''), '', 'empty replacement 2')
+  assertEquals('aaaaa'.replace('a', ''), '', 'empty replacement 3')
+  assertEquals(''.replace('a', 'chicken'), '', 'empty source')
+
+# Checks that the number of calls is one in order
+# to confirm that a function was only called once.
+def check_number_of_calls2(test_name):
+  global naked, proc_x, proc_y, func_x, func_y, func_a, n, ok, log, count, varToChange, rand, item, text, number_of_calls, list2, proc_z, func_z, x, proc_w, func_c, if2, loglist, changing_list, list_copy, unittestResults
+  test_name = str(test_name) + 'number of calls'
+  assertEquals(number_of_calls, 1, test_name)
+
+# Tests the "create list with" and "create empty list" blocks.
+def test_create_lists():
+  global test_name, naked, proc_x, proc_y, func_x, func_y, func_a, n, ok, log, count, varToChange, rand, item, text, number_of_calls, list2, proc_z, func_z, x, proc_w, func_c, if2, loglist, changing_list, list_copy, unittestResults
+  assertEquals([], [], 'create empty')
+  assertEquals([True, 'love'], [True, 'love'], 'create items')
+  assertEquals(['Eject'] * 3, ['Eject', 'Eject', 'Eject'], 'create repeated')
+  assertEquals(['Eject'] * (0 + 3), ['Eject', 'Eject', 'Eject'], 'create repeated order')
+
+# Creates an empty list for use with the empty test.
+def get_empty_list():
+  global test_name, naked, proc_x, proc_y, func_x, func_y, func_a, n, ok, log, count, varToChange, rand, item, text, number_of_calls, list2, proc_z, func_z, x, proc_w, func_c, if2, loglist, changing_list, list_copy, unittestResults
+  return []
+
+# Tests the "is empty" block.
+def test_lists_empty():
+  global test_name, naked, proc_x, proc_y, func_x, func_y, func_a, n, ok, log, count, varToChange, rand, item, text, number_of_calls, list2, proc_z, func_z, x, proc_w, func_c, if2, loglist, changing_list, list_copy, unittestResults
+  assertEquals(not len([0]), False, 'not empty')
+  assertEquals(not len([]), True, 'empty')
+  assertEquals(not len(get_empty_list()), True, 'empty complex')
+  assertEquals(not len([] if True else None), True, 'empty order')
+
+# Tests the "length" block.
+def test_lists_length():
+  global test_name, naked, proc_x, proc_y, func_x, func_y, func_a, n, ok, log, count, varToChange, rand, item, text, number_of_calls, list2, proc_z, func_z, x, proc_w, func_c, if2, loglist, changing_list, list_copy, unittestResults
+  assertEquals(len([]), 0, 'zero length')
+  assertEquals(len(['cat']), 1, 'one length')
+  assertEquals(len(['cat', True, []]), 3, 'three length')
+  assertEquals(len(['cat', True] if True else None), 2, 'two length order')
+
+def last_index(my_list, elem):
+  try: index = len(my_list) - my_list[::-1].index(elem)
+  except: index = 0
+  return index
+
+# Tests the "find" block with a variable.
+def test_find_lists_simple():
+  global test_name, naked, proc_x, proc_y, func_x, func_y, func_a, n, ok, log, count, varToChange, rand, item, text, number_of_calls, list2, proc_z, func_z, x, proc_w, func_c, if2, loglist, changing_list, list_copy, unittestResults
+  list2 = ['Alice', 'Eve', 'Bob', 'Eve']
+  assertEquals(first_index(list2, 'Eve'), 2, 'find first simple')
+  assertEquals(last_index(list2, 'Eve'), 4, 'find last simple')
+  assertEquals(first_index(list2, 'Dave'), 0, 'find none simple')
+
+# Creates a list for use with the find test.
+def get_names():
+  global test_name, naked, proc_x, proc_y, func_x, func_y, func_a, n, ok, log, count, varToChange, rand, item, text, number_of_calls, list2, proc_z, func_z, x, proc_w, func_c, if2, loglist, changing_list, list_copy, unittestResults
+  number_of_calls = (number_of_calls if isinstance(number_of_calls, Number) else 0) + 1
+  return ['Alice', 'Eve', 'Bob', 'Eve']
+
+# Tests the "find" block with a function call.
+def test_find_lists_complex():
+  global test_name, naked, proc_x, proc_y, func_x, func_y, func_a, n, ok, log, count, varToChange, rand, item, text, number_of_calls, list2, proc_z, func_z, x, proc_w, func_c, if2, loglist, changing_list, list_copy, unittestResults
+  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(get_names() if True else None, '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(get_names() if True else None, '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(get_names() if True else None, 'Dave'), 0, 'find none order complex')
+  check_number_of_calls('find none order complex')
+
+# Tests the "get" block with a variable.
+def test_get_lists_simple():
+  global test_name, naked, proc_x, proc_y, func_x, func_y, func_a, n, ok, log, count, varToChange, rand, item, text, number_of_calls, list2, proc_z, func_z, x, proc_w, func_c, if2, loglist, changing_list, list_copy, unittestResults
+  list2 = ['Kirk', 'Spock', 'McCoy']
+  assertEquals(list2[0], 'Kirk', 'get first simple')
+  assertEquals(list2[-1], 'McCoy', 'get last simple')
+  assertEquals(first_index(list2, random.choice(list2)) > 0, True, 'get random simple')
+  assertEquals(list2[1], 'Spock', 'get # simple')
+  assertEquals(list2[int((2 if True else None) - 1)], 'Spock', 'get # order simple')
+  assertEquals(list2[-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(list2[-int(0 + 3)], 'Kirk', 'get #-end order simple')
+
+# Tests the "get" block with create list call.
+def test_get_lists_create_list():
+  global test_name, naked, proc_x, proc_y, func_x, func_y, func_a, n, ok, log, count, varToChange, rand, item, text, number_of_calls, list2, proc_z, func_z, x, proc_w, func_c, if2, loglist, changing_list, list_copy, unittestResults
+  assertEquals(['Kirk', 'Spock', 'McCoy'][0], 'Kirk', 'get first create list')
+  assertEquals(['Kirk', 'Spock', 'McCoy'][-1], 'McCoy', 'get last simple')
+  assertEquals(first_index(['Kirk', 'Spock', 'McCoy'], random.choice(['Kirk', 'Spock', 'McCoy'])) > 0, True, 'get random simple')
+  assertEquals(['Kirk', 'Spock', 'McCoy'][1], 'Spock', 'get # simple')
+  assertEquals(['Kirk', 'Spock', 'McCoy'][int((2 if True else None) - 1)], 'Spock', 'get # order simple')
+  assertEquals(['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(['Kirk', 'Spock', 'McCoy'][-int(0 + 3)], 'Kirk', 'get #-end order simple')
+
+# Creates a list for use with the get test.
+def get_star_wars():
+  global test_name, naked, proc_x, proc_y, func_x, func_y, func_a, n, ok, log, count, varToChange, rand, item, text, number_of_calls, list2, proc_z, func_z, x, proc_w, func_c, if2, loglist, changing_list, list_copy, unittestResults
+  number_of_calls = (number_of_calls if isinstance(number_of_calls, Number) else 0) + 1
+  return ['Kirk', 'Spock', 'McCoy']
+
+# Tests the "get" block with a function call.
+def test_get_lists_complex():
+  global test_name, naked, proc_x, proc_y, func_x, func_y, func_a, n, ok, log, count, varToChange, rand, item, text, number_of_calls, list2, proc_z, func_z, x, proc_w, func_c, if2, loglist, changing_list, list_copy, unittestResults
+  list2 = ['Kirk', 'Spock', 'McCoy']
+  number_of_calls = 0
+  assertEquals(get_star_wars()[0], 'Kirk', 'get first complex')
+  check_number_of_calls('get first complex')
+  number_of_calls = 0
+  assertEquals((get_star_wars() if True else None)[0], 'Kirk', 'get first order complex')
+  check_number_of_calls('get first order complex')
+  number_of_calls = 0
+  assertEquals(get_star_wars()[-1], 'McCoy', 'get last complex')
+  check_number_of_calls('get last complex')
+  number_of_calls = 0
+  assertEquals((get_star_wars() if True else None)[-1], 'McCoy', 'get last order complex')
+  check_number_of_calls('get last order complex')
+  number_of_calls = 0
+  assertEquals(first_index(list2, random.choice(get_star_wars())) > 0, True, 'get random complex')
+  check_number_of_calls('get random complex')
+  number_of_calls = 0
+  assertEquals(first_index(list2, random.choice(get_star_wars() if True else None)) > 0, True, 'get random order complex')
+  check_number_of_calls('get random order complex')
+  number_of_calls = 0
+  assertEquals(get_star_wars()[1], 'Spock', 'get # complex')
+  check_number_of_calls('get # complex')
+  number_of_calls = 0
+  assertEquals((get_star_wars() if True else None)[int((2 if True else None) - 1)], 'Spock', 'get # order complex')
+  check_number_of_calls('get # order complex')
+  number_of_calls = 0
+  assertEquals(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((get_star_wars() if True else None)[-int(0 + 3)], 'Kirk', 'get #-end order complex')
+  check_number_of_calls('get #-end order complex')
+
+def lists_remove_random_item(myList):
+  x = int(random.random() * len(myList))
+  return myList.pop(x)
+
+# Tests the "get and remove" block.
+def test_getRemove():
+  global test_name, naked, proc_x, proc_y, func_x, func_y, func_a, n, ok, log, count, varToChange, rand, item, text, number_of_calls, list2, proc_z, func_z, x, proc_w, func_c, if2, loglist, changing_list, list_copy, unittestResults
+  list2 = ['Kirk', 'Spock', 'McCoy']
+  assertEquals(list2.pop(0), 'Kirk', 'getremove first')
+  assertEquals(list2, ['Spock', 'McCoy'], 'getremove first list')
+  list2 = ['Kirk', 'Spock', 'McCoy']
+  assertEquals((list2 if True else None).pop(0), 'Kirk', 'getremove first order')
+  assertEquals(list2, ['Spock', 'McCoy'], 'getremove first order list')
+  list2 = ['Kirk', 'Spock', 'McCoy']
+  assertEquals(list2.pop(), 'McCoy', 'getremove last')
+  assertEquals(list2, ['Kirk', 'Spock'], 'getremove last list')
+  list2 = ['Kirk', 'Spock', 'McCoy']
+  assertEquals((list2 if True else None).pop(), 'McCoy', 'getremove last order')
+  assertEquals(list2, ['Kirk', 'Spock'], 'getremove last order list')
+  list2 = ['Kirk', 'Spock', 'McCoy']
+  assertEquals(first_index(list2, lists_remove_random_item(list2)) == 0, True, 'getremove random')
+  assertEquals(len(list2), 2, 'getremove random list')
+  list2 = ['Kirk', 'Spock', 'McCoy']
+  assertEquals(first_index(list2, lists_remove_random_item(list2 if True else None)) == 0, True, 'getremove random order')
+  assertEquals(len(list2), 2, 'getremove random order list')
+  list2 = ['Kirk', 'Spock', 'McCoy']
+  assertEquals(list2.pop(1), 'Spock', 'getremove #')
+  assertEquals(list2, ['Kirk', 'McCoy'], 'getremove # list')
+  list2 = ['Kirk', 'Spock', 'McCoy']
+  assertEquals((list2 if True else None).pop(int((2 if True else None) - 1)), 'Spock', 'getremove # order')
+  assertEquals(list2, ['Kirk', 'McCoy'], 'getremove # order list')
+  list2 = ['Kirk', 'Spock', 'McCoy']
+  assertEquals(list2.pop(-3), 'Kirk', 'getremove #-end')
+  assertEquals(list2, ['Spock', 'McCoy'], 'getremove #-end list')
+  list2 = ['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((list2 if True else None).pop(-int(0 + 3)), 'Kirk', 'getremove #-end order')
+  assertEquals(list2, ['Spock', 'McCoy'], 'getremove #-end order list')
+
+# Tests the "remove" block.
+def test_remove():
+  global test_name, naked, proc_x, proc_y, func_x, func_y, func_a, n, ok, log, count, varToChange, rand, item, text, number_of_calls, list2, proc_z, func_z, x, proc_w, func_c, if2, loglist, changing_list, list_copy, unittestResults
+  list2 = ['Kirk', 'Spock', 'McCoy']
+  list2.pop(0)
+  assertEquals(list2, ['Spock', 'McCoy'], 'remove first list')
+  list2 = ['Kirk', 'Spock', 'McCoy']
+  (list2 if True else None).pop(0)
+  assertEquals(list2, ['Spock', 'McCoy'], 'remove first order list')
+  list2 = ['Kirk', 'Spock', 'McCoy']
+  list2.pop()
+  assertEquals(list2, ['Kirk', 'Spock'], 'remove last list')
+  list2 = ['Kirk', 'Spock', 'McCoy']
+  (list2 if True else None).pop()
+  assertEquals(list2, ['Kirk', 'Spock'], 'remove last order list')
+  list2 = ['Kirk', 'Spock', 'McCoy']
+  lists_remove_random_item(list2)
+  assertEquals(len(list2), 2, 'remove random list')
+  list2 = ['Kirk', 'Spock', 'McCoy']
+  lists_remove_random_item(list2 if True else None)
+  assertEquals(len(list2), 2, 'remove random order list')
+  list2 = ['Kirk', 'Spock', 'McCoy']
+  list2.pop(1)
+  assertEquals(list2, ['Kirk', 'McCoy'], 'remove # list')
+  list2 = ['Kirk', 'Spock', 'McCoy']
+  (list2 if True else None).pop(int((2 if True else None) - 1))
+  assertEquals(list2, ['Kirk', 'McCoy'], 'remove # order list')
+  list2 = ['Kirk', 'Spock', 'McCoy']
+  list2.pop(-3)
+  assertEquals(list2, ['Spock', 'McCoy'], 'remove #-end list')
+  list2 = ['Kirk', 'Spock', 'McCoy']
+  # The order for index for #-end is addition because this will catch
+  # errors in generators where most perform the operation ... - index.
+  (list2 if True else None).pop(-int(0 + 3))
+  assertEquals(list2, ['Spock', 'McCoy'], 'remove #-end order list')
+
+# Tests the "set" block.
+def test_set():
+  global test_name, naked, proc_x, proc_y, func_x, func_y, func_a, n, ok, log, count, varToChange, rand, item, text, number_of_calls, list2, proc_z, func_z, x, proc_w, func_c, if2, loglist, changing_list, list_copy, unittestResults
+  list2 = ['Picard', 'Riker', 'Crusher']
+  list2[0] = 'Jean-Luc'
+  assertEquals(list2, ['Jean-Luc', 'Riker', 'Crusher'], 'set first list')
+  list2 = ['Picard', 'Riker', 'Crusher']
+  (list2 if True else None)[0] = 'Jean-Luc'
+  assertEquals(list2, ['Jean-Luc', 'Riker', 'Crusher'], 'set first order list')
+  list2 = ['Picard', 'Riker', 'Crusher']
+  list2[-1] = 'Beverly'
+  assertEquals(list2, ['Picard', 'Riker', 'Beverly'], 'set last list')
+  list2 = ['Picard', 'Riker', 'Crusher']
+  (list2 if True else None)[-1] = 'Beverly'
+  assertEquals(list2, ['Picard', 'Riker', 'Beverly'], 'set last order list')
+  list2 = ['Picard', 'Riker', 'Crusher']
+  tmp_x = int(random.random() * len(list2))
+  list2[tmp_x] = 'Data'
+  assertEquals(len(list2), 3, 'set random list')
+  list2 = ['Picard', 'Riker', 'Crusher']
+  tmp_list = (list2 if True else None)
+  tmp_x2 = int(random.random() * len(tmp_list))
+  tmp_list[tmp_x2] = 'Data'
+  assertEquals(len(list2), 3, 'set random order list')
+  list2 = ['Picard', 'Riker', 'Crusher']
+  list2[2] = 'Pulaski'
+  assertEquals(list2, ['Picard', 'Riker', 'Pulaski'], 'set # list')
+  list2 = ['Picard', 'Riker', 'Crusher']
+  (list2 if True else None)[int((3 if True else None) - 1)] = 'Pulaski'
+  assertEquals(list2, ['Picard', 'Riker', 'Pulaski'], 'set # order list')
+  list2 = ['Picard', 'Riker', 'Crusher']
+  list2[-1] = 'Pulaski'
+  assertEquals(list2, ['Picard', 'Riker', 'Pulaski'], 'set #-end list')
+  list2 = ['Picard', 'Riker', 'Crusher']
+  # The order for index for #-end is addition because this will catch
+  # errors in generators where most perform the operation ... - index.
+  (list2 if True else None)[-int(0 + 2)] = 'Pulaski'
+  assertEquals(list2, ['Picard', 'Pulaski', 'Crusher'], 'set #-end order list')
+
+# Tests the "insert" block.
+def test_insert():
+  global test_name, naked, proc_x, proc_y, func_x, func_y, func_a, n, ok, log, count, varToChange, rand, item, text, number_of_calls, list2, proc_z, func_z, x, proc_w, func_c, if2, loglist, changing_list, list_copy, unittestResults
+  list2 = ['Picard', 'Riker', 'Crusher']
+  list2.insert(0, 'Data')
+  assertEquals(list2, ['Data', 'Picard', 'Riker', 'Crusher'], 'insert first list')
+  list2 = ['Picard', 'Riker', 'Crusher']
+  (list2 if True else None).insert(0, 'Data')
+  assertEquals(list2, ['Data', 'Picard', 'Riker', 'Crusher'], 'insert first order list')
+  list2 = ['Picard', 'Riker', 'Crusher']
+  list2.append('Data')
+  assertEquals(list2, ['Picard', 'Riker', 'Crusher', 'Data'], 'insert last list')
+  list2 = ['Picard', 'Riker', 'Crusher']
+  (list2 if True else None).append('Data')
+  assertEquals(list2, ['Picard', 'Riker', 'Crusher', 'Data'], 'insert last order list')
+  list2 = ['Picard', 'Riker', 'Crusher']
+  tmp_x3 = int(random.random() * len(list2))
+  list2.insert(tmp_x3, 'Data')
+  assertEquals(len(list2), 4, 'insert random list')
+  list2 = ['Picard', 'Riker', 'Crusher']
+  tmp_list2 = (list2 if True else None)
+  tmp_x4 = int(random.random() * len(tmp_list2))
+  tmp_list2.insert(tmp_x4, 'Data')
+  assertEquals(len(list2), 4, 'insert random order list')
+  list2 = ['Picard', 'Riker', 'Crusher']
+  list2.insert(2, 'Data')
+  assertEquals(list2, ['Picard', 'Riker', 'Data', 'Crusher'], 'insert # list')
+  list2 = ['Picard', 'Riker', 'Crusher']
+  (list2 if True else None).insert(int((3 if True else None) - 1), 'Data')
+  assertEquals(list2, ['Picard', 'Riker', 'Data', 'Crusher'], 'insert # order list')
+  list2 = ['Picard', 'Riker', 'Crusher']
+  list2.insert(-1, 'Data')
+  assertEquals(list2, ['Picard', 'Riker', 'Data', 'Crusher'], 'insert #-end list')
+  list2 = ['Picard', 'Riker', 'Crusher']
+  # The order for index for #-end is addition because this will catch
+  # errors in generators where most perform the operation ... - index.
+  (list2 if True else None).insert(-int(0 + 2), 'Data')
+  assertEquals(list2, ['Picard', 'Data', 'Riker', 'Crusher'], 'insert #-end order list')
+
+# Tests the "get sub-list" block with a variable.
+def test_sublist_simple():
+  global test_name, naked, proc_x, proc_y, func_x, func_y, func_a, n, ok, log, count, varToChange, rand, item, text, number_of_calls, list2, proc_z, func_z, x, proc_w, func_c, if2, loglist, changing_list, list_copy, unittestResults
+  list2 = ['Columbia', 'Challenger', 'Discovery', 'Atlantis', 'Endeavour']
+  assertEquals(list2[1 : 3], ['Challenger', 'Discovery'], 'sublist # simple')
+  assertEquals(list2[int((2 if True else None) - 1) : int(3 if True else None)], ['Challenger', 'Discovery'], 'sublist # simple order')
+  assertEquals(list2[-3 : -1], ['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(list2[-int(0 + 3) : -int((0 + 2) - 1) or sys.maxsize], ['Discovery', 'Atlantis'], 'sublist #-end simple order')
+  assertEquals(list2[ : ], list2, 'sublist first-last simple')
+  changing_list = ['Columbia', 'Challenger', 'Discovery', 'Atlantis', 'Endeavour']
+  list_copy = changing_list[ : ]
+  lists_remove_random_item(changing_list)
+  assertEquals(list_copy, list2, 'sublist first-last simple copy check')
+  assertEquals(list2[1 : -1], ['Challenger', 'Discovery', 'Atlantis'], 'sublist # #-end simple')
+  assertEquals(list2[-3 : 4], ['Discovery', 'Atlantis'], 'sublist #-end # simple')
+  assertEquals(list2[ : 4], ['Columbia', 'Challenger', 'Discovery', 'Atlantis'], 'sublist first # simple')
+  assertEquals(list2[ : -3], ['Columbia', 'Challenger'], 'sublist first #-end simple')
+  assertEquals(list2[3 : ], ['Atlantis', 'Endeavour'], 'sublist # last simple')
+  assertEquals(list2[-4 : ], ['Challenger', 'Discovery', 'Atlantis', 'Endeavour'], 'sublist #-end last simple')
+  assertEquals(list2[ : ], list2, 'sublist all with # #-end simple')
+  assertEquals(list2[-5 : 5], list2, '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(list2[int((0 + 1) - 1) : -int((0 + 1) - 1) or sys.maxsize], list2, 'sublist all with # #-end math simple')
+
+# Creates a list for use with the sublist test.
+def get_space_shuttles():
+  global test_name, naked, proc_x, proc_y, func_x, func_y, func_a, n, ok, log, count, varToChange, rand, item, text, number_of_calls, list2, proc_z, func_z, x, proc_w, func_c, if2, loglist, changing_list, list_copy, unittestResults
+  number_of_calls = (number_of_calls if isinstance(number_of_calls, Number) else 0) + 1
+  return ['Columbia', 'Challenger', 'Discovery', 'Atlantis', 'Endeavour']
+
+# Tests the "get sub-list" block with a function call.
+def test_sublist_complex():
+  global test_name, naked, proc_x, proc_y, func_x, func_y, func_a, n, ok, log, count, varToChange, rand, item, text, number_of_calls, list2, proc_z, func_z, x, proc_w, func_c, if2, loglist, changing_list, list_copy, unittestResults
+  number_of_calls = 0
+  assertEquals(get_space_shuttles()[1 : 3], ['Challenger', 'Discovery'], 'sublist # start complex')
+  check_number_of_calls('sublist # start complex')
+  number_of_calls = 0
+  assertEquals((get_space_shuttles() if True else None)[int((2 if True else None) - 1) : int(3 if True else None)], ['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(get_space_shuttles()[-3 : -1], ['Discovery', 'Atlantis'], 'sublist # end complex')
+  assertEquals(number_of_calls, 1, 'sublist # end complex number of calls')
+  number_of_calls = 0
+  assertEquals((get_space_shuttles() if True else None)[-int(0 + 3) : -int((0 + 2) - 1) or sys.maxsize], ['Discovery', 'Atlantis'], 'sublist # end order complex')
+  check_number_of_calls('sublist # end order complex')
+  number_of_calls = 0
+  assertEquals(get_space_shuttles()[ : ], list2, 'sublist first-last complex')
+  check_number_of_calls('sublist first-last complex')
+  number_of_calls = 0
+  assertEquals(get_space_shuttles()[1 : -1], ['Challenger', 'Discovery', 'Atlantis'], 'sublist # #-end complex')
+  check_number_of_calls('sublist # #-end complex')
+  number_of_calls = 0
+  assertEquals(get_space_shuttles()[-3 : 4], ['Discovery', 'Atlantis'], 'sublist #-end # complex')
+  check_number_of_calls('sublist #-end # complex')
+  number_of_calls = 0
+  assertEquals(get_space_shuttles()[ : 4], ['Columbia', 'Challenger', 'Discovery', 'Atlantis'], 'sublist first # complex')
+  check_number_of_calls('sublist first # complex')
+  number_of_calls = 0
+  assertEquals(get_space_shuttles()[ : -3], ['Columbia', 'Challenger'], 'sublist first #-end complex')
+  check_number_of_calls('sublist first #-end complex')
+  number_of_calls = 0
+  assertEquals(get_space_shuttles()[3 : ], ['Atlantis', 'Endeavour'], 'sublist # last complex')
+  check_number_of_calls('sublist # last complex')
+  number_of_calls = 0
+  assertEquals(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(get_space_shuttles()[ : ], list2, 'sublist all with # #-end complex')
+  check_number_of_calls('sublist all with # #-end complex')
+  number_of_calls = 0
+  assertEquals(get_space_shuttles()[-5 : 5], list2, '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(get_space_shuttles()[int((0 + 1) - 1) : -int((0 + 1) - 1) or sys.maxsize], list2, 'sublist all with # #-end math complex')
+  check_number_of_calls('sublist all with # #-end math complex')
+
+# Tests the "join" block.
+def test_join():
+  global test_name, naked, proc_x, proc_y, func_x, func_y, func_a, n, ok, log, count, varToChange, rand, item, text, number_of_calls, list2, proc_z, func_z, x, proc_w, func_c, if2, loglist, changing_list, list_copy, unittestResults
+  list2 = ['Vulcan', 'Klingon', 'Borg']
+  assertEquals(','.join(list2), 'Vulcan,Klingon,Borg', 'join')
+  assertEquals(','.join(list2 if True else None), 'Vulcan,Klingon,Borg', 'join order')
+
+# Tests the "split" block.
+def test_split():
+  global test_name, naked, proc_x, proc_y, func_x, func_y, func_a, n, ok, log, count, varToChange, rand, item, text, number_of_calls, list2, proc_z, func_z, x, proc_w, func_c, if2, loglist, changing_list, list_copy, unittestResults
+  text = 'Vulcan,Klingon,Borg'
+  assertEquals(text.split(','), ['Vulcan', 'Klingon', 'Borg'], 'split')
+  assertEquals((text if True else None).split(','), ['Vulcan', 'Klingon', 'Borg'], 'split order')
+
+def lists_sort(my_list, type, reverse):
+  def try_float(s):
+    try:
+      return float(s)
+    except:
+      return 0
+  key_funcs = {
+    "NUMERIC": try_float,
+    "TEXT": str,
+    "IGNORE_CASE": lambda s: str(s).lower()
+  }
+  key_func = key_funcs[type]
+  list_cpy = list(my_list)
+  return sorted(list_cpy, key=key_func, reverse=reverse)
+
+# Tests the "alphabetic sort" block.
+def test_sort_alphabetic():
+  global test_name, naked, proc_x, proc_y, func_x, func_y, func_a, n, ok, log, count, varToChange, rand, item, text, number_of_calls, list2, proc_z, func_z, x, proc_w, func_c, if2, loglist, changing_list, list_copy, unittestResults
+  list2 = ['Vulcan', 'klingon', 'Borg']
+  assertEquals(lists_sort(list2, "TEXT", False), ['Borg', 'Vulcan', 'klingon'], 'sort alphabetic ascending')
+  assertEquals(lists_sort(list2 if True else None, "TEXT", False), ['Borg', 'Vulcan', 'klingon'], 'sort alphabetic ascending order')
+
+# Tests the "alphabetic sort ignore case" block.
+def test_sort_ignoreCase():
+  global test_name, naked, proc_x, proc_y, func_x, func_y, func_a, n, ok, log, count, varToChange, rand, item, text, number_of_calls, list2, proc_z, func_z, x, proc_w, func_c, if2, loglist, changing_list, list_copy, unittestResults
+  list2 = ['Vulcan', 'klingon', 'Borg']
+  assertEquals(lists_sort(list2, "IGNORE_CASE", False), ['Borg', 'klingon', 'Vulcan'], 'sort ignore case ascending')
+  assertEquals(lists_sort(list2 if True else None, "IGNORE_CASE", False), ['Borg', 'klingon', 'Vulcan'], 'sort ignore case ascending order')
+
+# Tests the "numeric sort" block.
+def test_sort_numeric():
+  global test_name, naked, proc_x, proc_y, func_x, func_y, func_a, n, ok, log, count, varToChange, rand, item, text, number_of_calls, list2, proc_z, func_z, x, proc_w, func_c, if2, loglist, changing_list, list_copy, unittestResults
+  list2 = [8, 18, -1]
+  assertEquals(lists_sort(list2, "NUMERIC", True), [18, 8, -1], 'sort numeric descending')
+  assertEquals(lists_sort(list2 if True else None, "NUMERIC", True), [18, 8, -1], 'sort numeric descending order')
+
+# Tests the "list reverse" block.
+def test_lists_reverse():
+  global test_name, naked, proc_x, proc_y, func_x, func_y, func_a, n, ok, log, count, varToChange, rand, item, text, number_of_calls, list2, proc_z, func_z, x, proc_w, func_c, if2, loglist, changing_list, list_copy, unittestResults
+  list2 = [8, 18, -1, 64]
+  assertEquals(list(reversed(list2)), [64, -1, 18, 8], 'reverse a copy')
+  assertEquals(list2, [8, 18, -1, 64], 'reverse a copy original')
+  list2 = []
+  assertEquals(list(reversed(list2)), [], 'empty list')
+
+# Describe this function...
+def test_procedure():
+  global test_name, naked, proc_x, proc_y, func_x, func_y, func_a, n, ok, log, count, varToChange, rand, item, text, number_of_calls, list2, proc_z, func_z, x, proc_w, func_c, if2, loglist, changing_list, list_copy, unittestResults
+  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')
+
+# Describe this function...
+def procedure_1(proc_x, proc_y):
+  global test_name, naked, func_x, func_y, func_a, n, ok, log, count, varToChange, rand, item, text, number_of_calls, list2, proc_z, func_z, x, proc_w, func_c, if2, loglist, changing_list, list_copy, unittestResults
+  proc_z = proc_x / proc_y
+
+# Describe this function...
+def procedure_2(proc_x):
+  global test_name, naked, proc_y, func_x, func_y, func_a, n, ok, log, count, varToChange, rand, item, text, number_of_calls, list2, proc_z, func_z, x, proc_w, func_c, if2, loglist, changing_list, list_copy, unittestResults
+  if proc_x:
+    return
+  proc_w = True
+
+# Describe this function...
+def test_function():
+  global test_name, naked, proc_x, proc_y, func_x, func_y, func_a, n, ok, log, count, varToChange, rand, item, text, number_of_calls, list2, proc_z, func_z, x, proc_w, func_c, if2, loglist, changing_list, list_copy, unittestResults
+  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')
+
+# Describe this function...
+def function_1(func_x, func_y):
+  global test_name, naked, proc_x, proc_y, func_a, n, ok, log, count, varToChange, rand, item, text, number_of_calls, list2, proc_z, func_z, x, proc_w, func_c, if2, loglist, changing_list, list_copy, unittestResults
+  func_z = 'side effect'
+  return func_x - func_y
+
+# Describe this function...
+def function_2(func_a):
+  global test_name, naked, proc_x, proc_y, func_x, func_y, n, ok, log, count, varToChange, rand, item, text, number_of_calls, list2, proc_z, func_z, x, proc_w, func_c, if2, loglist, changing_list, list_copy, unittestResults
+  func_a = (func_a if isinstance(func_a, Number) else 0) + 1
+  return str(func_a) + str(func_c)
+
+# Describe this function...
+def function_3(func_a):
+  global test_name, naked, proc_x, proc_y, func_x, func_y, n, ok, log, count, varToChange, rand, item, text, number_of_calls, list2, proc_z, func_z, x, proc_w, func_c, if2, loglist, changing_list, list_copy, unittestResults
+  if func_a:
+    return True
+  return False
+
+# Describe this function...
+def recurse(n):
+  global test_name, naked, proc_x, proc_y, func_x, func_y, func_a, ok, log, count, varToChange, rand, item, text, number_of_calls, list2, proc_z, func_z, x, proc_w, func_c, if2, loglist, changing_list, list_copy, unittestResults
+  if n > 0:
+    text = ''.join([str(x4) for x4 in [recurse(n - 1), n, recurse(n - 1)]])
+  else:
+    text = '-'
+  return text
+
+
+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 = None
+
+unittestResults = []
+print('\n====================\n\nRunning suite: Loops 1')
+test_repeat()
+test_repeat_ext()
+test_while()
+test_foreach()
+print(unittest_report())
+unittestResults = None
+
+unittestResults = []
+print('\n====================\n\nRunning suite: Loops 2')
+test_count_loops()
+test_count_by()
+print(unittest_report())
+unittestResults = None
+
+unittestResults = []
+print('\n====================\n\nRunning suite: Loops 3')
+test_break()
+test_continue()
+print(unittest_report())
+unittestResults = None
+
+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 = None
+
+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 = None
+
+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 = None
+
+unittestResults = []
+print('\n====================\n\nRunning suite: Variables')
+item = 123
+assertEquals(item, 123, 'variable')
+if2 = 123
+assertEquals(if2, 123, 'reserved variable')
+print(unittest_report())
+unittestResults = None
+
+# 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 = None