anchor.diff:          | ex ->
               Assert.IsInstanceOf<System.IndexOutOfRangeException>(ex)
   
  +let private isalnumValues : (string * bool)[] = [|
  +    (
  +        // idx 0
  +        // printer.isalnum.01
  +        // empty string
  +        // throws System.IndexOutOfRangeException
  +        "",
  +        false  // dummy value
  +    );
  +    (
  +        // idx 1
  +        // printer.isalnum.02
  +        // empty string using the empty string literal
  +        // throws System.IndexOutOfRangeException
  +        String.empty,
  +        false  // dummy value
  +    );
  +    (
  +        // idx 2
  +        // printer.isalnum.03
  +        // string with two characters, both are not alnum kind
  +        "--",
  +        false
  +    );
  +    (
  +        // idx 3
  +        // printer.isalnum.04
  +        // string with two characters, first character is alnum kind, second character is not alnum kind
  +        "1-",
  +        true
  +    );
  +    (
  +        // idx 4
  +        // printer.isalnum.05
  +        // string with two characters, first character is not alnum kind, second character is alnum kind
  +        "-a",
  +        false
  +    );
  +    (
  +        // idx 5
  +        // printer.isalnum.06
  +        // string with two characters, both same alnum kind
  +        "11",
  +        true
  +    );
  +    (
  +        // idx 6
  +        // printer.isalnum.07
  +        // string with two characters, both different alnum kind
  +        "1a",
  +        true
  +    );
  +    |]
  +
  +[<Test>]
  +[<TestCase(0, TestName = "printer.isalnum.01", ExpectedException=typeof<System.IndexOutOfRangeException>, ExpectedMessage = "Index was outside the bounds of the array.")>]
  +[<TestCase(1, TestName = "printer.isalnum.02", ExpectedException=typeof<System.IndexOutOfRangeException>, ExpectedMessage = "Index was outside the bounds of the array.")>]
  +[<TestCase(2, TestName = "printer.isalnum.03")>]
  +[<TestCase(3, TestName = "printer.isalnum.04")>]
  +[<TestCase(4, TestName = "printer.isalnum.05")>]
  +[<TestCase(5, TestName = "printer.isalnum.06")>]
  +[<TestCase(6, TestName = "printer.isalnum.07")>]
  +let ``function isalnum`` idx =
  +    let (word, _) = isalnumValues.[idx]
  +    let (_, result) = isalnumValues.[idx]
  +    let isalnumResult = NHol.printer.isalnum word
  +//    printfn "%A" end_itlistResult
  +    isalnumResult |> assertEqual result
  +
   (* reserve_words  tests *)
  -
   (* unreserve_words  tests *)
  +(* reserved_words  tests *)
  +
  +// Note: Since reserve words is based on a mutable list,
  +// and the list should remain static for the duration of the core testing,
  +// the test are peformed to end with the list back in the inital state.
  +[<Test>]
  +let ``functions reserved_words, reserve_words, reserved_words`` () =
  +    let reserved_words_initial = [
  +        "(";
  +        ")";
  +        "[";
  +        "]";
  +        "{";
  +        "}";
  +        ":";
  +        ";";
  +        ".";
  +        "|";
  +        "let";
  +        "in";
  +        "and";
  +        "if";
  +        "then";
  +        "else";
  +        "match";
  +        "with";
  +        "function";
  +        "->";
  +        "when"]
  +
  +    // Check the intial state of the reserved words.
  +    let initialResult = NHol.printer.reserved_words()
  +    NUnit.Framework.CollectionAssert.AreEquivalent(initialResult, reserved_words_initial)
  +
  +    let reserved_words_added = [
  +        "(";
  +        ")";
  +        "[";
  +        "]";
  +        "{";
  +        "}";
  +        ":";
  +        ";";
  +        ".";
  +        "|";
  +        "let";
  +        "in";
  +        "and";
  +        "if";
  +        "then";
  +        "else";
  +        "match";
  +        "with";
  +        "function";
  +        "->";
  +        "when";
  +        "TeSt";
  +        "two words"
  +        ]
  +
  +    // Add some values.
  +    NHol.printer.reserve_words ["TeSt"; "two words"]
  +    let addResult = NHol.printer.reserved_words()
  +    NUnit.Framework.CollectionAssert.AreEquivalent(addResult, reserved_words_added)
  +
  +    // Test for one of the added values.
  +    let existResult = NHol.printer.is_reserved_word "two words"
  +    existResult |> NUnit.Framework.Assert.True
  +
  +    // Remove added values returning reserved words back to inital state.
  +    NHol.printer.unreserve_words ["TeSt"; "two words"]
  +    let removeResult = NHol.printer.reserved_words()
  +    NUnit.Framework.CollectionAssert.AreEquivalent(removeResult, reserved_words_initial)
   
   (* is_reserved_word  tests *)
   
  
