Tests pass modulo couple of differences in Tcl 8 and 9 default behavior to be discussed (tickets logged)

9 files changed, 612 insertions, 337 deletions

diff --git a/tests/chanio.test b/tests/chanio.test
index ec0dbbd..18e1614 100644
--- a/tests/chanio.test
+++ b/tests/chanio.test
@@ -252,7 +252,7 @@ test chan-io-3.3 {WriteChars: compatibility with WriteBytes: flush on line} -bod
 test chan-io-3.4 {WriteChars: loop over stage buffer} -body {
     # stage buffer maps to more than can be queued at once.
     set f [open $path(test1) w]
-    chan configure $f -encoding jis0208 -buffersize 16 -nocomplainencoding 1
+    chan configure $f -encoding jis0208 -buffersize 16 -encodingprofile tcl8
     chan puts -nonewline $f "\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\"
     set x [list [contents $path(test1)]]
     chan close $f
@@ -265,7 +265,7 @@ test chan-io-3.5 {WriteChars: saved != 0} -body {
     # be moved to beginning of next channel buffer to preserve requested
     # buffersize.
     set f [open $path(test1) w]
-    chan configure $f -encoding jis0208 -buffersize 17 -nocomplainencoding 1
+    chan configure $f -encoding jis0208 -buffersize 17 -encodingprofile tcl8
     chan puts -nonewline $f "\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\"
     set x [list [contents $path(test1)]]
     chan close $f
@@ -298,7 +298,7 @@ test chan-io-3.7 {WriteChars: (bufPtr->nextAdded > bufPtr->length)} -body {
     # on flush. The truncated bytes are moved to the beginning of the next
     # channel buffer.
     set f [open $path(test1) w]
-    chan configure $f -encoding jis0208 -buffersize 17 -nocomplainencoding 1
+    chan configure $f -encoding jis0208 -buffersize 17 -encodingprofile tcl8
     chan puts -nonewline $f "\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\"
     set x [list [contents $path(test1)]]
     chan close $f
diff --git a/tests/cmdAH.test b/tests/cmdAH.test
index 8805906..634c3c4 100644
--- a/tests/cmdAH.test
+++ b/tests/cmdAH.test
@@ -178,238 +178,513 @@ test cmdAH-3.2 {Tcl_ContinueObjCmd, success} {
     list [catch {continue} msg] $msg
 } {4 {}}
 
-test cmdAH-4.1 {Tcl_EncodingObjCmd} -returnCodes error -body {
+###
+# encoding command
+
+set "numargErrors(encoding system)" {^wrong # args: should be "(encoding |::tcl::encoding::)system \?encoding\?"$}
+set "numargErrors(encoding convertfrom)" {wrong # args: should be "(encoding |::tcl::encoding::)convertfrom \?-profile profile\? \?-failindex var\? encoding data" or "(encoding |::tcl::encoding::)convertfrom data"}
+set "numargErrors(encoding convertto)" {wrong # args: should be "(encoding |::tcl::encoding::)convertto \?-profile profile\? \?-failindex var\? encoding data" or "(encoding |::tcl::encoding::)convertto data"}
+set "numargErrors(encoding names)" {wrong # args: should be "encoding names"}
+set "numargErrors(encoding profiles)" {wrong # args: should be "encoding profiles"}
+
+source [file join [file dirname [info script]] encodingVectors.tcl]
+
+
+# Maps utf-{16,32}{le,be} to utf-16, utf-32 and
+# others to "". Used to test utf-16, utf-32 based
+# on system endianness
+proc endianUtf {enc} {
+    if {$::tcl_platform(byteOrder) eq "littleEndian"} {
+        set endian le
+    } else {
+        set endian be
+    }
+    if {$enc eq "utf-16$endian" || $enc eq "utf-32$endian"} {
+        return [string range $enc 0 5]
+    }
+    return ""
+}
+
+# Map arbitrary strings to printable form in ASCII.
+proc printable {s} {
+    set print ""
+    foreach c [split $s ""] {
+        set i [scan $c %c]
+        if {[string is print $c] && ($i <= 127)} {
+            append print $c
+        } elseif {$i <= 0xff} {
+            append print \\x[format %02X $i]
+        } elseif {$i <= 0xffff} {
+            append print \\u[format %04X $i]
+        } else {
+            append print \\U[format %08X $i]
+        }
+    }
+    return $print
+}
+
+#
+# Check errors for invalid number of arguments
+proc badnumargs {id cmd cmdargs} {
+    variable numargErrors
+    test $id.a "Syntax error: $cmd $cmdargs" \
+        -body [list {*}$cmd {*}$cmdargs] \
+        -result $numargErrors($cmd) \
+        -match regexp \
+        -returnCodes error
+    test $id.b "Syntax error: $cmd (byte compiled)" \
+        -setup [list proc compiled_proc {} [list {*}$cmd {*}$cmdargs]] \
+        -body {compiled_proc} \
+        -cleanup {rename compiled_proc {}} \
+        -result $numargErrors($cmd) \
+        -match regexp \
+        -returnCodes error
+}
+
+# Wraps tests resulting in unknown encoding errors
+proc unknownencodingtest {id cmd} {
+    set result "unknown encoding \"[lindex $cmd end-1]\""
+    test $id.a "Unknown encoding error: $cmd" \
+        -body [list encoding {*}$cmd] \
+        -result $result \
+        -returnCodes error
+    test $id.b "Syntax error: $cmd (byte compiled)" \
+        -setup [list proc encoding_test {} [list encoding {*}$cmd]] \
+        -body {encoding_test} \
+        -cleanup {rename encoding_test {}} \
+        -result $result \
+        -returnCodes error
+}
+
+# Wraps tests for conversion, successful or not.
+# Really more general than just for encoding conversion.
+proc testconvert {id body result args} {
+    test $id.a $body \
+        -body $body \
+        -result $result \
+        {*}$args
+    dict append args -setup \n[list proc compiled_script {} $body]
+    dict append args -cleanup "\nrename compiled_script {}"
+    test $id.b "$body (byte compiled)" \
+        -body {compiled_script} \
+        -result $result \
+        {*}$args
+}
+
+# Wrapper to verify encoding convert{to,from} ?-profile?
+# Generates tests for compiled and uncompiled implementation.
+# Also generates utf-{16,32} tests if passed encoding is utf-{16,32}{le,be}
+# The enc and profile are appended to id to generate the test id
+proc testprofile {id converter enc profile data result args} {
+    testconvert $id.$enc.$profile [list encoding $converter -profile $profile $enc $data] $result {*}$args
+    if {[set enc2 [endianUtf $enc]] ne ""} {
+        # If utf{16,32}-{le,be}, also do utf{16,32}
+        testconvert $id.$enc2.$profile [list encoding $converter -profile $profile $enc2 $data] $result {*}$args
+    }
+
+    # If this is the default profile, generate a test without specifying profile
+    if {$profile eq $::encDefaultProfile} {
+        testconvert $id.$enc.default [list encoding $converter $enc $data] $result {*}$args
+        if {[set enc2 [endianUtf $enc]] ne ""} {
+            # If utf{16,32}-{le,be}, also do utf{16,32}
+            testconvert $id.$enc2.default [list encoding $converter $enc2 $data] $result {*}$args
+        }
+    }
+}
+
+
+# Wrapper to verify encoding convert{to,from} -failindex ?-profile?
+# Generates tests for compiled and uncompiled implementation.
+# Also generates utf-{16,32} tests if passed encoding is utf-{16,32}{le,be}
+# The enc and profile are appended to id to generate the test id
+proc testfailindex {id converter enc data result failidx {profile default}} {
+    testconvert $id.$enc.$profile "list \[encoding $converter -profile $profile -failindex idx $enc [list $data]\] \[set idx\]" [list $result $failidx]
+    if {[set enc2 [endianUtf $enc]] ne ""} {
+        # If utf{16,32}-{le,be}, also do utf{16,32}
+        testconvert $id.$enc2.$profile "list \[encoding $converter -profile $profile -failindex idx $enc2 [list $data]\] \[set idx]" [list $result $failidx]
+    }
+
+    # If this is the default profile, generate a test without specifying profile
+    if {$profile eq $::encDefaultProfile} {
+        testconvert $id.$enc.default "list \[encoding $converter -failindex idx $enc [list $data]\] \[set idx]" [list $result $failidx]
+        if {[set enc2 [endianUtf $enc]] ne ""} {
+            # If utf{16,32}-{le,be}, also do utf{16,32}
+            testconvert $id.$enc2.default "list \[encoding $converter -failindex idx $enc2 [list $data]\] \[set idx]" [list $result $failidx]
+        }
+    }
+}
+
+test cmdAH-4.1.1 {encoding} -returnCodes error -body {
     encoding
 } -result {wrong # args: should be "encoding subcommand ?arg ...?"}
-test cmdAH-4.2 {Tcl_EncodingObjCmd} -returnCodes error -body {
+test cmdAH-4.1.2 {Tcl_EncodingObjCmd} -returnCodes error -body {
     encoding foo
-} -result {unknown or ambiguous subcommand "foo": must be convertfrom, convertto, dirs, names, or system}
-test cmdAH-4.3 {Tcl_EncodingObjCmd} -returnCodes error -body {
-    encoding convertto
-} -result {wrong # args: should be "encoding convertto ?-strict? ?-failindex var? ?encoding? data" or "encoding convertto -nocomplain ?encoding? data"}
-test cmdAH-4.4 {Tcl_EncodingObjCmd} -returnCodes error -body {
-    encoding convertto foo bar
-} -result {unknown encoding "foo"}
-test cmdAH-4.5 {Tcl_EncodingObjCmd} -setup {
+} -result {unknown or ambiguous subcommand "foo": must be convertfrom, convertto, dirs, names, profiles, or system}
+
+#
+# encoding system 4.2.*
+badnumargs cmdAH-4.2.1 {encoding system} {ascii ascii}
+test cmdAH-4.2.2 {Tcl_EncodingObjCmd} -setup {
     set system [encoding system]
 } -body {
-    encoding system jis0208
-    encoding convertto 乎
+    encoding system iso8859-1
+    encoding system
 } -cleanup {
     encoding system $system
-} -result 8C
-test cmdAH-4.6 {Tcl_EncodingObjCmd} -setup {
+} -result iso8859-1
+
+#
+# encoding convertfrom 4.3.*
+
+# Odd number of args is always invalid since last two args
+# are ENCODING DATA and all options take a value
+badnumargs cmdAH-4.3.1 {encoding convertfrom} {}
+badnumargs cmdAH-4.3.2 {encoding convertfrom} {-failindex VAR ABC}
+badnumargs cmdAH-4.3.3 {encoding convertfrom} {-profile VAR ABC}
+badnumargs cmdAH-4.3.4 {encoding convertfrom} {-failindex VAR -profile strict ABC}
+badnumargs cmdAH-4.3.5 {encoding convertfrom} {-profile strict -failindex VAR ABC}
+
+# Test that last two args always treated as ENCODING DATA
+unknownencodingtest cmdAH-4.3.6 {convertfrom -failindex ABC}
+unknownencodingtest cmdAH-4.3.7 {convertfrom -profile ABC}
+unknownencodingtest cmdAH-4.3.8 {convertfrom nosuchencoding ABC}
+unknownencodingtest cmdAH-4.3.9 {convertfrom -failindex VAR -profile ABC}
+unknownencodingtest cmdAH-4.3.10 {convertfrom -profile strict -failindex ABC}
+testconvert cmdAH-4.3.11 {
+    encoding convertfrom jis0208 \x38\x43
+} \u4e4e -setup {
     set system [encoding system]
-} -body {
     encoding system iso8859-1
-    encoding convertto jis0208 乎
 } -cleanup {
     encoding system $system
-} -result 8C
-test cmdAH-4.7 {Tcl_EncodingObjCmd} -returnCodes error -body {
-    encoding convertfrom
-} -result {wrong # args: should be "encoding convertfrom ?-strict? ?-failindex var? ?encoding? data" or "encoding convertfrom -nocomplain ?encoding? data"}
-test cmdAH-4.8 {Tcl_EncodingObjCmd} -returnCodes error -body {
-    encoding convertfrom foo bar
-} -result {unknown encoding "foo"}
-test cmdAH-4.9 {Tcl_EncodingObjCmd} -setup {
+}
+
+# Verify single arg defaults to system encoding
+testconvert cmdAH-4.3.12 {
+    encoding convertfrom \x38\x43
+} \u4e4e -setup {
     set system [encoding system]
-} -body {
     encoding system jis0208
-    encoding convertfrom 8C
 } -cleanup {
     encoding system $system
-} -result 乎
-test cmdAH-4.10 {Tcl_EncodingObjCmd} -setup {
+}
+
+# convertfrom ?-profile? : valid byte sequences
+foreach {enc str hex ctrl comment} $encValidStrings {
+    if {"knownBug" in $ctrl} continue
+    set bytes [binary decode hex $hex]
+    set prefix A
+    set suffix B
+    set prefix_bytes [encoding convertto $enc A]
+    set suffix_bytes [encoding convertto $enc B]
+    foreach profile $encProfiles {
+        testprofile cmdAH-4.3.13.$hex.solo convertfrom $enc $profile $bytes $str
+        testprofile cmdAH-4.3.13.$hex.lead convertfrom $enc $profile $bytes$suffix_bytes $str$suffix
+        testprofile cmdAH-4.3.13.$hex.tail convertfrom $enc $profile $prefix_bytes$bytes $prefix$str
+        testprofile cmdAH-4.3.13.$hex.middle convertfrom $enc $profile $prefix_bytes$bytes$suffix_bytes $prefix$str$suffix
+    }
+}
+
+# convertfrom ?-profile? : invalid byte sequences
+foreach {enc hex profile str failidx ctrl comment} $encInvalidBytes {
+    if {"knownBug" in $ctrl} continue
+    set bytes [binary format H* $hex]
+    set prefix A
+    set suffix B
+    set prefix_bytes [encoding convertto $enc $prefix]
+    set suffix_bytes [encoding convertto $enc $suffix]
+    set prefixLen [string length $prefix_bytes]
+    set result [list $str]
+    # TODO - if the bad byte is unprintable, tcltest errors out when printing a mismatch
+    # so glob it out in error message pattern for now.
+    set errorWithoutPrefix [list "unexpected byte sequence starting at index $failidx: *" -returnCodes error -match glob]
+    set errorWithPrefix [list "unexpected byte sequence starting at index [expr {$failidx+$prefixLen}]: *" -returnCodes error -match glob]
+    if {$ctrl eq {} || "solo" in $ctrl} {
+        if {$failidx == -1} {
+            set result [list $str]
+        } else {
+            set result $errorWithoutPrefix
+        }
+        testprofile cmdAH-4.3.13.$hex.solo convertfrom $enc $profile $bytes {*}$result
+    }
+    if {$ctrl eq {} || "lead" in $ctrl} {
+        if {$failidx == -1} {
+            set result [list $str$suffix]
+        } else {
+            set result $errorWithoutPrefix
+        }
+        testprofile cmdAH-4.3.13.$hex.lead convertfrom $enc $profile $bytes$suffix_bytes {*}$result
+    }
+    if {$ctrl eq {} || "tail" in $ctrl} {
+        if {$failidx == -1} {
+            set result [list $prefix$str]
+        } else {
+            set result $errorWithPrefix
+        }
+        testprofile cmdAH-4.3.13.$hex.tail convertfrom $enc $profile $prefix_bytes$bytes {*}$result
+    }
+    if {$ctrl eq {} || "middle" in $ctrl} {
+        if {$failidx == -1} {
+            set result [list $prefix$str$suffix]
+        } else {
+            set result $errorWithPrefix
+        }
+        testprofile cmdAH-4.3.13.$hex.middle convertfrom $enc $profile $prefix_bytes$bytes$suffix_bytes {*}$result
+    }
+}
+
+# convertfrom -failindex ?-profile? - valid data
+foreach {enc str hex ctrl comment} $encValidStrings {
+    if {"knownBug" in $ctrl} continue
+    set bytes [binary decode hex $hex]
+    set prefix A
+    set suffix B
+    set prefix_bytes [encoding convertto $enc $prefix]
+    set suffix_bytes [encoding convertto $enc $suffix]
+    foreach profile $encProfiles {
+        testfailindex cmdAH-4.3.14.$hex.solo convertfrom $enc $bytes $str -1 $profile
+        testfailindex cmdAH-4.3.14.$hex.lead convertfrom $enc $bytes$suffix_bytes $str$suffix -1 $profile
+        testfailindex cmdAH-4.3.14.$hex.tail convertfrom $enc $prefix_bytes$bytes $prefix$str -1 $profile
+        testfailindex cmdAH-4.3.14.$hex.middle convertfrom $enc $prefix_bytes$bytes$suffix_bytes $prefix$str$suffix -1 $profile
+    }
+}
+
+# convertfrom -failindex ?-profile? - invalid data
+foreach {enc hex profile str failidx ctrl comment} $encInvalidBytes {
+    if {"knownBug" in $ctrl} continue
+    # There are multiple test cases based on location of invalid bytes
+    set bytes [binary decode hex $hex]
+    set prefix A
+    set suffix B
+    set prefix_bytes [encoding convertto $enc $prefix]
+    set suffix_bytes [encoding convertto $enc $suffix]
+    set prefixLen [string length $prefix_bytes]
+    if {$ctrl eq {} || "solo" in $ctrl} {
+        testfailindex cmdAH-4.3.14.$hex.solo convertfrom $enc $bytes $str $failidx $profile
+    }
+    if {$ctrl eq {} || "lead" in $ctrl} {
+        if {$failidx == -1} {
+            # If success expected
+            set result $str$suffix
+        } else {
+            # Failure expected
+            set result ""
+        }
+        testfailindex cmdAH-4.3.14.$hex.lead convertfrom $enc $bytes$suffix_bytes $result $failidx $profile
+    }
+    if {$ctrl eq {} || "tail" in $ctrl} {
+        set expected_failidx $failidx
+        if {$failidx == -1} {
+            # If success expected
+            set result $prefix$str
+        } else {
+            # Failure expected
+            set result $prefix
+            incr expected_failidx $prefixLen
+        }
+        testfailindex cmdAH-4.3.14.$hex.tail convertfrom $enc $prefix_bytes$bytes $result $expected_failidx $profile
+    }
+    if {$ctrl eq {} || "middle" in $ctrl} {
+        set expected_failidx $failidx
+        if {$failidx == -1} {
+            # If success expected
+            set result $prefix$str$suffix
+        } else {
+            # Failure expected
+            set result $prefix
+            incr expected_failidx $prefixLen
+        }
+        testfailindex cmdAH-4.3.14.$hex.middle convertfrom $enc $prefix_bytes$bytes$suffix_bytes $result $expected_failidx $profile
+    }
+}
+
+#
+# encoding convertto 4.4.*
+
+badnumargs cmdAH-4.4.1 {encoding convertto} {}
+badnumargs cmdAH-4.4.2 {encoding convertto} {-failindex VAR ABC}
+badnumargs cmdAH-4.4.3 {encoding convertto} {-profile VAR ABC}
+badnumargs cmdAH-4.4.4 {encoding convertto} {-failindex VAR -profile strict ABC}
+badnumargs cmdAH-4.4.5 {encoding convertto} {-profile strict -failindex VAR ABC}
+
+# Test that last two args always treated as ENCODING DATA
+unknownencodingtest cmdAH-4.4.6 {convertto -failindex ABC}
+unknownencodingtest cmdAH-4.4.7 {convertto -profile ABC}
+unknownencodingtest cmdAH-4.4.8 {convertto nosuchencoding ABC}
+unknownencodingtest cmdAH-4.4.9 {convertto -failindex VAR -profile ABC}
+unknownencodingtest cmdAH-4.4.10 {convertto -profile strict -failindex ABC}
+testconvert cmdAH-4.4.11 {
+    encoding convertto jis0208 \u4e4e
+} \x38\x43 -setup {
     set system [encoding system]
-} -body {
     encoding system iso8859-1
-    encoding convertfrom jis0208 8C
 } -cleanup {
     encoding system $system
-} -result 乎
-test cmdAH-4.11 {Tcl_EncodingObjCmd} -returnCodes error -body {
-    encoding names foo
-} -result {wrong # args: should be "encoding names"}
-test cmdAH-4.12 {Tcl_EncodingObjCmd} -returnCodes error -body {
-    encoding system foo bar
-} -result {wrong # args: should be "encoding system ?encoding?"}
-test cmdAH-4.13 {Tcl_EncodingObjCmd} -setup {
+}
+
+# Verify single arg defaults to system encoding
+testconvert cmdAH-4.4.12 {
+    encoding convertto \u4e4e
+} \x38\x43 -setup {
     set system [encoding system]
-} -body {
-    encoding system iso8859-1
-    encoding system
+    encoding system jis0208
 } -cleanup {
     encoding system $system
-} -result iso8859-1
+}
+
+# convertto ?-profile? : valid byte sequences
 
-test cmdAH-4.14.1 {Syntax error, -nocomplain and -failindex, no encoding} -body {
-    encoding convertfrom -nocomplain -failindex 2 ABC
-} -returnCodes 1 -result {wrong # args: should be "encoding convertfrom ?-strict? ?-failindex var? ?encoding? data" or "encoding convertfrom -nocomplain ?encoding? data"}
-test cmdAH-4.14.2 {Syntax error, -nocomplain and -failindex, no encoding} -body {
-    encoding convertto -nocomplain -failindex 2 ABC
-} -returnCodes 1 -result {wrong # args: should be "encoding convertto ?-strict? ?-failindex var? ?encoding? data" or "encoding convertto -nocomplain ?encoding? data"}
-test cmdAH-4.15.1 {Syntax error, -failindex and -nocomplain, no encoding} -body {
-    encoding convertfrom -failindex 2 -nocomplain ABC
-} -returnCodes 1 -result {unknown encoding "-nocomplain"}
-test cmdAH-4.15.2 {Syntax error, -failindex and -nocomplain, no encoding} -body {
-    encoding convertto -failindex 2 -nocomplain ABC
-} -returnCodes 1 -result {unknown encoding "-nocomplain"}
-test cmdAH-4.16.1 {Syntax error, -nocomplain and -failindex, encoding} -body {
-    encoding convertfrom -nocomplain -failindex 2 utf-8 ABC
-} -returnCodes 1 -result {wrong # args: should be "encoding convertfrom ?-strict? ?-failindex var? ?encoding? data" or "encoding convertfrom -nocomplain ?encoding? data"}
-test cmdAH-4.16.2 {Syntax error, -nocomplain and -failindex, encoding} -body {
-    encoding convertto -nocomplain -failindex 2 utf-8 ABC
-} -returnCodes 1 -result {wrong # args: should be "encoding convertto ?-strict? ?-failindex var? ?encoding? data" or "encoding convertto -nocomplain ?encoding? data"}
-test cmdAH-4.17.1 {Syntax error, -failindex and -nocomplain, encoding} -body {
-    encoding convertfrom -failindex 2 -nocomplain utf-8 ABC
-} -returnCodes 1 -result {wrong # args: should be "encoding convertfrom ?-strict? ?-failindex var? ?encoding? data" or "encoding convertfrom -nocomplain ?encoding? data"}
-test cmdAH-4.17.2 {Syntax error, -failindex and -nocomplain, encoding} -body {
-    encoding convertto -failindex 2 -nocomplain utf-8 ABC
-} -returnCodes 1 -result {wrong # args: should be "encoding convertto ?-strict? ?-failindex var? ?encoding? data" or "encoding convertto -nocomplain ?encoding? data"}
-test cmdAH-4.18.1 {Syntax error, -failindex with no var, no encoding} -body {
-    encoding convertfrom -failindex ABC
-} -returnCodes 1 -result {wrong # args: should be "::tcl::encoding::convertfrom ?-strict? ?-failindex var? ?encoding? data" or "::tcl::encoding::convertfrom -nocomplain ?encoding? data"}
-test cmdAH-4.18.2 {Syntax error, -failindex with no var, no encoding (byte compiled)} -setup {
-    proc encoding_test {} {
-        encoding convertfrom -failindex ABC
+foreach {enc str hex ctrl comment} $encValidStrings {
+    if {"knownBug" in $ctrl} continue
+    set bytes [binary decode hex $hex]
+    set printable [printable $str]
+    set prefix A
+    set suffix B
+    set prefix_bytes [encoding convertto $enc A]
+    set suffix_bytes [encoding convertto $enc B]
+    foreach profile $encProfiles {
+        testprofile cmdAH-4.4.13.$printable.solo convertto $enc $profile $str $bytes
+        testprofile cmdAH-4.4.13.$printable.lead convertto $enc $profile $str$suffix $bytes$suffix_bytes
+        testprofile cmdAH-4.4.13.$printable.tail convertto $enc $profile $prefix$str $prefix_bytes$bytes
+        testprofile cmdAH-4.4.13.$printable.middle convertto $enc $profile $prefix$str$suffix $prefix_bytes$bytes$suffix_bytes
     }
-} -body {
-    # Compile and execute
-    encoding_test
-} -returnCodes 1 -result {wrong # args: should be "::tcl::encoding::convertfrom ?-strict? ?-failindex var? ?encoding? data" or "::tcl::encoding::convertfrom -nocomplain ?encoding? data"} -cleanup {
-    rename encoding_test ""
 }
-test cmdAH-4.18.3 {Syntax error, -failindex with no var, no encoding} -body {
-    encoding convertto -failindex ABC
-} -returnCodes 1 -result {wrong # args: should be "::tcl::encoding::convertto ?-strict? ?-failindex var? ?encoding? data" or "::tcl::encoding::convertto -nocomplain ?encoding? data"}
-test cmdAH-4.18.4 {Syntax error, -failindex with no var, no encoding (byte compiled)} -setup {
-    proc encoding_test {} {
-        encoding convertto -failindex ABC
+
+# convertto ?-profile? : invalid byte sequences
+foreach {enc str profile hex failidx ctrl comment} $encUnencodableStrings {
+    if {"knownBug" in $ctrl} continue
+    set bytes [binary decode hex $hex]
+    set printable [printable $str]
+    set prefix A
+    set suffix B
+    set prefix_bytes [encoding convertto $enc $prefix]
+    set suffix_bytes [encoding convertto $enc $suffix]
+    set prefixLen [string length $prefix_bytes]
+    set result [list $bytes]
+    # TODO - if the bad byte is unprintable, tcltest errors out when printing a mismatch
+    # so glob it out in error message pattern for now.
+    set errorWithoutPrefix [list "unexpected character at index $failidx: *" -returnCodes error -match glob]
+    set errorWithPrefix [list "unexpected character at index [expr {$failidx+$prefixLen}]: *" -returnCodes error -match glob]
+    if {$ctrl eq {} || "solo" in $ctrl} {
+        if {$failidx == -1} {
+            set result [list $bytes]
+        } else {
+            set result $errorWithoutPrefix
+        }
+        testprofile cmdAH-4.4.13.$printable.solo convertto $enc $profile $str {*}$result
     }
-} -body {
-    # Compile and execute
-    encoding_test
-} -returnCodes 1 -result {wrong # args: should be "::tcl::encoding::convertto ?-strict? ?-failindex var? ?encoding? data" or "::tcl::encoding::convertto -nocomplain ?encoding? data"} -cleanup {
-    rename encoding_test ""
-}
-test cmdAH-4.19.1 {convertrom -failindex with correct data} -body {
-    encoding convertfrom -failindex test ABC
-    set test
-} -returnCodes 0 -result -1
-test cmdAH-4.19.2 {convertrom -failindex with correct data (byt compiled)} -setup {
-    proc encoding_test {} {
-	encoding convertfrom -failindex test ABC
-	set test
+    if {$ctrl eq {} || "lead" in $ctrl} {
+        if {$failidx == -1} {
+            set result [list $bytes$suffix_bytes]
+        } else {
+            set result $errorWithoutPrefix
+        }
+        testprofile cmdAH-4.4.13.$printable.lead convertto $enc $profile $str$suffix {*}$result
     }
-} -body {
-    # Compile and execute
-    encoding_test
-} -returnCodes 0 -result -1 -cleanup {
-    rename encoding_test ""
-}
-test cmdAH-4.19.3 {convertrom -failindex with correct data} -body {
-    encoding convertto -failindex test ABC
-    set test
-} -returnCodes 0 -result -1
-test cmdAH-4.19.4 {convertrom -failindex with correct data (byt compiled)} -setup {
-    proc encoding_test {} {
-	encoding convertto -failindex test ABC
-	set test
+    if {$ctrl eq {} || "tail" in $ctrl} {
+        if {$failidx == -1} {
+            set result [list $prefix_bytes$bytes]
+        } else {
+            set result $errorWithPrefix
+        }
+        testprofile cmdAH-4.4.13.$printable.tail convertto $enc $profile $prefix$str {*}$result
     }
-} -body {
-    # Compile and execute
-    encoding_test
-} -returnCodes 0 -result -1 -cleanup {
-    rename encoding_test ""
-}
-test cmdAH-4.20.1 {convertrom -failindex with incomplete utf8} -body {
-    set x [encoding convertfrom -failindex i utf-8 A\xc3]
-    binary scan $x H* y
-    list $y $i
-} -returnCodes 0 -result {41 1}
-test cmdAH-4.20.2 {convertrom -failindex with incomplete utf8 (byte compiled)} -setup {
-    proc encoding_test {} {
-	set x [encoding convertfrom -failindex i utf-8 A\xc3]
-	binary scan $x H* y
-	list $y $i
+    if {$ctrl eq {} || "middle" in $ctrl} {
+        if {$failidx == -1} {
+            set result [list $prefix_bytes$bytes$suffix_bytes]
+        } else {
+            set result $errorWithPrefix
+        }
+        testprofile cmdAH-4.4.13.$printable.middle convertto $enc $profile $prefix$str$suffix {*}$result
     }
-} -body {
-    # Compile and execute
-    encoding_test
-} -returnCodes 0 -result {41 1} -cleanup {
-    rename encoding_test ""
 }
-test cmdAH-4.20.3 {convertrom -failindex with incomplete utf8} -body {
-    set x [encoding convertfrom -strict -failindex i utf-8 A\xc3]
-    binary scan $x H* y
-    list $y $i
-} -returnCodes 0 -result {41 1}
-test cmdAH-4.20.4 {convertrom -failindex with incomplete utf8 (byte compiled)} -setup {
-    proc encoding_test {} {
-	set x [encoding convertfrom -strict -failindex i utf-8 A\xc3]
-	binary scan $x H* y
-	list $y $i
+
+# convertto -failindex ?-profile? - valid data
+foreach {enc str hex ctrl comment} $encValidStrings {
+    if {"knownBug" in $ctrl} continue
+    set bytes [binary decode hex $hex]
+    set printable [printable $str]
+    set prefix A
+    set suffix B
+    set prefix_bytes [encoding convertto $enc A]
+    set suffix_bytes [encoding convertto $enc B]
+    foreach profile $encProfiles {
+        testfailindex cmdAH-4.4.14.$enc.$printable.solo convertto $enc $str $bytes -1 $profile
+        testfailindex cmdAH-4.4.14.$enc.$printable.lead convertto $enc $str$suffix $bytes$suffix_bytes -1 $profile
+        testfailindex cmdAH-4.4.14.$enc.$printable.tail convertto $enc $prefix$str $prefix_bytes$bytes -1 $profile
+        testfailindex cmdAH-4.4.14.$enc.$printable.middle convertto $enc $prefix$str$suffix $prefix_bytes$bytes$suffix_bytes -1 $profile
     }
-} -body {
-    # Compile and execute
-    encoding_test
-} -returnCodes 0 -result {41 1} -cleanup {
-    rename encoding_test ""
 }
-test cmdAH-4.20.5 {convertrom -failindex with incomplete utf8} -body {
-    set x [encoding convertfrom -failindex i -strict utf-8 A\xc3]
-    binary scan $x H* y
-    list $y $i
-} -returnCodes 0 -result {41 1}
-test cmdAH-4.20.6 {convertrom -failindex with incomplete utf8 (byte compiled)} -setup {
-    proc encoding_test {} {
-	set x [encoding convertfrom -failindex i -strict utf-8 A\xc3]
-	binary scan $x H* y
-	list $y $i
+
+# convertto -failindex ?-profile? - invalid data
+foreach {enc str profile hex failidx ctrl comment} $encUnencodableStrings {
+    if {"knownBug" in $ctrl} continue
+    set bytes [binary decode hex $hex]
+    set printable [printable $str]
+    set prefix A
+    set suffix B
+    set prefixLen [string length [encoding convertto $enc $prefix]]
+    if {$ctrl eq {} || "solo" in $ctrl} {
+        testfailindex cmdAH-4.4.14.$printable.solo convertto $enc $str $bytes $failidx $profile
     }
-} -body {
-    # Compile and execute
-    encoding_test
-} -returnCodes 0 -result {41 1} -cleanup {
-    rename encoding_test ""
-}
-test cmdAH-4.21.1 {convertto -failindex with wrong character} -body {
-    set x [encoding convertto -failindex i iso8859-1 A\u0141]
-    binary scan $x H* y
-    list $y $i
-} -returnCodes 0 -result {41 1}
-test cmdAH-4.21.2 {convertto -failindex with wrong character (byte compiled)} -setup {
-    proc encoding_test {} {
-    set x [encoding convertto -failindex i iso8859-1 A\u0141]
-	binary scan $x H* y
-	list $y $i
+    if {$ctrl eq {} || "lead" in $ctrl} {
+        if {$failidx == -1} {
+            # If success expected
+            set result $bytes$suffix
+        } else {
+            # Failure expected
+            set result ""
+        }
+        testfailindex cmdAH-4.4.14.$printable.lead convertto $enc $str$suffix $result $failidx $profile
+    }
+    if {$ctrl eq {} || "tail" in $ctrl} {
+        set expected_failidx $failidx
+        if {$failidx == -1} {
+            # If success expected
+            set result $prefix$bytes
+        } else {
+            # Failure expected
+            set result $prefix
+            incr expected_failidx $prefixLen
+        }
+        testfailindex cmdAH-4.4.14.$printable.tail convertto $enc $prefix$str $result $expected_failidx $profile
+    }
+    if {$ctrl eq {} || "middle" in $ctrl} {
+        set expected_failidx $failidx
+        if {$failidx == -1} {
+            # If success expected
+            set result $prefix$bytes$suffix
+        } else {
+            # Failure expected
+            set result $prefix
+            incr expected_failidx $prefixLen
+        }
+        testfailindex cmdAH-4.4.14.$printable.middle convertto $enc $prefix$str$suffix $result $expected_failidx $profile
     }
-} -body {
-    # Compile and execute
-    encoding_test
-} -returnCodes 0 -result {41 1} -cleanup {
-    rename encoding_test ""
 }
-test cmdAH-4.22 {convertfrom -strict} -body {
-    encoding convertfrom -strict utf-8 A\x00B
-} -result A\x00B
 
-test cmdAH-4.23 {convertfrom -strict} -body {
-    encoding convertfrom -strict utf-8 A\xC0\x80B
-} -returnCodes error -result {unexpected byte sequence starting at index 1: '\xC0'}
+test cmdAH-4.4.xx {convertto -profile strict} -constraints {testbytestring knownBug} -body {
+    # TODO - what does testbytestring even test? Invalid UTF8 in the Tcl_Obj bytes field
+    encoding convertto -profile strict utf-8 A[testbytestring \x80]B
+} -returnCodes error -result {unexpected byte sequence starting at index 1: '\x80'}
 
-test cmdAH-4.24 {convertto -strict} -body {
-    encoding convertto -strict utf-8 A\x00B
-} -result A\x00B
+#
+# encoding names 4.5.*
+badnumargs cmdAH-4.5.1 {encoding names} {foo}
+test cmdAH-4.5.2 {encoding names should include at least utf-8 and iso8859-1 and at least one more} -body {
+    set names [encoding names]
+    list [expr {"utf-8" in $names}] [expr {"iso8859-1" in $names}] [expr {[llength $names] > 2}]
+} -result {1 1 1}
 
-test cmdAH-4.25 {convertfrom -strict} -constraints knownBug -body {
-    encoding convertfrom -strict utf-8 A\x80B
-} -returnCodes error -result {unexpected byte sequence starting at index 1: '\x80'}
+#
+# encoding profiles 4.6.*
+badnumargs cmdAH-4.6.1 {encoding profiles} {foo}
+test cmdAH-4.6.2 {encoding profiles} -body {
+    lsort [encoding profiles]
+} -result {replace strict tcl8}
 
-test cmdAH-4.26 {convertto -strict} -constraints {testbytestring knownBug} -body {
-    encoding convertto -strict utf-8 A[testbytestring \x80]B
-} -returnCodes error -result {unexpected byte sequence starting at index 1: '\x80'}
+#
+# file command
 
 test cmdAH-5.1 {Tcl_FileObjCmd} -returnCodes error -body {
     file
diff --git a/tests/encoding.test b/tests/encoding.test
index e0e1598..2deda8d 100644
--- a/tests/encoding.test
+++ b/tests/encoding.test
@@ -300,7 +300,7 @@ test encoding-11.11 {encoding: extended Unicode UTF-32} {
 
 test encoding-12.1 {LoadTableEncoding: normal encoding} {
     set x [encoding convertto iso8859-3 Ġ]
-    append x [encoding convertto -nocomplain iso8859-3 Õ]
+    append x [encoding convertto -profile tcl8 iso8859-3 Õ]
     append x [encoding convertfrom iso8859-3 Õ]
 } "Õ?Ġ"
 test encoding-12.2 {LoadTableEncoding: single-byte encoding} {
@@ -339,7 +339,7 @@ test encoding-15.3 {UtfToUtfProc null character input} teststringbytes {
 } c080
 test encoding-15.4 {UtfToUtfProc emoji character input} -body {
     set x \xED\xA0\xBD\xED\xB8\x82
-    set y [encoding convertfrom -nocomplain utf-8 \xED\xA0\xBD\xED\xB8\x82]
+    set y [encoding convertfrom -profile tcl8 utf-8 \xED\xA0\xBD\xED\xB8\x82]
     list [string length $x] $y
 } -result "6 \uD83D\uDE02"
 test encoding-15.5 {UtfToUtfProc emoji character input} {
@@ -349,67 +349,67 @@ test encoding-15.5 {UtfToUtfProc emoji character input} {
 } "4 😂"
 test encoding-15.6 {UtfToUtfProc emoji character output} utf32 {
     set x \uDE02\uD83D\uDE02\uD83D
-    set y [encoding convertto -nocomplain utf-8 \uDE02\uD83D\uDE02\uD83D]
+    set y [encoding convertto -profile tcl8 utf-8 \uDE02\uD83D\uDE02\uD83D]
     binary scan $y H* z
     list [string length $y] $z
 } {12 edb882eda0bdedb882eda0bd}
 test encoding-15.7 {UtfToUtfProc emoji character output} {
     set x \uDE02\uD83D\uD83D
-    set y [encoding convertto -nocomplain utf-8 \uDE02\uD83D\uD83D]
+    set y [encoding convertto -profile tcl8 utf-8 \uDE02\uD83D\uD83D]
     binary scan $y H* z
     list [string length $x] [string length $y] $z
 } {3 9 edb882eda0bdeda0bd}
 test encoding-15.8 {UtfToUtfProc emoji character output} {
     set x \uDE02\uD83Dé
-    set y [encoding convertto -nocomplain utf-8 \uDE02\uD83Dé]
+    set y [encoding convertto -profile tcl8 utf-8 \uDE02\uD83Dé]
     binary scan $y H* z
     list [string length $x] [string length $y] $z
 } {3 8 edb882eda0bdc3a9}
 test encoding-15.9 {UtfToUtfProc emoji character output} {
     set x \uDE02\uD83DX
-    set y [encoding convertto -nocomplain utf-8 \uDE02\uD83DX]
+    set y [encoding convertto -profile tcl8 utf-8 \uDE02\uD83DX]
     binary scan $y H* z
     list [string length $x] [string length $y] $z
 } {3 7 edb882eda0bd58}
 test encoding-15.10 {UtfToUtfProc high surrogate character output} {
     set x \uDE02é
-    set y [encoding convertto -nocomplain utf-8 \uDE02é]
+    set y [encoding convertto -profile tcl8 utf-8 \uDE02é]
     binary scan $y H* z
     list [string length $x] [string length $y] $z
 } {2 5 edb882c3a9}
 test encoding-15.11 {UtfToUtfProc low surrogate character output} {
     set x \uDA02é
-    set y [encoding convertto -nocomplain utf-8 \uDA02é]
+    set y [encoding convertto -profile tcl8 utf-8 \uDA02é]
     binary scan $y H* z
     list [string length $x] [string length $y] $z
 } {2 5 eda882c3a9}
 test encoding-15.12 {UtfToUtfProc high surrogate character output} {
     set x \uDE02Y
-    set y [encoding convertto -nocomplain utf-8 \uDE02Y]
+    set y [encoding convertto -profile tcl8 utf-8 \uDE02Y]
     binary scan $y H* z
     list [string length $x] [string length $y] $z
 } {2 4 edb88259}
 test encoding-15.13 {UtfToUtfProc low surrogate character output} {
     set x \uDA02Y
-    set y [encoding convertto -nocomplain utf-8 \uDA02Y]
+    set y [encoding convertto -profile tcl8 utf-8 \uDA02Y]
     binary scan $y H* z
     list [string length $x] [string length $y] $z
 } {2 4 eda88259}
 test encoding-15.14 {UtfToUtfProc high surrogate character output} {
     set x \uDE02
-    set y [encoding convertto -nocomplain utf-8 \uDE02]
+    set y [encoding convertto -profile tcl8 utf-8 \uDE02]
     binary scan $y H* z
     list [string length $x] [string length $y] $z
 } {1 3 edb882}
 test encoding-15.15 {UtfToUtfProc low surrogate character output} {
     set x \uDA02
-    set y [encoding convertto -nocomplain utf-8 \uDA02]
+    set y [encoding convertto -profile tcl8 utf-8 \uDA02]
     binary scan $y H* z
     list [string length $x] [string length $y] $z
 } {1 3 eda882}
 test encoding-15.16 {UtfToUtfProc: Invalid 4-byte UTF-8, see [ed29806ba]} {
     set x \xF0\xA0\xA1\xC2
-    set y [encoding convertfrom -nocomplain utf-8 \xF0\xA0\xA1\xC2]
+    set y [encoding convertfrom -profile tcl8 utf-8 \xF0\xA0\xA1\xC2]
     list [string length $x] $y
 } "4 \xF0\xA0\xA1\xC2"
 test encoding-15.17 {UtfToUtfProc emoji character output} {
@@ -459,20 +459,20 @@ test encoding-15.25 {UtfToUtfProc CESU-8} {
 test encoding-15.26 {UtfToUtfProc CESU-8} {
     encoding convertfrom cesu-8 \xC0\x80
 } \x00
-test encoding-15.27 {UtfToUtfProc -strict CESU-8} {
-    encoding convertfrom -strict cesu-8 \x00
+test encoding-15.27 {UtfToUtfProc -profile strict CESU-8} {
+    encoding convertfrom -profile strict cesu-8 \x00
 } \x00
-test encoding-15.28 {UtfToUtfProc -strict CESU-8} -body {
-    encoding convertfrom -strict cesu-8 \xC0\x80
+test encoding-15.28 {UtfToUtfProc -profile strict CESU-8} -body {
+    encoding convertfrom -profile strict cesu-8 \xC0\x80
 } -returnCodes 1 -result {unexpected byte sequence starting at index 0: '\xC0'}
 test encoding-15.29 {UtfToUtfProc CESU-8} {
     encoding convertto cesu-8 \x00
 } \x00
-test encoding-15.30 {UtfToUtfProc -strict CESU-8} {
-    encoding convertto -strict cesu-8 \x00
+test encoding-15.30 {UtfToUtfProc -profile strict CESU-8} {
+    encoding convertto -profile strict cesu-8 \x00
 } \x00
-test encoding-15.31 {UtfToUtfProc -strict CESU-8 (bytes F0-F4 are invalid)} -body {
-    encoding convertfrom -strict cesu-8 \xF1\x86\x83\x9C
+test encoding-15.31 {UtfToUtfProc -profile strict CESU-8 (bytes F0-F4 are invalid)} -body {
+    encoding convertfrom -profile strict cesu-8 \xF1\x86\x83\x9C
 } -returnCodes 1 -result {unexpected byte sequence starting at index 0: '\xF1'}
 
 test encoding-16.1 {Utf16ToUtfProc} -body {
@@ -504,7 +504,7 @@ test encoding-16.7 {Utf32ToUtfProc} -body {
     list $val [format %x [scan $val %c]]
 } -result "乎 4e4e"
 test encoding-16.8 {Utf32ToUtfProc} -body {
-    set val [encoding convertfrom -nocomplain utf-32 \x41\x00\x00\x41]
+    set val [encoding convertfrom -profile tcl8 utf-32 \x41\x00\x00\x41]
     list $val [format %x [scan $val %c]]
 } -result "\uFFFD fffd"
 test encoding-16.9 {Utf32ToUtfProc} -constraints utf32 -body {
@@ -532,7 +532,7 @@ test encoding-16.16 {Utf16ToUtfProc} -body {
     encoding convertfrom utf-16le \x00\xDC\x00\xD8
 } -result \uDC00\uD800
 test encoding-16.17 {Utf32ToUtfProc} -body {
-    list [encoding convertfrom -strict -failindex  idx utf-32le \x41\x00\x00\x00\x00\xD8\x00\x00\x42\x00\x00\x00] [set idx]
+    list [encoding convertfrom -profile strict -failindex  idx utf-32le \x41\x00\x00\x00\x00\xD8\x00\x00\x42\x00\x00\x00] [set idx]
 } -result {A 4}
 
 test encoding-16.18 {
@@ -571,10 +571,10 @@ test encoding-17.2 {UtfToUcs2Proc} -body {
     encoding convertfrom utf-16 \xD8\xD8\xDC\xDC
 } -result "\U460DC"
 test encoding-17.3 {UtfToUtf16Proc} -body {
-    encoding convertto -nocomplain utf-16be "\uDCDC"
+    encoding convertto -profile tcl8 utf-16be "\uDCDC"
 } -result "\xDC\xDC"
 test encoding-17.4 {UtfToUtf16Proc} -body {
-    encoding convertto -nocomplain utf-16le "\uD8D8"
+    encoding convertto -profile tcl8 utf-16le "\uD8D8"
 } -result "\xD8\xD8"
 test encoding-17.5 {UtfToUtf16Proc} -body {
     encoding convertto utf-32le "\U460DC"
@@ -583,54 +583,54 @@ test encoding-17.6 {UtfToUtf16Proc} -body {
     encoding convertto utf-32be "\U460DC"
 } -result "\x00\x04\x60\xDC"
 test encoding-17.7 {UtfToUtf16Proc} -body {
-    encoding convertto -strict utf-16be "\uDCDC"
+    encoding convertto -profile strict utf-16be "\uDCDC"
 } -returnCodes error -result {unexpected character at index 0: 'U+00DCDC'}
 test encoding-17.8 {UtfToUtf16Proc} -body {
-    encoding convertto -strict utf-16le "\uD8D8"
+    encoding convertto -profile strict utf-16le "\uD8D8"
 } -returnCodes error -result {unexpected character at index 0: 'U+00D8D8'}
 test encoding-17.9 {Utf32ToUtfProc} -body {
-    encoding convertfrom -strict utf-32 "\xFF\xFF\xFF\xFF"
+    encoding convertfrom -profile strict utf-32 "\xFF\xFF\xFF\xFF"
 } -returnCodes error -result {unexpected byte sequence starting at index 0: '\xFF'}
 test encoding-17.10 {Utf32ToUtfProc} -body {
-    encoding convertfrom -nocomplain utf-32 "\xFF\xFF\xFF\xFF"
+    encoding convertfrom -profile tcl8 utf-32 "\xFF\xFF\xFF\xFF"
 } -result \uFFFD
 
 test encoding-18.1 {TableToUtfProc on invalid input} -body {
 	list [catch {encoding convertto jis0208 \\} res] $res
 } -result {1 {unexpected character at index 0: 'U+00005C'}}
-test encoding-18.2 {TableToUtfProc on invalid input with -strict} -body {
-	list [catch {encoding convertto -strict jis0208 \\} res] $res
+test encoding-18.2 {TableToUtfProc on invalid input with -profile strict} -body {
+	list [catch {encoding convertto -profile strict jis0208 \\} res] $res
 } -result {1 {unexpected character at index 0: 'U+00005C'}}
-test encoding-18.3 {TableToUtfProc on invalid input with -strict -failindex} -body {
-	list [catch {encoding convertto -strict -failindex pos jis0208 \\} res] $res $pos
+test encoding-18.3 {TableToUtfProc on invalid input with -profile strict -failindex} -body {
+	list [catch {encoding convertto -profile strict -failindex pos jis0208 \\} res] $res $pos
 } -result {0 {} 0}
-test encoding-18.4 {TableToUtfProc on invalid input with -failindex -strict} -body {
-	list [catch {encoding convertto -failindex pos -strict jis0208 \\} res] $res $pos
+test encoding-18.4 {TableToUtfProc on invalid input with -failindex -profile strict} -body {
+	list [catch {encoding convertto -failindex pos -profile strict jis0208 \\} res] $res $pos
 } -result {0 {} 0}
 test encoding-18.5 {TableToUtfProc on invalid input with -failindex} -body {
 	list [catch {encoding convertto -failindex pos jis0208 \\} res] $res $pos
-} -result {0 {} 0}
-test encoding-18.6 {TableToUtfProc on invalid input with -nocomplain} -body {
-	list [catch {encoding convertto -nocomplain jis0208 \\} res] $res
+} -result {0 !) -1}
+test encoding-18.6 {TableToUtfProc on invalid input with -profile tcl8} -body {
+	list [catch {encoding convertto -profile tcl8 jis0208 \\} res] $res
 } -result {0 !)}
 
 test encoding-19.1 {TableFromUtfProc} -body {
     encoding convertfrom ascii AÁ
 } -result AÁ
 test encoding-19.2 {TableFromUtfProc} -body {
-    encoding convertfrom -nocomplain ascii AÁ
+    encoding convertfrom -profile tcl8 ascii AÁ
 } -result AÁ
 test encoding-19.3 {TableFromUtfProc} -body {
-    encoding convertfrom -strict ascii AÁ
+    encoding convertfrom -profile strict ascii AÁ
 } -returnCodes 1 -result {unexpected byte sequence starting at index 1: '\xC1'}
 test encoding-19.4 {TableFromUtfProc} -body {
     list [encoding convertfrom -failindex idx ascii AÁ] [set idx]
-} -result {A 1}
+} -result [list A\xC1 -1]
 test encoding-19.5 {TableFromUtfProc} -body {
-    list [encoding convertfrom -failindex idx -strict ascii AÁ] [set idx]
+    list [encoding convertfrom -failindex idx -profile strict ascii A\xC1] [set idx]
 } -result {A 1}
 test encoding-19.6 {TableFromUtfProc} -body {
-    list [encoding convertfrom -failindex idx -strict ascii AÁB] [set idx]
+    list [encoding convertfrom -failindex idx -profile strict ascii AÁB] [set idx]
 } -result {A 1}
 
 test encoding-20.1 {TableFreefProc} {
@@ -743,31 +743,31 @@ test encoding-24.4 {Parse valid or invalid utf-8} {
     string length [encoding convertfrom utf-8 "\xC0\x80"]
 } 1
 test encoding-24.5 {Parse valid or invalid utf-8} {
-    string length [encoding convertfrom -nocomplain utf-8 "\xC0\x81"]
+    string length [encoding convertfrom -profile tcl8 utf-8 "\xC0\x81"]
 } 2
 test encoding-24.6 {Parse valid or invalid utf-8} {
-    string length [encoding convertfrom -nocomplain utf-8 "\xC1\xBF"]
+    string length [encoding convertfrom -profile tcl8 utf-8 "\xC1\xBF"]
 } 2
 test encoding-24.7 {Parse valid or invalid utf-8} {
     string length [encoding convertfrom utf-8 "\xC2\x80"]
 } 1
 test encoding-24.8 {Parse valid or invalid utf-8} {
-    string length [encoding convertfrom -nocomplain utf-8 "\xE0\x80\x80"]
+    string length [encoding convertfrom -profile tcl8 utf-8 "\xE0\x80\x80"]
 } 3
 test encoding-24.9 {Parse valid or invalid utf-8} {
-    string length [encoding convertfrom -nocomplain utf-8 "\xE0\x9F\xBF"]
+    string length [encoding convertfrom -profile tcl8 utf-8 "\xE0\x9F\xBF"]
 } 3
 test encoding-24.10 {Parse valid or invalid utf-8} {
     string length [encoding convertfrom utf-8 "\xE0\xA0\x80"]
 } 1
 test encoding-24.11 {Parse valid or invalid utf-8} {
-    string length [encoding convertfrom -nocomplain utf-8 "\xEF\xBF\xBF"]
+    string length [encoding convertfrom -profile tcl8 utf-8 "\xEF\xBF\xBF"]
 } 1
 test encoding-24.12 {Parse valid or invalid utf-8} -body {
-    encoding convertfrom -strict utf-8 "\xC0\x81"
+    encoding convertfrom -profile strict utf-8 "\xC0\x81"
 } -returnCodes 1 -result {unexpected byte sequence starting at index 0: '\xC0'}
 test encoding-24.13 {Parse valid or invalid utf-8} -body {
-    encoding convertfrom -strict utf-8 "\xC1\xBF"
+    encoding convertfrom -profile strict utf-8 "\xC1\xBF"
 } -returnCodes 1 -result {unexpected byte sequence starting at index 0: '\xC1'}
 test encoding-24.14 {Parse valid or invalid utf-8} {
     string length [encoding convertfrom utf-8 "\xC2\x80"]
@@ -787,83 +787,83 @@ test encoding-24.18 {Parse valid or invalid utf-8} -constraints testbytestring -
 test encoding-24.19 {Parse valid or invalid utf-8} -body {
     encoding convertto utf-8 "ZX\uD800"
 } -returnCodes 1 -match glob -result "unexpected character at index 2: 'U+00D800'"
-test encoding-24.20 {Parse with -nocomplain but without providing encoding} {
-    string length [encoding convertfrom -nocomplain "\x20"]
-} 1
-test encoding-24.21 {Parse with -nocomplain but without providing encoding} {
-    string length [encoding convertto -nocomplain "\x20"]
-} 1
+test encoding-24.20 {Parse with -profile tcl8 but without providing encoding} -body {
+    encoding convertfrom -profile tcl8 "\x20"
+} -result {wrong # args: should be "::tcl::encoding::convertfrom ?-profile profile? ?-failindex var? encoding data" or "::tcl::encoding::convertfrom data"} -returnCodes error
+test encoding-24.21 {Parse with -profile tcl8 but without providing encoding} -body {
+    string length [encoding convertto -profile tcl8 "\x20"]
+} -result {wrong # args: should be "::tcl::encoding::convertto ?-profile profile? ?-failindex var? encoding data" or "::tcl::encoding::convertto data"} -returnCodes error
 test encoding-24.22 {Syntax error, two encodings} -body {
     encoding convertfrom iso8859-1 utf-8 "ZX\uD800"
-} -returnCodes 1 -result {wrong # args: should be "::tcl::encoding::convertfrom ?-strict? ?-failindex var? ?encoding? data" or "::tcl::encoding::convertfrom -nocomplain ?encoding? data"}
+} -result {bad option "iso8859-1": must be -profile or -failindex} -returnCodes error
 test encoding-24.23 {Syntax error, two encodings} -body {
     encoding convertto iso8859-1 utf-8 "ZX\uD800"
-} -returnCodes 1 -result {wrong # args: should be "::tcl::encoding::convertto ?-strict? ?-failindex var? ?encoding? data" or "::tcl::encoding::convertto -nocomplain ?encoding? data"}
-test encoding-24.24 {Parse invalid utf-8 with -strict} -body {
-    encoding convertfrom -strict utf-8 "\xC0\x80\x00\x00"
+} -result {bad option "iso8859-1": must be -profile or -failindex} -returnCodes error
+test encoding-24.24 {Parse invalid utf-8 with -profile strict} -body {
+    encoding convertfrom -profile strict utf-8 "\xC0\x80\x00\x00"
 } -returnCodes 1 -result {unexpected byte sequence starting at index 0: '\xC0'}
-test encoding-24.25 {Parse invalid utf-8 with -strict} -body {
-    encoding convertfrom -strict utf-8 "\x40\x80\x00\x00"
+test encoding-24.25 {Parse invalid utf-8 with -profile strict} -body {
+    encoding convertfrom -profile strict utf-8 "\x40\x80\x00\x00"
 } -returnCodes 1 -result {unexpected byte sequence starting at index 1: '\x80'}
-test encoding-24.26 {Parse valid utf-8 with -strict} -body {
-    encoding convertfrom -strict utf-8 "\xF1\x80\x80\x80"
+test encoding-24.26 {Parse valid utf-8 with -profile strict} -body {
+    encoding convertfrom -profile strict utf-8 "\xF1\x80\x80\x80"
 } -result \U40000
-test encoding-24.27 {Parse invalid utf-8 with -strict} -body {
-    encoding convertfrom -strict utf-8 "\xF0\x80\x80\x80"
+test encoding-24.27 {Parse invalid utf-8 with -profile strict} -body {
+    encoding convertfrom -profile strict utf-8 "\xF0\x80\x80\x80"
 } -returnCodes 1 -result {unexpected byte sequence starting at index 0: '\xF0'}
-test encoding-24.28 {Parse invalid utf-8 with -strict} -body {
-    encoding convertfrom -strict utf-8 "\xFF\x00\x00"
+test encoding-24.28 {Parse invalid utf-8 with -profile strict} -body {
+    encoding convertfrom -profile strict utf-8 "\xFF\x00\x00"
 } -returnCodes 1 -result {unexpected byte sequence starting at index 0: '\xFF'}
 test encoding-24.29 {Parse invalid utf-8} -body {
     encoding convertfrom utf-8 \xEF\xBF\xBF
 } -result \uFFFF
-test encoding-24.30 {Parse noncharacter with -strict} -body {
-    encoding convertfrom -strict utf-8 \xEF\xBF\xBF
+test encoding-24.30 {Parse noncharacter with -profile strict} -body {
+    encoding convertfrom -profile strict utf-8 \xEF\xBF\xBF
 } -result \uFFFF
-test encoding-24.31 {Parse invalid utf-8 with -nocomplain} -body {
-    encoding convertfrom -nocomplain utf-8 \xEF\xBF\xBF
+test encoding-24.31 {Parse invalid utf-8 with -profile tcl8} -body {
+    encoding convertfrom -profile tcl8 utf-8 \xEF\xBF\xBF
 } -result \uFFFF
 test encoding-24.32 {Try to generate invalid utf-8} -body {
     encoding convertto utf-8 \uFFFF
 } -result \xEF\xBF\xBF
-test encoding-24.33 {Try to generate noncharacter with -strict} -body {
-    encoding convertto -strict utf-8 \uFFFF
+test encoding-24.33 {Try to generate noncharacter with -profile strict} -body {
+    encoding convertto -profile strict utf-8 \uFFFF
 } -result \xEF\xBF\xBF
-test encoding-24.34 {Try to generate invalid utf-8 with -nocomplain} -body {
-    encoding convertto -nocomplain utf-8 \uFFFF
+test encoding-24.34 {Try to generate invalid utf-8 with -profile tcl8} -body {
+    encoding convertto -profile tcl8 utf-8 \uFFFF
 } -result \xEF\xBF\xBF
 test encoding-24.35 {Parse invalid utf-8} -constraints utf32 -body {
     encoding convertfrom utf-8 \xED\xA0\x80
 } -result \uD800
-test encoding-24.36 {Parse invalid utf-8 with -strict} -body {
-    encoding convertfrom -strict utf-8 \xED\xA0\x80
+test encoding-24.36 {Parse invalid utf-8 with -profile strict} -body {
+    encoding convertfrom -profile strict utf-8 \xED\xA0\x80
 } -returnCodes 1 -result {unexpected byte sequence starting at index 0: '\xED'}
-test encoding-24.37 {Parse invalid utf-8 with -nocomplain} -body {
-    encoding convertfrom -nocomplain utf-8 \xED\xA0\x80
+test encoding-24.37 {Parse invalid utf-8 with -profile tcl8} -body {
+    encoding convertfrom -profile tcl8 utf-8 \xED\xA0\x80
 } -result \uD800
 test encoding-24.38 {Try to generate invalid utf-8} -body {
     encoding convertto utf-8 \uD800
 } -returnCodes 1 -result {unexpected character at index 0: 'U+00D800'}
-test encoding-24.39 {Try to generate invalid utf-8 with -strict} -body {
-    encoding convertto -strict utf-8 \uD800
+test encoding-24.39 {Try to generate invalid utf-8 with -profile strict} -body {
+    encoding convertto -profile strict utf-8 \uD800
 } -returnCodes 1 -result {unexpected character at index 0: 'U+00D800'}
-test encoding-24.40 {Try to generate invalid utf-8 with -nocomplain} -body {
-    encoding convertto -nocomplain utf-8 \uD800
+test encoding-24.40 {Try to generate invalid utf-8 with -profile tcl8} -body {
+    encoding convertto -profile tcl8 utf-8 \uD800
 } -result \xED\xA0\x80
-test encoding-24.41 {Parse invalid utf-8 with -strict} -body {
-    encoding convertfrom -strict utf-8 \xED\xA0\x80\xED\xB0\x80
+test encoding-24.41 {Parse invalid utf-8 with -profile strict} -body {
+    encoding convertfrom -profile strict utf-8 \xED\xA0\x80\xED\xB0\x80
 } -returnCodes 1 -result {unexpected byte sequence starting at index 0: '\xED'}
 test encoding-24.42 {Parse invalid utf-8, fallback to cp1252 [885c86a9a0]} -body {
-    encoding convertfrom -nocomplain utf-8 \xF0\x80\x80\x80
+    encoding convertfrom -profile tcl8 utf-8 \xF0\x80\x80\x80
 } -result \xF0\u20AC\u20AC\u20AC
 test encoding-24.43 {Parse invalid utf-8, fallback to cp1252 [885c86a9a0]} -body {
-    encoding convertfrom -nocomplain utf-8 \x80
+    encoding convertfrom -profile tcl8 utf-8 \x80
 } -result \u20AC
-test encoding-24.44 {Try to generate invalid ucs-2 with -strict} -body {
-    encoding convertto -strict ucs-2 \uD800
+test encoding-24.44 {Try to generate invalid ucs-2 with -profile strict} -body {
+    encoding convertto -profile strict ucs-2 \uD800
 } -returnCodes 1 -result {unexpected character at index 0: 'U+00D800'}
-test encoding-24.45 {Try to generate invalid ucs-2 with -strict} -body {
-    encoding convertto -strict ucs-2 \U10000
+test encoding-24.45 {Try to generate invalid ucs-2 with -profile strict} -body {
+    encoding convertto -profile strict ucs-2 \U10000
 } -returnCodes 1 -result {unexpected character at index 0: 'U+010000'}
 
 file delete [file join [temporaryDirectory] iso2022.txt]
@@ -1022,7 +1022,7 @@ test encoding-28.0 {all encodings load} -body {
 		if {$name ne "unicode"} {
 		    incr count
 		}
-		encoding convertto -nocomplain $name $string
+		encoding convertto -profile tcl8 $name $string
 
 		# discard the cached internal representation of Tcl_Encoding
 		# Unfortunately, without this, encoding 2-1 fails.
diff --git a/tests/io.test b/tests/io.test
index cb1c691..b0142dd 100644
--- a/tests/io.test
+++ b/tests/io.test
@@ -272,7 +272,7 @@ test io-3.4 {WriteChars: loop over stage buffer} -body {
     # stage buffer maps to more than can be queued at once.
 
     set f [open $path(test1) w]
-    fconfigure $f -encoding jis0208 -buffersize 16 -nocomplainencoding 1
+    fconfigure $f -encoding jis0208 -buffersize 16 -encodingprofile tcl8
     puts -nonewline $f "\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\"
     set x [list [contents $path(test1)]]
     close $f
@@ -286,7 +286,7 @@ test io-3.5 {WriteChars: saved != 0} -body {
     # requested buffersize.
 
     set f [open $path(test1) w]
-    fconfigure $f -encoding jis0208 -buffersize 17 -nocomplainencoding 1
+    fconfigure $f -encoding jis0208 -buffersize 17 -encodingprofile tcl8
     puts -nonewline $f "\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\"
     set x [list [contents $path(test1)]]
     close $f
@@ -319,7 +319,7 @@ test io-3.7 {WriteChars: (bufPtr->nextAdded > bufPtr->length)} -body {
     # of the next channel buffer.
 
     set f [open $path(test1) w]
-    fconfigure $f -encoding jis0208 -buffersize 17 -nocomplainencoding 1
+    fconfigure $f -encoding jis0208 -buffersize 17 -encodingprofile tcl8
     puts -nonewline $f "\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\"
     set x [list [contents $path(test1)]]
     close $f
@@ -7622,7 +7622,7 @@ test io-52.20 {TclCopyChannel & encodings} -setup {
     set out [open $path(kyrillic.txt) w]
 
     # Using "-encoding ascii" means reading the "Á" gives an error
-    fconfigure $in  -encoding ascii -strictencoding 1
+    fconfigure $in  -encoding ascii -encodingprofile strict
     fconfigure $out -encoding koi8-r -translation lf
 
     fcopy $in $out
@@ -7644,7 +7644,7 @@ test io-52.21 {TclCopyChannel & encodings} -setup {
 
     # Using "-encoding ascii" means writing the "Á" gives an error
     fconfigure $in  -encoding utf-8
-    fconfigure $out -encoding ascii -translation lf -strictencoding 1
+    fconfigure $out -encoding ascii -translation lf -encodingprofile strict
 
     fcopy $in $out
 } -cleanup {
@@ -7664,7 +7664,7 @@ test io-52.22 {TclCopyChannel & encodings} -setup {
     set out [open $path(kyrillic.txt) w]
 
     # Using "-encoding ascii" means reading the "Á" gives an error
-    fconfigure $in  -encoding ascii -strictencoding 1
+    fconfigure $in  -encoding ascii -encodingprofile strict
     fconfigure $out -encoding koi8-r -translation lf
     proc ::xxx args {
         set ::s0 $args
@@ -7692,7 +7692,7 @@ test io-52.23 {TclCopyChannel & encodings} -setup {
 
     # Using "-encoding ascii" means writing the "Á" gives an error
     fconfigure $in  -encoding utf-8
-    fconfigure $out -encoding ascii -translation lf -strictencoding 1
+    fconfigure $out -encoding ascii -translation lf -encodingprofile strict
     proc ::xxx args {
         set ::s0 $args
     }
@@ -9058,7 +9058,7 @@ test io-75.1 {multibyte encoding error read results in raw bytes (-nocomplainenc
     puts -nonewline $f A\xC0\x40
     flush $f
     seek $f 0
-    fconfigure $f -encoding utf-8 -nocomplainencoding 1 -buffering none
+    fconfigure $f -encoding utf-8 -encodingprofile tcl8 -buffering none
 } -body {
     set d [read $f]
     binary scan $d H* hd
@@ -9068,10 +9068,10 @@ test io-75.1 {multibyte encoding error read results in raw bytes (-nocomplainenc
     removeFile io-75.1
 } -result 41c040
 
-test io-75.2 {unrepresentable character write passes and is replaced by ? (-nocomplainencoding 1)} -setup {
+test io-75.2 {unrepresentable character write passes and is replaced by ? (-encodingprofile tcl8)} -setup {
     set fn [makeFile {} io-75.2]
     set f [open $fn w+]
-    fconfigure $f -encoding iso8859-1 -nocomplainencoding 1
+    fconfigure $f -encoding iso8859-1 -encodingprofile tcl8
 } -body {
     puts -nonewline $f A\u2022
     flush $f
@@ -9085,14 +9085,14 @@ test io-75.2 {unrepresentable character write passes and is replaced by ? (-noco
 # Incomplete sequence test.
 # This error may IMHO only be detected with the close.
 # But the read already returns the incomplete sequence.
-test io-75.3 {incomplete multibyte encoding read is ignored (-nocomplainencoding 1)} -setup {
+test io-75.3 {incomplete multibyte encoding read is ignored (-encodingprofile tcl8)} -setup {
     set fn [makeFile {} io-75.3]
     set f [open $fn w+]
     fconfigure $f -encoding binary
     puts -nonewline $f "A\xC0"
     flush $f
     seek $f 0
-    fconfigure $f -encoding utf-8 -buffering none -nocomplainencoding 1
+    fconfigure $f -encoding utf-8 -buffering none -encodingprofile tcl8
 } -body {
     set d [read $f]
     close $f
@@ -9104,7 +9104,7 @@ test io-75.3 {incomplete multibyte encoding read is ignored (-nocomplainencoding
 
 # As utf-8 has a special treatment in multi-byte decoding, also test another
 # one.
-test io-75.4 {shiftjis encoding error read results in raw bytes (-nocomplainencoding 1)} -setup {
+test io-75.4 {shiftjis encoding error read results in raw bytes (-encodingprofile tcl8)} -setup {
     set fn [makeFile {} io-75.4]
     set f [open $fn w+]
     fconfigure $f -encoding binary
@@ -9113,7 +9113,7 @@ test io-75.4 {shiftjis encoding error read results in raw bytes (-nocomplainenco
     puts -nonewline $f A\x81\xFFA
     flush $f
     seek $f 0
-    fconfigure $f -encoding shiftjis -buffering none -eofchar "" -translation lf -nocomplainencoding 1
+    fconfigure $f -encoding shiftjis -buffering none -eofchar "" -translation lf -encodingprofile tcl8
 } -body {
     set d [read $f]
     binary scan $d H* hd
@@ -9123,14 +9123,14 @@ test io-75.4 {shiftjis encoding error read results in raw bytes (-nocomplainenco
     removeFile io-75.4
 } -result 4181ff41
 
-test io-75.5 {invalid utf-8 encoding read is ignored (-nocomplainencoding 1)} -setup {
+test io-75.5 {invalid utf-8 encoding read is ignored (-encodingprofile tcl8)} -setup {
     set fn [makeFile {} io-75.5]
     set f [open $fn w+]
     fconfigure $f -encoding binary
     puts -nonewline $f A\x81
     flush $f
     seek $f 0
-    fconfigure $f -encoding utf-8 -buffering none -eofchar "" -translation lf -nocomplainencoding 1
+    fconfigure $f -encoding utf-8 -buffering none -eofchar "" -translation lf -encodingprofile tcl8
 } -body {
     set d [read $f]
     close $f
@@ -9140,7 +9140,7 @@ test io-75.5 {invalid utf-8 encoding read is ignored (-nocomplainencoding 1)} -s
     removeFile io-75.5
 } -result 4181
 
-test io-75.6 {invalid utf-8 encoding read is not ignored (-strictencoding 1)} -setup {
+test io-75.6 {invalid utf-8 encoding read is not ignored (-encodingprofile strict)} -setup {
     set fn [makeFile {} io-75.6]
     set f [open $fn w+]
     fconfigure $f -encoding binary
@@ -9148,7 +9148,7 @@ test io-75.6 {invalid utf-8 encoding read is not ignored (-strictencoding 1)} -s
     puts -nonewline $f A\x81
     flush $f
     seek $f 0
-    fconfigure $f -encoding utf-8 -buffering none -eofchar "" -translation lf -strictencoding 1
+    fconfigure $f -encoding utf-8 -buffering none -eofchar "" -translation lf -encodingprofile strict
 } -body {
     set d [read $f]
     binary scan $d H* hd
@@ -9159,7 +9159,7 @@ test io-75.6 {invalid utf-8 encoding read is not ignored (-strictencoding 1)} -s
     removeFile io-75.6
 } -match glob -result {41 1 {error reading "*": illegal byte sequence}}
 
-test io-75.7 {invalid utf-8 encoding eof handling (-strictencoding 1)} -setup {
+test io-75.7 {invalid utf-8 encoding eof handling (-encodingprofile strict)} -setup {
     set fn [makeFile {} io-75.7]
     set f [open $fn w+]
     fconfigure $f -encoding binary
@@ -9167,7 +9167,7 @@ test io-75.7 {invalid utf-8 encoding eof handling (-strictencoding 1)} -setup {
     puts -nonewline $f A\xA1\x1A
     flush $f
     seek $f 0
-    fconfigure $f -encoding utf-8 -buffering none -eofchar \x1A -translation lf -strictencoding 1
+    fconfigure $f -encoding utf-8 -buffering none -eofchar \x1A -translation lf -encodingprofile strict
 } -body {
     set d [read $f]
     binary scan $d H* hd
@@ -9182,7 +9182,7 @@ test io-75.7 {invalid utf-8 encoding eof handling (-strictencoding 1)} -setup {
     removeFile io-75.7
 } -match glob -result {41 0 1 {error reading "*": illegal byte sequence} ¡}
 
-test io-75.8 {invalid utf-8 encoding eof handling (-strictencoding 1)} -setup {
+test io-75.8 {invalid utf-8 encoding eof handling (-encodingprofile strict)} -setup {
     set fn [makeFile {} io-75.8]
     set f [open $fn w+]
     fconfigure $f -encoding binary
@@ -9190,7 +9190,7 @@ test io-75.8 {invalid utf-8 encoding eof handling (-strictencoding 1)} -setup {
     puts -nonewline $f A\x1A\x81
     flush $f
     seek $f 0
-    fconfigure $f -encoding utf-8 -buffering none -eofchar \x1A -translation lf -strictencoding 1
+    fconfigure $f -encoding utf-8 -buffering none -eofchar \x1A -translation lf -encodingprofile strict
 } -body {
     set d [read $f]
     binary scan $d H* hd
@@ -9205,7 +9205,7 @@ test io-75.8 {invalid utf-8 encoding eof handling (-strictencoding 1)} -setup {
 test io-75.9 {unrepresentable character write passes and is replaced by ?} -setup {
     set fn [makeFile {} io-75.9]
     set f [open $fn w+]
-    fconfigure $f -encoding iso8859-1 -strictencoding 1
+    fconfigure $f -encoding iso8859-1 -encodingprofile strict
 } -body {
     catch {puts -nonewline $f "A\u2022"} msg
     flush $f
@@ -9249,7 +9249,7 @@ test io-75.11 {shiftjis encoding error read results in raw bytes} -setup {
     puts -nonewline $f A\x81\xFFA
     flush $f
     seek $f 0
-    fconfigure $f -encoding shiftjis -buffering none -eofchar "" -translation lf -strictencoding 1
+    fconfigure $f -encoding shiftjis -buffering none -eofchar "" -translation lf -encodingprofile strict
 } -body {
     set d [read $f]
     binary scan $d H* hd
@@ -9276,7 +9276,7 @@ test io-75.12 {invalid utf-8 encoding read is ignored} -setup {
 } -cleanup {
     removeFile io-75.12
 } -result 4181
-test io-75.13 {invalid utf-8 encoding read is not ignored (-strictencoding 1)} -setup {
+test io-75.13 {invalid utf-8 encoding read is not ignored (-encodingprofile strict)} -setup {
     set fn [makeFile {} io-75.13]
     set f [open $fn w+]
     fconfigure $f -encoding binary
@@ -9284,7 +9284,7 @@ test io-75.13 {invalid utf-8 encoding read is not ignored (-strictencoding 1)} -
     puts -nonewline $f "A\x81"
     flush $f
     seek $f 0
-    fconfigure $f -encoding utf-8 -buffering none -eofchar "" -translation lf -strictencoding 1
+    fconfigure $f -encoding utf-8 -buffering none -eofchar "" -translation lf -encodingprofile strict
 } -body {
     set d [read $f]
     binary scan $d H* hd
diff --git a/tests/ioCmd.test b/tests/ioCmd.test
index 41abfb9..9e28569 100644
--- a/tests/ioCmd.test
+++ b/tests/ioCmd.test
@@ -207,7 +207,7 @@ test iocmd-7.5 {close command} -setup {
 
 proc expectedOpts {got extra} {
     set basicOpts {
-	-blocking -buffering -buffersize -encoding -eofchar -nocomplainencoding -strictencoding -translation
+	-blocking -buffering -buffersize -encoding -encodingprofile -eofchar -translation
     }
     set opts [list {*}$basicOpts {*}$extra]
     lset opts end [string cat "or " [lindex $opts end]]
@@ -244,19 +244,19 @@ test iocmd-8.7 {fconfigure command} -setup {
     fconfigure $f1
 } -cleanup {
     catch {close $f1}
-} -result {-blocking 1 -buffering full -buffersize 4096 -encoding utf-16 -eofchar {} -nocomplainencoding 0 -strictencoding 0 -translation lf}
+} -result {-blocking 1 -buffering full -buffersize 4096 -encoding utf-16 -encodingprofile tcl8 -eofchar {} -translation lf}
 test iocmd-8.8 {fconfigure command} -setup {
     file delete $path(test1)
     set x {}
 } -body {
     set f1 [open $path(test1) w]
     fconfigure $f1 -translation lf -buffering line -buffersize 3030 \
-		-eofchar {} -encoding utf-16
+		-eofchar {} -encoding utf-16 -encodingprofile tcl8
     lappend x [fconfigure $f1 -buffering]
     lappend x [fconfigure $f1]
 } -cleanup {
     catch {close $f1}
-} -result {line {-blocking 1 -buffering line -buffersize 3030 -encoding utf-16 -eofchar {} -nocomplainencoding 0 -strictencoding 0 -translation lf}}
+} -result {line {-blocking 1 -buffering line -buffersize 3030 -encoding utf-16 -encodingprofile tcl8 -eofchar {} -translation lf}}
 test iocmd-8.9 {fconfigure command} -setup {
     file delete $path(test1)
 } -body {
@@ -266,7 +266,7 @@ test iocmd-8.9 {fconfigure command} -setup {
     fconfigure $f1
 } -cleanup {
     catch {close $f1}
-} -result {-blocking 1 -buffering none -buffersize 4040 -encoding binary -eofchar {} -nocomplainencoding 0 -strictencoding 0 -translation lf}
+} -result {-blocking 1 -buffering none -buffersize 4040 -encoding binary -encodingprofile tcl8 -eofchar {} -translation lf}
 test iocmd-8.10 {fconfigure command} -returnCodes error -body {
     fconfigure a b
 } -result {can not find channel named "a"}
@@ -1368,7 +1368,7 @@ test iocmd-25.1 {chan configure, cgetall, standard options} -match glob -body {
     close $c
     rename foo {}
     set res
-} -result {{-blocking 1 -buffering full -buffersize 4096 -encoding * -eofchar {} -nocomplainencoding 0 -strictencoding 0 -translation {auto *}}}
+} -result {{-blocking 1 -buffering full -buffersize 4096 -encoding * -encodingprofile * -eofchar {} -translation {auto *}}}
 test iocmd-25.2 {chan configure, cgetall, no options} -match glob -body {
     set res {}
     proc foo {args} {oninit cget cgetall; onfinal; track; return ""}
@@ -1377,7 +1377,7 @@ test iocmd-25.2 {chan configure, cgetall, no options} -match glob -body {
     close $c
     rename foo {}
     set res
-} -result {{cgetall rc*} {-blocking 1 -buffering full -buffersize 4096 -encoding * -eofchar {} -nocomplainencoding 0 -strictencoding 0 -translation {auto *}}}
+} -result {{cgetall rc*} {-blocking 1 -buffering full -buffersize 4096 -encoding * -encodingprofile * -eofchar {} -translation {auto *}}}
 test iocmd-25.3 {chan configure, cgetall, regular result} -match glob -body {
     set res {}
     proc foo {args} {
@@ -1389,7 +1389,7 @@ test iocmd-25.3 {chan configure, cgetall, regular result} -match glob -body {
     close $c
     rename foo {}
     set res
-} -result {{cgetall rc*} {-blocking 1 -buffering full -buffersize 4096 -encoding * -eofchar {} -nocomplainencoding 0 -strictencoding 0 -translation {auto *} -bar foo -snarf x}}
+} -result {{cgetall rc*} {-blocking 1 -buffering full -buffersize 4096 -encoding * -encodingprofile * -eofchar {} -translation {auto *} -bar foo -snarf x}}
 test iocmd-25.4 {chan configure, cgetall, bad result, list of uneven length} -match glob -body {
     set res {}
     proc foo {args} {
diff --git a/tests/safe.test b/tests/safe.test
index 7b73eb2..d81da0a 100644
--- a/tests/safe.test
+++ b/tests/safe.test
@@ -1473,7 +1473,7 @@ test safe-11.7 {testing safe encoding} -setup {
     interp eval $i encoding convertfrom
 } -returnCodes error -cleanup {
     safe::interpDelete $i
-} -result {wrong # args: should be "encoding convertfrom ?-strict? ?-failindex var? ?encoding? data" or "encoding convertfrom -nocomplain ?encoding? data"}
+} -result {wrong # args: should be "encoding convertfrom ?-profile profile? ?-failindex var? encoding data" or "encoding convertfrom data"}
 test safe-11.7.1 {testing safe encoding} -setup {
     set i [safe::interpCreate]
 } -body {
@@ -1482,7 +1482,7 @@ test safe-11.7.1 {testing safe encoding} -setup {
 } -match glob -cleanup {
     unset -nocomplain m o
     safe::interpDelete $i
-} -result {wrong # args: should be "encoding convertfrom ?-strict? ?-failindex var? ?encoding? data" or "encoding convertfrom -nocomplain ?encoding? data"
+} -result {wrong # args: should be "encoding convertfrom ?-profile profile? ?-failindex var? encoding data" or "encoding convertfrom data"
     while executing
 "encoding convertfrom"
     invoked from within
@@ -1495,7 +1495,7 @@ test safe-11.8 {testing safe encoding} -setup {
     interp eval $i encoding convertto
 } -returnCodes error -cleanup {
     safe::interpDelete $i
-} -result {wrong # args: should be "encoding convertto ?-strict? ?-failindex var? ?encoding? data" or "encoding convertto -nocomplain ?encoding? data"}
+} -result {wrong # args: should be "encoding convertto ?-profile profile? ?-failindex var? encoding data" or "encoding convertto data"}
 test safe-11.8.1 {testing safe encoding} -setup {
     set i [safe::interpCreate]
 } -body {
@@ -1504,7 +1504,7 @@ test safe-11.8.1 {testing safe encoding} -setup {
 } -match glob -cleanup {
     unset -nocomplain m o
     safe::interpDelete $i
-} -result {wrong # args: should be "encoding convertto ?-strict? ?-failindex var? ?encoding? data" or "encoding convertto -nocomplain ?encoding? data"
+} -result {wrong # args: should be "encoding convertto ?-profile profile? ?-failindex var? encoding data" or "encoding convertto data"
     while executing
 "encoding convertto"
     invoked from within
diff --git a/tests/socket.test b/tests/socket.test
index a0fe2f7..b1435be 100644
--- a/tests/socket.test
+++ b/tests/socket.test
@@ -1071,7 +1071,7 @@ test socket_$af-7.3 {testing socket specific options} -constraints [list socket
     close $s
     update
     llength $l
-} -result 22
+} -result 20
 test socket_$af-7.4 {testing socket specific options} -constraints [list socket supported_$af] -setup {
     set timer [after 10000 "set x timed_out"]
     set l ""
diff --git a/tests/winConsole.test b/tests/winConsole.test
index b04f3e9..62dfbf3 100644
--- a/tests/winConsole.test
+++ b/tests/winConsole.test
@@ -198,7 +198,7 @@ test console-fconfigure-get-1.0 {
     Console get stdin configuration
 } -constraints {win interactive} -body {
     lsort [dict keys [fconfigure stdin]]
-} -result {-blocking -buffering -buffersize -encoding -eofchar -inputmode -translation}
+} -result {-blocking -buffering -buffersize -encoding -encodingprofile -eofchar -inputmode -translation}
 
 set testnum 0
 foreach {opt result} {
@@ -224,7 +224,7 @@ test console-fconfigure-get-1.[incr testnum] {
     fconfigure -winsize
 } -constraints {win interactive} -body {
     fconfigure stdin -winsize
-} -result {bad option "-winsize": should be one of -blocking, -buffering, -buffersize, -encoding, -eofchar, -nocomplainencoding, -strictencoding, -translation, or -inputmode} -returnCodes error
+} -result {bad option "-winsize": should be one of -blocking, -buffering, -buffersize, -encoding, -encodingprofile, -eofchar, -translation, or -inputmode} -returnCodes error
 
 ## fconfigure get stdout/stderr
 foreach chan {stdout stderr} major {2 3} {
@@ -232,7 +232,7 @@ foreach chan {stdout stderr} major {2 3} {
         win interactive
     } -body {
         lsort [dict keys [fconfigure $chan]]
-    } -result {-blocking -buffering -buffersize -encoding -eofchar -translation -winsize}
+    } -result {-blocking -buffering -buffersize -encoding -encodingprofile -eofchar -translation -winsize}
     set testnum 0
     foreach {opt result} {
         -blocking 1
@@ -260,7 +260,7 @@ foreach chan {stdout stderr} major {2 3} {
         fconfigure -inputmode
     } -constraints {win interactive} -body {
         fconfigure $chan -inputmode
-    } -result {bad option "-inputmode": should be one of -blocking, -buffering, -buffersize, -encoding, -eofchar, -nocomplainencoding, -strictencoding, -translation, or -winsize} -returnCodes error
+    } -result {bad option "-inputmode": should be one of -blocking, -buffering, -buffersize, -encoding, -encodingprofile, -eofchar, -translation, or -winsize} -returnCodes error
 
 }
 
@@ -330,7 +330,7 @@ test console-fconfigure-set-1.3 {
     fconfigure stdin -winsize
 } -constraints {win interactive} -body {
     fconfigure stdin -winsize {10 30}
-} -result {bad option "-winsize": should be one of -blocking, -buffering, -buffersize, -encoding, -eofchar, -nocomplainencoding, -strictencoding, -translation, or -inputmode} -returnCodes error
+} -result {bad option "-winsize": should be one of -blocking, -buffering, -buffersize, -encoding, -encodingprofile, -eofchar, -translation, or -inputmode} -returnCodes error
 
 ## fconfigure set stdout,stderr
 
@@ -338,13 +338,13 @@ test console-fconfigure-set-2.0 {
     fconfigure stdout -winsize
 } -constraints {win interactive} -body {
     fconfigure stdout -winsize {10 30}
-} -result {bad option "-winsize": should be one of -blocking, -buffering, -buffersize, -encoding, -eofchar, -nocomplainencoding, -strictencoding, or -translation} -returnCodes error
+} -result {bad option "-winsize": should be one of -blocking, -buffering, -buffersize, -encoding, -encodingprofile, -eofchar, or -translation} -returnCodes error
 
 test console-fconfigure-set-3.0 {
     fconfigure stderr -winsize
 } -constraints {win interactive} -body {
     fconfigure stderr -winsize {10 30}
-} -result {bad option "-winsize": should be one of -blocking, -buffering, -buffersize, -encoding, -eofchar, -nocomplainencoding, -strictencoding, or -translation} -returnCodes error
+} -result {bad option "-winsize": should be one of -blocking, -buffering, -buffersize, -encoding, -encodingprofile, -eofchar, or -translation} -returnCodes error
 
 # Multiple threads
 
diff --git a/tests/zlib.test b/tests/zlib.test
index 1c9514d..7e11634 100644
--- a/tests/zlib.test
+++ b/tests/zlib.test
@@ -292,7 +292,7 @@ test zlib-8.6 {transformation and fconfigure} -setup {
 } -cleanup {
     catch {close $fd}
     removeFile $file
-} -result {{-blocking 1 -buffering full -buffersize 4096 -encoding binary -eofchar {} -nocomplainencoding 0 -strictencoding 0 -translation lf} {-blocking 1 -buffering full -buffersize 4096 -encoding binary -eofchar {} -nocomplainencoding 0 -strictencoding 0 -translation lf -checksum 1 -dictionary {}} {-blocking 1 -buffering full -buffersize 4096 -encoding binary -eofchar {} -nocomplainencoding 0 -strictencoding 0 -translation lf}}
+} -result {{-blocking 1 -buffering full -buffersize 4096 -encoding binary -encodingprofile tcl8 -eofchar {} -translation lf} {-blocking 1 -buffering full -buffersize 4096 -encoding binary -encodingprofile tcl8 -eofchar {} -translation lf -checksum 1 -dictionary {}} {-blocking 1 -buffering full -buffersize 4096 -encoding binary -encodingprofile tcl8 -eofchar {} -translation lf}}
 test zlib-8.7 {transformation and fconfigure} -setup {
     set file [makeFile {} test.gz]
     set fd [open $file wb]
@@ -302,7 +302,7 @@ test zlib-8.7 {transformation and fconfigure} -setup {
 } -cleanup {
     catch {close $fd}
     removeFile $file
-} -result {{-blocking 1 -buffering full -buffersize 4096 -encoding binary -eofchar {} -nocomplainencoding 0 -strictencoding 0 -translation lf} {-blocking 1 -buffering full -buffersize 4096 -encoding binary -eofchar {} -nocomplainencoding 0 -strictencoding 0 -translation lf -checksum 0} {-blocking 1 -buffering full -buffersize 4096 -encoding binary -eofchar {} -nocomplainencoding 0 -strictencoding 0 -translation lf}}
+} -result {{-blocking 1 -buffering full -buffersize 4096 -encoding binary -encodingprofile tcl8 -eofchar {} -translation lf} {-blocking 1 -buffering full -buffersize 4096 -encoding binary -encodingprofile tcl8 -eofchar {} -translation lf -checksum 0} {-blocking 1 -buffering full -buffersize 4096 -encoding binary -encodingprofile tcl8 -eofchar {} -translation lf}}
 # Input is headers from fetching SPDY draft
 # Dictionary is that which is proposed _in_ SPDY draft
 set spdyHeaders "HTTP/1.0 200 OK\r\nContent-Type: text/html; charset=utf-8\r\nX-Robots-Tag: noarchive\r\nLast-Modified: Tue, 05 Jun 2012 02:43:25 GMT\r\nETag: \"1338864205129|#public|0|en|||0\"\r\nExpires: Tue, 05 Jun 2012 16:17:11 GMT\r\nDate: Tue, 05 Jun 2012 16:17:06 GMT\r\nCache-Control: public, max-age=5\r\nX-Content-Type-Options: nosniff\r\nX-XSS-Protection: 1; mode=block\r\nServer: GSE\r\n"