anchor.diff:          | ex ->
               Assert.IsInstanceOf<System.IndexOutOfRangeException>(ex)
   
  +let private issymbValues : (string * bool)[] = [|
  +    (
  +        // idx 0
  +        // printer.issymb.01
  +        // empty string
  +        // throws System.IndexOutOfRangeException
  +        "",
  +        false  // dummy value
  +    );
  +    (
  +        // idx 1
  +        // printer.issymb.02
  +        // empty string using the empty string literal
  +        // throws System.IndexOutOfRangeException
  +        String.empty,
  +        false  // dummy value
  +    );
  +    (
  +        // idx 2
  +        // printer.issymb.03
  +        // string with two characters, both are not symbol kind
  +        "aa",
  +        false
  +    );
  +    (
  +        // idx 3
  +        // printer.issymb.04
  +        // string with two characters, first character is symbol kind, second character is not symbol kind
  +        "=a",
  +        true
  +    );
  +    (
  +        // idx 4
  +        // printer.issymb.05
  +        // string with two characters, first character is not symbol kind, second character is symbol kind
  +        "a=",
  +        false
  +    );
  +    (
  +        // idx 5
  +        // printer.issymb.06
  +        // string with two characters, both same symbol kind
  +        "--",
  +        true
  +    );
  +    (
  +        // idx 6
  +        // printer.issymb.07
  +        // string with two characters, both different symbol kind
  +        ">=",
  +        true
  +    );
  +    |]
  +
  +[<Test>]
  +[<TestCase(0, TestName = "printer.issymb.01", ExpectedException=typeof<System.IndexOutOfRangeException>, ExpectedMessage = "Index was outside the bounds of the array.")>]
  +[<TestCase(1, TestName = "printer.issymb.02", ExpectedException=typeof<System.IndexOutOfRangeException>, ExpectedMessage = "Index was outside the bounds of the array.")>]
  +[<TestCase(2, TestName = "printer.issymb.03")>]
  +[<TestCase(3, TestName = "printer.issymb.04")>]
  +[<TestCase(4, TestName = "printer.issymb.05")>]
  +[<TestCase(5, TestName = "printer.issymb.06")>]
  +[<TestCase(6, TestName = "printer.issymb.07")>]
  +let ``function issymb`` idx =
  +    let (word, _) = issymbValues.[idx]
  +    let (_, result) = issymbValues.[idx]
  +    let issymbResult = NHol.printer.issymb word
  +//    printfn "%A" end_itlistResult
  +    issymbResult |> assertEqual result
  +
   (* isalpha tests *)
   
   [<Test>]
  -let ``function isalpha`` () =
  +let ``function isalpha - 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 (|NHolalphaChar|_|) c =
  
positive.code:         | ex ->
              Assert.IsInstanceOf<System.IndexOutOfRangeException>(ex)
  
  (* issymb tests *)
  
  [<Test>]
  let ``function issymb`` () =
      // 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 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 *)
  
  