positive.code:         | ex ->
              Assert.IsInstanceOf<System.IndexOutOfRangeException>(ex)
  
  (* isnum tests *)
  
  [<Test>]
  let ``function isnum`` () =
      // Note: The OCaml char range is 0-255, but in NHol with F# it is 0..65535
      // We expect System.IndexOutOfRangeException for characters with values of 256 or greater.
      let inline charcode (s : string) = int s.[0]
  
negative.code:         | ex ->
              Assert.IsInstanceOf<System.IndexOutOfRangeException>(ex)
  
  let private isbraValues : (string * bool)[] = [|
      (
          // idx 0
          // printer.isbra.01
          // empty string
          // throws System.IndexOutOfRangeException
          "",
          false  // dummy value
      );
      (
          // idx 1
          // printer.isbra.02
          // empty string using the empty string literal
          // throws System.IndexOutOfRangeException
          String.empty,
          false  // dummy value
      );
      (
          // idx 2
          // printer.isbra.03
          // string with two characters, both are not braket kind
          "aa",
          false
      );
      (
          // idx 3
          // printer.isbra.04
          // string with two characters, first character is braket kind, second character is not braket kind
          "(a",
          true
      );
      (
          // idx 4
          // printer.isbra.05
          // string with two characters, first character is not braket kind, second character is braket kind
          "a)",
          false
      );
      (
          // idx 5
          // printer.isbra.06
          // string with two characters, both same braket kind
          "((",
          true
      );
      (
          // idx 6
          // printer.isbra.07
          // string with two characters, both different braket kind
          "()",
          true
      );
      |]
  
  [<Test>]
  [<TestCase(0, TestName = "printer.isbra.01", ExpectedException=typeof<System.IndexOutOfRangeException>, ExpectedMessage = "Index was outside the bounds of the array.")>]
  [<TestCase(1, TestName = "printer.isbra.02", ExpectedException=typeof<System.IndexOutOfRangeException>, ExpectedMessage = "Index was outside the bounds of the array.")>]
  [<TestCase(2, TestName = "printer.isbra.03")>]
  [<TestCase(3, TestName = "printer.isbra.04")>]
  [<TestCase(4, TestName = "printer.isbra.05")>]
  [<TestCase(5, TestName = "printer.isbra.06")>]
  [<TestCase(6, TestName = "printer.isbra.07")>]
  let ``function isbra`` idx =
      let (word, _) = isbraValues.[idx]
      let (_, result) = isbraValues.[idx]
      let isbraResult = NHol.printer.isbra word
  //    printfn "%A" end_itlistResult
      isbraResult |> assertEqual result
  
  (* issymb tests *)
  
  [<Test>]
  let ``function issymb - test all single char values`` () =
      // Note: The OCaml char range is 0-255, but in NHol with F# it is 0..65535
      // We expect System.IndexOutOfRangeException for characters with values of 256 or greater.
      let inline charcode (s : string) = int s.[0]
  