diff --git a/.github/workflows/linux-build.yml b/.github/workflows/linux-build.yml
index 52cec15004c9..29aa98be41cd 100644
--- a/.github/workflows/linux-build.yml
+++ b/.github/workflows/linux-build.yml
@@ -3,7 +3,6 @@ on:
   push:
     branches:
     - "main"
-    - "trunk"
     - "core-8-branch"
     tags:
     - "core-**"
diff --git a/.github/workflows/mac-build.yml b/.github/workflows/mac-build.yml
index c57639035acf..462bd9236cdd 100644
--- a/.github/workflows/mac-build.yml
+++ b/.github/workflows/mac-build.yml
@@ -3,7 +3,6 @@ on:
   push:
     branches:
     - "main"
-    - "trunk"
     - "core-8-branch"
     tags:
     - "core-**"
diff --git a/.github/workflows/onefiledist.yml b/.github/workflows/onefiledist.yml
index f1cee16363f3..5c90701f3471 100644
--- a/.github/workflows/onefiledist.yml
+++ b/.github/workflows/onefiledist.yml
@@ -3,7 +3,6 @@ on:
   push:
     branches:
     - "main"
-    - "trunk"
     - "core-8-branch"
     tags:
     - "core-**"
diff --git a/.github/workflows/win-build.yml b/.github/workflows/win-build.yml
index 3b55c41ae9aa..4c7fafc3971c 100644
--- a/.github/workflows/win-build.yml
+++ b/.github/workflows/win-build.yml
@@ -3,7 +3,6 @@ on:
   push:
     branches:
     - "main"
-    - "trunk"
     - "core-8-branch"
     tags:
     - "core-**"
diff --git a/generic/tclArithSeries.c b/generic/tclArithSeries.c
index 4571b4a0b8fb..101967762b88 100755
--- a/generic/tclArithSeries.c
+++ b/generic/tclArithSeries.c
@@ -757,52 +757,6 @@ SetArithSeriesFromAny(
     return TCL_ERROR;
 }
 
-/*
- *----------------------------------------------------------------------
- *
- * TclArithSeriesObjCopy --
- *
- *	Makes a "pure arithSeries" copy of an ArithSeries value. This provides for the C
- *	level a counterpart of the [lrange $list 0 end] command, while using
- *	internals details to be as efficient as possible.
- *
- * Results:
- *
- *	Normally returns a pointer to a new Tcl_Obj, that contains the same
- *	arithSeries value as *arithSeriesObj does. The returned Tcl_Obj has a
- *	refCount of zero. If *arithSeriesObj does not hold an arithSeries,
- *	NULL is returned, and if interp is non-NULL, an error message is
- *	recorded there.
- *
- * Side effects:
- *	None.
- *
- *----------------------------------------------------------------------
- */
-
-Tcl_Obj *
-TclArithSeriesObjCopy(
-    Tcl_Interp *interp,		/* Used to report errors if not NULL. */
-    Tcl_Obj *arithSeriesObj)	/* List object for which an element array is
-				 * to be returned. */
-{
-    Tcl_Obj *copyPtr;
-    ArithSeries *arithSeriesRepPtr;
-
-    arithSeriesRepPtr = ArithSeriesGetInternalRep(arithSeriesObj);
-    if (NULL == arithSeriesRepPtr) {
-	if (SetArithSeriesFromAny(interp, arithSeriesObj) != TCL_OK) {
-	    /* We know this is going to panic, but it's the message we want */
-	    return NULL;
-	}
-    }
-
-    TclNewObj(copyPtr);
-    TclInvalidateStringRep(copyPtr);
-    DupArithSeriesInternalRep(arithSeriesObj, copyPtr);
-    return copyPtr;
-}
-
 /*
  *----------------------------------------------------------------------
  *
diff --git a/generic/tclArithSeries.h b/generic/tclArithSeries.h
index 61538c484dc3..8002239551f1 100644
--- a/generic/tclArithSeries.h
+++ b/generic/tclArithSeries.h
@@ -34,8 +34,6 @@ typedef struct {
 } ArithSeriesDbl;
 
 
-MODULE_SCOPE Tcl_Obj *	TclArithSeriesObjCopy(Tcl_Interp *interp,
-			    Tcl_Obj *arithSeriesPtr);
 MODULE_SCOPE  Tcl_Obj *TclArithSeriesObjIndex(Tcl_Interp *, Tcl_Obj *,
 			    Tcl_WideInt index);
 MODULE_SCOPE Tcl_Obj *	TclArithSeriesObjRange(Tcl_Interp *interp,
diff --git a/generic/tclAssembly.c b/generic/tclAssembly.c
index ef25e74751c9..dc8a158633dc 100644
--- a/generic/tclAssembly.c
+++ b/generic/tclAssembly.c
@@ -2247,7 +2247,7 @@ static int
 GetListIndexOperand(
     AssemblyEnv* assemEnvPtr,	/* Assembly environment */
     Tcl_Token** tokenPtrPtr,	/* Current token from the parser */
-    int* result)		/* OUTPUT: Integer extracted from the token */
+    int* result)		/* OUTPUT: encoded index derived from the token */
 {
     CompileEnv* envPtr = assemEnvPtr->envPtr;
 				/* Compilation environment */
diff --git a/generic/tclCmdAH.c b/generic/tclCmdAH.c
index 64058035bd98..4b2cd96f9754 100644
--- a/generic/tclCmdAH.c
+++ b/generic/tclCmdAH.c
@@ -2811,7 +2811,7 @@ EachloopCmd(
 	/* Values */
 	if (TclHasInternalRep(objv[2+i*2],&tclArithSeriesType.objType)) {
 	    /* Special case for Arith Series */
-	    statePtr->aCopyList[i] = TclArithSeriesObjCopy(interp, objv[2+i*2]);
+	    statePtr->aCopyList[i] = Tcl_DuplicateObj(objv[2+i*2]);
 	    if (statePtr->aCopyList[i] == NULL) {
 		result = TCL_ERROR;
 		goto done;
diff --git a/generic/tclCompile.c b/generic/tclCompile.c
index 926c492a7771..b974c30d7bb0 100644
--- a/generic/tclCompile.c
+++ b/generic/tclCompile.c
@@ -720,8 +720,8 @@ const Tcl_ObjType tclByteCodeType = {
 };
 
 /*
- * subtCodeType provides the standard type managemnt procedures for the
- * substcode type, which represents substiution within a Tcl value.
+ * substCodeType provides the standard type management procedures for the
+ * substcode type, which represents substitution within a Tcl value.
  */
 
 static const Tcl_ObjType substCodeType = {
diff --git a/generic/tclEncoding.c b/generic/tclEncoding.c
index b794eb204398..3ab3de979291 100644
--- a/generic/tclEncoding.c
+++ b/generic/tclEncoding.c
@@ -1165,7 +1165,7 @@ Tcl_ExternalToUtfDString(
  * Tcl_ExternalToUtfDStringEx --
  *
  *	Convert a source buffer from the specified encoding into UTF-8.
- *	The parameter flags controls the behavior, if any of the bytes in
+ *	"flags" controls the behavior if any of the bytes in
  *	the source buffer are invalid or cannot be represented in utf-8.
  *	Possible flags values:
  *	target encoding. It should be composed by OR-ing the following:
@@ -2588,10 +2588,10 @@ UtfToUtfProc(
 	} else if (!Tcl_UtfCharComplete(src, srcEnd - src)) {
 	    /*
 	     * Incomplete byte sequence.
-	     * Always check before using TclUtfToUCS4. Not doing can so
-	     * cause it run beyond the end of the buffer! If we happen such an
-	     * incomplete char its bytes are made to represent themselves
-	     * unless the user has explicitly asked to be told.
+		 * Always check before using TclUtfToUCS4. Not doing so can cause it
+		 * run beyond the end of the buffer! If we happen on such an incomplete
+		 * char its bytes are made to represent themselves unless the user has
+		 * explicitly asked to be told.
 	     */
 
 	    if (flags & ENCODING_INPUT) {
diff --git a/generic/tclExecute.c b/generic/tclExecute.c
index 14cd6f417fa5..f496b93c8e8c 100644
--- a/generic/tclExecute.c
+++ b/generic/tclExecute.c
@@ -113,9 +113,8 @@ typedef struct {
     ByteCode *codePtr;		/* Constant until the BC returns */
 				/* -----------------------------------------*/
     Tcl_Obj **catchTop;		/* These fields are used on return TO this */
-    Tcl_Obj *auxObjList;	/* this level: they record the state when a */
-    CmdFrame cmdFrame;		/* new codePtr was received for NR */
-                                /* execution. */
+    Tcl_Obj *auxObjList;	/* level: they record the state when a new */
+    CmdFrame cmdFrame;		/* codePtr was received for NR execution. */
     Tcl_Obj *stack[1];		/* Start of the actual combined catch and obj
 				 * stacks; the struct will be expanded as
 				 * necessary */
diff --git a/generic/tclIO.c b/generic/tclIO.c
index 65e327d2f01d..f5e39e218ab4 100644
--- a/generic/tclIO.c
+++ b/generic/tclIO.c
@@ -5931,7 +5931,7 @@ DoReadChars(
 
     if (GotFlag(statePtr, CHANNEL_ENCODING_ERROR)) {
 	ResetFlag(statePtr, CHANNEL_EOF|CHANNEL_ENCODING_ERROR);
-	/* TODO: We don't need this call? */
+	/* TODO: UpdateInterest not needed here? */
 	UpdateInterest(chanPtr);
 	Tcl_SetErrno(EILSEQ);
 	return -1;
@@ -5948,7 +5948,7 @@ DoReadChars(
 	assert(statePtr->inputEncodingFlags & TCL_ENCODING_END);
 	assert(!GotFlag(statePtr, CHANNEL_BLOCKED|INPUT_SAW_CR));
 
-	/* TODO: We don't need this call? */
+	/* TODO: UpdateInterest not needed here? */
 	UpdateInterest(chanPtr);
 	return 0;
     }
@@ -5962,7 +5962,7 @@ DoReadChars(
 	}
 	ResetFlag(statePtr, CHANNEL_BLOCKED|CHANNEL_EOF);
 	statePtr->inputEncodingFlags &= ~TCL_ENCODING_END;
-	/* TODO: We don't need this call? */
+	/* TODO: UpdateInterest not needed here? */
 	UpdateInterest(chanPtr);
 	return 0;
     }
@@ -6009,7 +6009,7 @@ DoReadChars(
 	    }
 
 	    /*
-	     * If the current buffer is empty recycle it.
+	     * Recycle current buffer if empty.
 	     */
 
 	    bufPtr = statePtr->inQueueHead;
diff --git a/generic/tclListObj.c b/generic/tclListObj.c
index 726b8dd1153f..6cc933c74dfd 100644
--- a/generic/tclListObj.c
+++ b/generic/tclListObj.c
@@ -304,8 +304,8 @@ ListSpanMerited(
     Tcl_Size allocatedStorageLength) /* Length of the currently allocation */
 {
     /*
-     * Possible optimizations for future consideration 
-     * - heuristic LIST_SPAN_THRESHOLD 
+     * Possible optimizations for future consideration
+     * - heuristic LIST_SPAN_THRESHOLD
      * - currently, information about the sharing (ref count) of existing
      * storage is not passed. Perhaps it should be. For example if the
      * existing storage has a "large" ref count, then it might make sense
@@ -828,7 +828,7 @@ ListStoreNew(
  *
  * ListStoreReallocate --
  *
- *    Reallocates the memory for a ListStore allocating extra for 
+ *    Reallocates the memory for a ListStore allocating extra for
  *    possible future growth.
  *
  * Results:
@@ -1386,7 +1386,7 @@ TclListObjCopy(
 
     if (!TclHasInternalRep(listObj, &tclListType.objType)) {
 	if (TclHasInternalRep(listObj,&tclArithSeriesType.objType)) {
-	    return TclArithSeriesObjCopy(interp, listObj);
+	    return Tcl_DuplicateObj(listObj);
 	}
 	if (SetListFromAny(interp, listObj) != TCL_OK) {
 	    return NULL;
diff --git a/tests-perf/listPerf.tcl b/tests-perf/listPerf.tcl
index 17f22e94be35..575c78e2e47b 100644
--- a/tests-perf/listPerf.tcl
+++ b/tests-perf/listPerf.tcl
@@ -3,8 +3,9 @@
 #
 # listPerf.tcl --
 #
-#  This file provides performance tests for list operations.
-#
+#  This file provides performance tests for list operations. Run
+#     tclsh listPerf.tcl help
+#  for options.
 # ------------------------------------------------------------------------
 #
 # See the file "license.terms" for information on usage and redistribution
@@ -77,7 +78,9 @@ namespace eval perf::list {
                     break
                 }
                 --* {
-                    error "Unknown option $arg"
+                    puts stderr "Unknown option $arg"
+                    print_usage
+                    exit 1
                 }
                 default {
                     # Remaining will be passed back to the caller
@@ -383,6 +386,8 @@ namespace eval perf::list {
             comment Create a list from two lists - real test of expansion speed
             perf measure [list_describe $len "from a {*}list {*}list"] {list {*}$L {*}$L} [list len [expr {$len/2}]]
         }
+
+        perf destroy
     }
 
     proc lappend_describe {share_mode len num iters} {
@@ -1217,7 +1222,7 @@ namespace eval perf::list {
             set commands [lmap sel $selections {
                 if {$sel eq "help"} {
                     print_usage
-                    continue
+                    exit 0
                 }
                 set cmd ::perf::list::${sel}_perf
                 if {$cmd ni [info commands ::perf::list::*_perf]} {
diff --git a/tests/chanio.test b/tests/chanio.test
index 29ef1e78b37c..e5e74cb5a576 100644
--- a/tests/chanio.test
+++ b/tests/chanio.test
@@ -1098,7 +1098,7 @@ test chan-io-7.3 {FilterInputBytes: split up character at EOF} -setup {
     chan puts -nonewline $f "1234567890123\x82\x4F\x82\x50\x82"
     chan close $f
     set f [open $path(test1)]
-    chan configure $f -encoding shiftjis
+    chan configure $f -encoding shiftjis -profile tcl8
     lappend x [chan gets $f line] $line
     lappend x [chan tell $f] [testchannel inputbuffered $f] [chan eof $f]
     lappend x [chan gets $f line] $line
diff --git a/tests/cmdInfo.test b/tests/cmdInfo.test
index d1722263ca7a..37b8a0b13be0 100644
--- a/tests/cmdInfo.test
+++ b/tests/cmdInfo.test
@@ -36,7 +36,7 @@ test cmdinfo-1.3 {command procedure and clientData} {testcmdinfo} {
     testcmdinfo create x1
     testcmdinfo modify x1
     testcmdinfo get x1
-} {CmdProc2 new_command_data CmdDelProc2 new_delete_data :: nativeObjectProc2}
+} {CmdProc2 new_command_data CmdDelProc2 new_delete_data :: stringProc}
 test cmdinfo-1.4 {command procedure and clientData} {testcmdinfo} {
     testcmdinfo create x1
     testcmdinfo modify x1
diff --git a/tests/encoding.test b/tests/encoding.test
index 09f3e42942c7..26ddb694af3a 100644
--- a/tests/encoding.test
+++ b/tests/encoding.test
@@ -464,7 +464,10 @@ test encoding-15.24 {UtfToUtfProc CESU-8 bug [048dd20b4171c8da]} {
 test encoding-15.25 {UtfToUtfProc CESU-8} {
     encoding convertfrom cesu-8 \x00
 } \x00
-test encoding-15.26 {UtfToUtfProc CESU-8} {
+test {encoding-15.26 cesu-8 tclnull strict} {UtfToUtfProc CESU-8} {
+    encoding convertfrom -profile tcl8 cesu-8 \xC0\x80
+} \x00
+test {encoding-15.26 cesu-8 tclnull tcl8} {UtfToUtfProc CESU-8} {
     encoding convertfrom -profile tcl8 cesu-8 \xC0\x80
 } \x00
 test encoding-15.27 {UtfToUtfProc -profile strict CESU-8} {
@@ -562,24 +565,35 @@ test encoding-16.18 {
 	return done
     } [namespace current]]
 } -result done
-test encoding-16.19 {Utf16ToUtfProc, bug [d19fe0a5b]} -body {
+test {encoding-16.19 strict} {Utf16ToUtfProc, bug [d19fe0a5b]} -body {
+    encoding convertfrom -profile strict utf-16 "\x41\x41\x41"
+} -returnCodes 1 -result {unexpected byte sequence starting at index 2: '\x41'}
+test {encoding-16.19 tcl8} {Utf16ToUtfProc, bug [d19fe0a5b]} -body {
     encoding convertfrom -profile tcl8 utf-16 "\x41\x41\x41"
 } -result \u4141\uFFFD
-test encoding-16.20 {Utf16ToUtfProc, bug [d19fe0a5b]} -constraints deprecated -body {
+test encoding-16.20 {utf16ToUtfProc, bug [d19fe0a5b]} \
+    -constraints deprecated -body {
     encoding convertfrom utf-16 "\xD8\xD8"
 } -result \uD8D8
-test encoding-16.21 {Utf32ToUtfProc, bug [d19fe0a5b]} -body {
+test encoding-16.21.tcl8 {Utf32ToUtfProc, bug [d19fe0a5b]} -body {
     encoding convertfrom -profile tcl8 utf-32 "\x00\x00\x00\x00\x41\x41"
 } -result \x00\uFFFD
+test encoding-16.21.strict {Utf32ToUtfProc, bug [d19fe0a5b]} -body {
+    encoding convertfrom -profile strict utf-32 "\x00\x00\x00\x00\x41\x41"
+} -returnCodes 1 -result {unexpected byte sequence starting at index 4: '\x41'}
+
 test encoding-16.22 {Utf16ToUtfProc, strict, bug [db7a085bd9]} -body {
     encoding convertfrom -profile strict utf-16le \x00\xD8
 } -returnCodes 1 -result {unexpected byte sequence starting at index 0: '\x00'}
 test encoding-16.23 {Utf16ToUtfProc, strict, bug [db7a085bd9]} -body {
     encoding convertfrom -profile strict utf-16le \x00\xDC
 } -returnCodes 1 -result {unexpected byte sequence starting at index 0: '\x00'}
-test encoding-16.24 {Utf32ToUtfProc} -body {
-    encoding convertfrom -profile tcl8 utf-32 "\xFF\xFF\xFF\xFF"
-} -result \uFFFD
+test {encoding-24.4 utf-8 invalid strict} {Parse invalid utf-8, strict} -body {
+    string length [encoding convertfrom -profile strict utf-8 "\xC0\x80"]
+} -returnCodes 1 -result {unexpected byte sequence starting at index 0: '\xC0'}
+test {encoding-24.4 utf-8 invalid tcl8} {UtfToUtfProc utf-8} {
+    encoding convertfrom -profile tcl8 utf-8 \xC0\x80
+} \x00
 test encoding-16.25 {Utf32ToUtfProc} -body {
     encoding convertfrom -profile tcl8 utf-32 "\x01\x00\x00\x01"
 } -result \uFFFD
@@ -789,16 +803,19 @@ test encoding-24.10 {Parse valid or invalid utf-8} {
 test encoding-24.11 {Parse valid or invalid utf-8} {
     string length [encoding convertfrom -profile tcl8 utf-8 "\xEF\xBF\xBF"]
 } 1
-test encoding-24.12 {Parse valid or invalid utf-8} -body {
+test encoding-24.12 {Parse invalid utf-8} -body {
     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 {
+test encoding-24.13 {Parse invalid utf-8} -body {
     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"]
+test encoding-24.14 {Parse valid utf-8} {
+    expr {[encoding convertfrom utf-8 "\xC2\x80"] eq "\u80"}
 } 1
-test encoding-24.15 {Parse valid or invalid utf-8} -body {
+test encoding-24.15.strict {Parse invalid utf-8, -profile strict} -body {
+    encoding convertfrom -profile strict utf-8 "Z\xE0\x80"
+} -returnCodes 1 -result "unexpected byte sequence starting at index 1: '\\xE0'"
+test encoding-24.15.tcl8 {Parse invalid utf-8, -profile tcl8} -body {
     encoding convertfrom -profile tcl8 utf-8 "Z\xE0\x80"
 } -result Z\xE0\u20AC
 test encoding-24.16 {Parse valid or invalid utf-8} -constraints testbytestring -body {
@@ -855,7 +872,7 @@ test encoding-24.31 {Parse invalid utf-8 with -profile tcl8} -body {
 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 -profile strict} -body {
+test encoding-24.33 {Try to generate invalid utf-8} -body {
     encoding convertto -profile strict utf-8 \uFFFF
 } -result \xEF\xBF\xBF
 test encoding-24.34 {Try to generate invalid utf-8 with -profile tcl8} -body {
diff --git a/tests/io.test b/tests/io.test
index fb2153584874..e3801464e719 100644
--- a/tests/io.test
+++ b/tests/io.test
@@ -1184,7 +1184,7 @@ test io-7.2 {FilterInputBytes: split up character in middle of buffer} {
     puts -nonewline $f "1234567890\n123\x82\x4F\x82\x50\x82"
     close $f
     set f [open $path(test1)]
-    fconfigure $f -encoding shiftjis
+    fconfigure $f -encoding shiftjis -profile tcl8
     set x [list [gets $f line] $line [eof $f]]
     close $f
     set x
@@ -1539,67 +1539,67 @@ test io-12.5 {ReadChars: fileevents on partial characters} {stdio fileevent} {
 } "{} timeout {} timeout 牦 {} eof 0 {}"
 test io-12.6 {ReadChars: too many chars read} {
     proc driver {cmd args} {
-        variable buffer
-        variable index
-        set chan [lindex $args 0]
-        switch -- $cmd {
-            initialize {
-                set index($chan) 0
-                set buffer($chan) [encoding convertto utf-8 \
-                        [string repeat 뻯 20][string repeat . 20]]
-                return {initialize finalize watch read}
-            }
-            finalize {
-                unset index($chan) buffer($chan)
-                return
-            }
-            watch {}
-            read {
-                set n [lindex $args 1]
-                set new [expr {$index($chan) + $n}]
-                set result [string range $buffer($chan) $index($chan) $new-1]
-                set index($chan) $new
-                return $result
-            }
-        }
+	variable buffer
+	variable index
+	set chan [lindex $args 0]
+	switch -- $cmd {
+	    initialize {
+		set index($chan) 0
+		set buffer($chan) [encoding convertto utf-8 \
+			[string repeat 뻯 20][string repeat . 20]]
+		return {initialize finalize watch read}
+	    }
+	    finalize {
+		unset index($chan) buffer($chan)
+		return
+	    }
+	    watch {}
+	    read {
+		set n [lindex $args 1]
+		set new [expr {$index($chan) + $n}]
+		set result [string range $buffer($chan) $index($chan) $new-1]
+		set index($chan) $new
+		return $result
+	    }
+	}
     }
     set c [chan create read [namespace which driver]]
     chan configure $c -encoding utf-8
     while {![eof $c]} {
-        read $c 15
+	read $c 15
     }
     close $c
 } {}
 test io-12.7 {ReadChars: too many chars read [bc5b790099]} {
     proc driver {cmd args} {
-        variable buffer
-        variable index
-        set chan [lindex $args 0]
-        switch -- $cmd {
-            initialize {
-                set index($chan) 0
-                set buffer($chan) [encoding convertto utf-8 \
-                        [string repeat 뻯 10]....뻯]
-                return {initialize finalize watch read}
-            }
-            finalize {
-                unset index($chan) buffer($chan)
-                return
-            }
-            watch {}
-            read {
-                set n [lindex $args 1]
-                set new [expr {$index($chan) + $n}]
-                set result [string range $buffer($chan) $index($chan) $new-1]
-                set index($chan) $new
-                return $result
-            }
-        }
+	variable buffer
+	variable index
+	set chan [lindex $args 0]
+	switch -- $cmd {
+	    initialize {
+		set index($chan) 0
+		set buffer($chan) [encoding convertto utf-8 \
+			[string repeat 뻯 10]....뻯]
+		return {initialize finalize watch read}
+	    }
+	    finalize {
+		unset index($chan) buffer($chan)
+		return
+	    }
+	    watch {}
+	    read {
+		set n [lindex $args 1]
+		set new [expr {$index($chan) + $n}]
+		set result [string range $buffer($chan) $index($chan) $new-1]
+		set index($chan) $new
+		return $result
+	    }
+	}
     }
     set c [chan create read [namespace which driver]]
     chan configure $c -encoding utf-8
     while {![eof $c]} {
-        read $c 7
+	read $c 7
     }
     close $c
 } {}
@@ -1614,7 +1614,7 @@ test io-12.8 {ReadChars: multibyte chars split} {
     close $f
     scan [string index $in end] %c
 } 160
-test io-12.9 {ReadChars: multibyte chars split} -body {
+test {io-12.9 profile tcl8} {ReadChars: multibyte chars split} -body {
     set f [open $path(test1) w]
     fconfigure $f -translation binary
     puts -nonewline $f [string repeat a 9]\xC2
@@ -1622,18 +1622,34 @@ test io-12.9 {ReadChars: multibyte chars split} -body {
     set f [open $path(test1)]
     fconfigure $f -encoding utf-8 -profile tcl8 -buffersize 10
     set in [read $f]
-    close $f
+    read $f
     scan [string index $in end] %c
 } -cleanup {
     catch {close $f}
 } -result 194
-test io-12.10 {ReadChars: multibyte chars split} -body {
+test {io-12.10 strict} {ReadChars: multibyte chars split} -body {
     set f [open $path(test1) w]
     fconfigure $f -translation binary
     puts -nonewline $f [string repeat a 9]\xC2
     close $f
     set f [open $path(test1)]
-    fconfigure $f -encoding utf-8 -buffersize 11
+    fconfigure $f -encoding utf-8 -profile strict -buffersize 10
+    set in [read $f]
+    close $f
+    scan [string index $in end] %c
+} -cleanup {
+    catch {close $f}
+} -returnCodes 1 -match glob -result {error reading "file*":\
+	invalid or incomplete multibyte or wide character}
+
+
+test {io-12.10 tcl8} {ReadChars: multibyte chars split} -body {
+    set f [open $path(test1) w]
+    fconfigure $f -translation binary
+    puts -nonewline $f [string repeat a 9]\xC2
+    close $f
+    set f [open $path(test1)]
+    fconfigure $f -encoding utf-8 -profile tcl8 -buffersize 10
     set in [read $f]
     close $f
     scan [string index $in end] %c
@@ -1990,7 +2006,7 @@ test io-14.9 {reuse of stdio special channels} {stdio fileevent} {
     file delete $path(test1)
     set f [open $path(script) w]
     puts $f {
-        array set path [lindex $argv 0]
+	array set path [lindex $argv 0]
 	set f [open $path(test1) w]
 	puts $f hello
 	close $f
@@ -2337,7 +2353,7 @@ test io-27.6 {FlushChannel, async flushing, async close} \
     close $f
     set x 01234567890123456789012345678901
     for {set i 0} {$i < 11} {incr i} {
-        set x "$x$x"
+	set x "$x$x"
     }
     set f [open $path(output) w]
     close $f
@@ -2351,9 +2367,9 @@ test io-27.6 {FlushChannel, async flushing, async close} \
 	vwait [namespace which -variable counter]
     }
     if {$counter == 1000} {
-        set result "file size only [file size $path(output)]"
+	set result "file size only [file size $path(output)]"
     } else {
-        set result ok
+	set result ok
     }
 } ok
 
@@ -2427,9 +2443,9 @@ test io-28.3 {CloseChannel, not called before output queue is empty} \
 	vwait [namespace which -variable counter]
     }
     if {$counter == 1000} {
-        set result probably_broken
+	set result probably_broken
     } else {
-        set result ok
+	set result ok
     }
 } ok
 test io-28.4 Tcl_Close testchannel {
@@ -4651,29 +4667,29 @@ test io-33.11 {TclGetsObjBinary, [10dc6daa37]} -setup {
 } -result {{} {} {} .......}
 test io-33.12 {Tcl_GetsObj, [10dc6daa37]} -setup {
     proc driver {cmd args} {
-        variable buffer
-        variable index
-        set chan [lindex $args 0]
-        switch -- $cmd {
-            initialize {
-                set index($chan) 0
-                set buffer($chan) .......
-                return {initialize finalize watch read}
-            }
-            finalize {
-                unset index($chan) buffer($chan)
-                return
-            }
-            watch {}
-            read {
-                set n [lindex $args 1]
+	variable buffer
+	variable index
+	set chan [lindex $args 0]
+	switch -- $cmd {
+	    initialize {
+		set index($chan) 0
+		set buffer($chan) .......
+		return {initialize finalize watch read}
+	    }
+	    finalize {
+		unset index($chan) buffer($chan)
+		return
+	    }
+	    watch {}
+	    read {
+		set n [lindex $args 1]
 		if {$n > 3} {set n 3}
-                set new [expr {$index($chan) + $n}]
-                set result [string range $buffer($chan) $index($chan) $new-1]
-                set index($chan) $new
-                return $result
-            }
-        }
+		set new [expr {$index($chan) + $n}]
+		set result [string range $buffer($chan) $index($chan) $new-1]
+		set index($chan) $new
+		return $result
+	    }
+	}
     }
 } -body {
     set c [chan create read [namespace which driver]]
@@ -4685,30 +4701,30 @@ test io-33.12 {Tcl_GetsObj, [10dc6daa37]} -setup {
 } -result {{} {} {} .......}
 test io-33.13 {Tcl_GetsObj, [10dc6daa37]} -setup {
     proc driver {cmd args} {
-        variable buffer
-        variable index
-        set chan [lindex $args 0]
-        switch -- $cmd {
-            initialize {
-                set index($chan) 0
-                set buffer($chan) [string repeat \
-                        [string repeat . 64]\n[string repeat . 25] 2]
-                return {initialize finalize watch read}
-            }
-            finalize {
-                unset index($chan) buffer($chan)
-                return
-            }
-            watch {}
-            read {
-                set n [lindex $args 1]
-                if {$n > 65} {set n 65}
-                set new [expr {$index($chan) + $n}]
-                set result [string range $buffer($chan) $index($chan) $new-1]
-                set index($chan) $new
-                return $result
-            }
-        }
+	variable buffer
+	variable index
+	set chan [lindex $args 0]
+	switch -- $cmd {
+	    initialize {
+		set index($chan) 0
+		set buffer($chan) [string repeat \
+			[string repeat . 64]\n[string repeat . 25] 2]
+		return {initialize finalize watch read}
+	    }
+	    finalize {
+		unset index($chan) buffer($chan)
+		return
+	    }
+	    watch {}
+	    read {
+		set n [lindex $args 1]
+		if {$n > 65} {set n 65}
+		set new [expr {$index($chan) + $n}]
+		set result [string range $buffer($chan) $index($chan) $new-1]
+		set index($chan) $new
+		return $result
+	    }
+	}
     }
 } -body {
     set c [chan create read [namespace which driver]]
@@ -5429,8 +5445,8 @@ test io-36.3 {Tcl_InputBlocked vs files, short read} {
 } {0 abc 0 defghijklmnop 0 1}
 test io-36.4 {Tcl_InputBlocked vs files, event driven read} {fileevent} {
     proc in {f} {
-        variable l
-        variable x
+	variable l
+	variable x
 	lappend l [read $f 3]
 	if {[eof $f]} {lappend l eof; close $f; set x done}
     }
@@ -5465,8 +5481,8 @@ test io-36.5 {Tcl_InputBlocked vs files, short read, nonblocking} {nonBlockFiles
 } {0 abc 0 defghijklmnop 0 1}
 test io-36.6 {Tcl_InputBlocked vs files, event driven read} {nonBlockFiles fileevent} {
     proc in {f} {
-        variable l
-        variable x
+	variable l
+	variable x
 	lappend l [read $f 3]
 	if {[eof $f]} {lappend l eof; close $f; set x done}
     }
@@ -5863,7 +5879,7 @@ test io-39.23 {Tcl_GetChannelOption, server socket is not readable or
     set l
 } {{} auto}
 test io-39.24 {Tcl_SetChannelOption, server socket is not readable or
-        writable so we can't change -eofchar or -translation } {
+    writable so we can't change -eofchar or -translation } {
     set l [list]
     set sock [socket -server [namespace code accept] -myaddr 127.0.0.1 0]
     fconfigure $sock -eofchar D -translation lf
@@ -6361,23 +6377,23 @@ test io-46.1 {Tcl event loop vs multiple interpreters} {testfevent fileevent not
 test io-46.2 {Tcl event loop vs multiple interpreters} testfevent {
     testfevent create
     testfevent cmd {
-        variable x 0
-        after 100 {set x triggered}
-        vwait [namespace which -variable x]
-        set x
+	variable x 0
+	after 100 {set x triggered}
+	vwait [namespace which -variable x]
+	set x
     }
 } {triggered}
 test io-46.3 {Tcl event loop vs multiple interpreters} testfevent {
     testfevent create
     testfevent cmd {
-        set x 0
-        after 10 {lappend x timer}
-        after 30
-        set result $x
-        update idletasks
-        lappend result $x
-        update
-        lappend result $x
+	set x 0
+	after 10 {lappend x timer}
+	after 30
+	set result $x
+	update idletasks
+	lappend result $x
+	update
+	lappend result $x
     }
 } {0 0 {0 timer}}
 
@@ -6394,7 +6410,7 @@ test io-47.1 {fileevent vs multiple interpreters} {testfevent fileevent} {
     lappend x [fileevent $f2 readable]
     testfevent delete
     lappend x [fileevent $f readable] [fileevent $f2 readable] \
-        [fileevent $f3 readable]
+	[fileevent $f3 readable]
     close $f
     close $f2
     close $f3
@@ -6410,11 +6426,11 @@ test io-47.2 {deleting fileevent on interpreter delete} {testfevent fileevent} {
     testfevent share $f2
     testfevent share $f3
     testfevent cmd "fileevent $f2 readable {script 2}
-        fileevent $f3 readable {script 3}"
+	fileevent $f3 readable {script 3}"
     fileevent $f4 readable {script 4}
     testfevent delete
     set x [list [fileevent $f readable] [fileevent $f2 readable] \
-                [fileevent $f3 readable] [fileevent $f4 readable]]
+		[fileevent $f3 readable] [fileevent $f4 readable]]
     close $f
     close $f2
     close $f3
@@ -6432,7 +6448,7 @@ test io-47.3 {deleting fileevent on interpreter delete} {testfevent fileevent} {
     fileevent $f readable {script 1}
     fileevent $f2 readable {script 2}
     testfevent cmd "fileevent $f3 readable {script 3}
-      fileevent $f4 readable {script 4}"
+	fileevent $f4 readable {script 4}"
     testfevent delete
     set x [list [fileevent $f readable] [fileevent $f2 readable] \
                 [fileevent $f3 readable] [fileevent $f4 readable]]
@@ -6451,8 +6467,8 @@ test io-47.4 {file events on shared files and multiple interpreters} {testfevent
     fileevent $f readable {script 2}
     fileevent $f2 readable {script 3}
     set x [list [fileevent $f2 readable] \
-                [testfevent cmd "fileevent $f readable"] \
-                [fileevent $f readable]]
+		[testfevent cmd "fileevent $f readable"] \
+		[fileevent $f readable]]
     testfevent delete
     close $f
     close $f2
@@ -6466,7 +6482,7 @@ test io-47.5 {file events on shared files, deleting file events} {testfevent fil
     fileevent $f readable {script 2}
     testfevent cmd "fileevent $f readable {}"
     set x [list [testfevent cmd "fileevent $f readable"] \
-                [fileevent $f readable]]
+		[fileevent $f readable]]
     testfevent delete
     close $f
     set x
@@ -7322,7 +7338,7 @@ test io-52.3 {TclCopyChannel} {fcopy} {
     set s1 [file size $thisScript]
     set s2 [file size $path(test1)]
     if {("$s1" == "$s2") && ($s0 == $s1)} {
-        lappend result ok
+	lappend result ok
     }
     set result
 } {0 0 ok}
@@ -7363,7 +7379,7 @@ test io-52.5 {TclCopyChannel, all} {fcopy} {
     set s1 [file size $thisScript]
     set s2 [file size $path(test1)]
     if {"$s1" == "$s2"} {
-        lappend result ok
+	lappend result ok
     }
     set result
 } {0 0 ok}
@@ -7380,7 +7396,7 @@ test io-52.5a {TclCopyChannel, all, other negative value} {fcopy} {
     set s1 [file size $thisScript]
     set s2 [file size $path(test1)]
     if {"$s1" == "$s2"} {
-        lappend result ok
+	lappend result ok
     }
     set result
 } {0 0 ok}
@@ -7397,7 +7413,7 @@ test io-52.5b {TclCopyChannel, all, wrap to negative value} {fcopy} {
     set s1 [file size $thisScript]
     set s2 [file size $path(test1)]
     if {"$s1" == "$s2"} {
-        lappend result ok
+	lappend result ok
     }
     set result
 } {0 0 ok}
@@ -7414,7 +7430,7 @@ test io-52.6 {TclCopyChannel} {fcopy} {
     set s1 [file size $thisScript]
     set s2 [file size $path(test1)]
     if {("$s1" == "$s2") && ($s0 == $s1)} {
-        lappend result ok
+	lappend result ok
     }
     set result
 } {0 0 ok}
@@ -7431,7 +7447,7 @@ test io-52.7 {TclCopyChannel} {fcopy} {
     close $f1
     close $f2
     if {"$s1" == "$s2"} {
-        lappend result ok
+	lappend result ok
     }
     set result
 } {0 0 ok}
@@ -7985,8 +8001,8 @@ proc doFcopy {in out {bytes 0} {error {}}} {
     } elseif {[eof $in]} {
 	set fcopyTestDone 0
     } else {
-        # Delay next fcopy to wait for size>0 input bytes
-        after 100 [list fcopy $in $out -size 1000 \
+	# Delay next fcopy to wait for size>0 input bytes
+	after 100 [list fcopy $in $out -size 1000 \
 		-command [namespace code [list doFcopy $in $out]]]
     }
 }
@@ -8001,9 +8017,9 @@ test io-53.7 {CopyData: Flooding fcopy from pipe} {stdio fcopy} {
 	proc Write {count} {
 	    puts -nonewline "1234567890"
 	    if {[incr count -1]} {
-	        after 10 [list Write $count]
+		after 10 [list Write $count]
 	    } else {
-	        set ::ready 1
+		set ::ready 1
 	    }
 	}
 	fconfigure stdout -buffering none
@@ -8345,21 +8361,21 @@ test io-53.12.1 {
 } A
 test io-53.13 {TclCopyChannel: read error reporting} -setup {
     proc driver {cmd args} {
-        variable buffer
-        variable index
-        set chan [lindex $args 0]
-        switch -- $cmd {
-            initialize {
-                return {initialize finalize watch read}
-            }
-            finalize {
-                return
-            }
-            watch {}
-            read {
+	variable buffer
+	variable index
+	set chan [lindex $args 0]
+	switch -- $cmd {
+	    initialize {
+		return {initialize finalize watch read}
+	    }
+	    finalize {
+		return
+	    }
+	    watch {}
+	    read {
 		error FAIL
-            }
-        }
+	    }
+	}
     }
     set outFile [makeFile {} out]
 } -body {
@@ -8375,21 +8391,21 @@ test io-53.13 {TclCopyChannel: read error reporting} -setup {
 } -result {error reading "rc*": *} -returnCodes error -match glob
 test io-53.14 {TclCopyChannel: write error reporting} -setup {
     proc driver {cmd args} {
-        variable buffer
-        variable index
-        set chan [lindex $args 0]
-        switch -- $cmd {
-            initialize {
-                return {initialize finalize watch write}
-            }
-            finalize {
-                return
-            }
-            watch {}
-            write {
-                error FAIL
-            }
-        }
+	variable buffer
+	variable index
+	set chan [lindex $args 0]
+	switch -- $cmd {
+	    initialize {
+		return {initialize finalize watch write}
+	    }
+	    finalize {
+		return
+	    }
+	    watch {}
+	    write {
+		error FAIL
+	    }
+	}
     }
     set inFile [makeFile {aaa} in]
 } -body {
@@ -8405,35 +8421,35 @@ test io-53.14 {TclCopyChannel: write error reporting} -setup {
 } -result {error writing "*": *} -returnCodes error -match glob
 test io-53.15 {[ed29c4da21] DoRead: fblocked seen as error} -setup {
     proc driver {cmd args} {
-        variable buffer
-        variable index
-        variable blocked
-        set chan [lindex $args 0]
-        switch -- $cmd {
-            initialize {
-                set index($chan) 0
-                set buffer($chan) [encoding convertto utf-8 \
-                        [string repeat a 100]]
-                set blocked($chan) 1
-                return {initialize finalize watch read}
-            }
-            finalize {
-                unset index($chan) buffer($chan) blocked($chan)
-                return
-            }
-            watch {}
-            read {
-                if {$blocked($chan)} {
-                    set blocked($chan) [expr {!$blocked($chan)}]
-                    return -code error EAGAIN
-                }
-                set n [lindex $args 1]
-                set new [expr {$index($chan) + $n}]
-                set result [string range $buffer($chan) $index($chan) $new-1]
-                set index($chan) $new
-                return $result
-            }
-        }
+	variable buffer
+	variable index
+	variable blocked
+	set chan [lindex $args 0]
+	switch -- $cmd {
+	    initialize {
+		set index($chan) 0
+		set buffer($chan) [encoding convertto utf-8 \
+			[string repeat a 100]]
+		set blocked($chan) 1
+		return {initialize finalize watch read}
+	    }
+	    finalize {
+		unset index($chan) buffer($chan) blocked($chan)
+		return
+	    }
+	    watch {}
+	    read {
+		if {$blocked($chan)} {
+		    set blocked($chan) [expr {!$blocked($chan)}]
+		    return -code error EAGAIN
+		}
+		set n [lindex $args 1]
+		set new [expr {$index($chan) + $n}]
+		set result [string range $buffer($chan) $index($chan) $new-1]
+		set index($chan) $new
+		return $result
+	    }
+	}
     }
     set c [chan create read [namespace which driver]]
     chan configure $c -encoding utf-8
@@ -8449,35 +8465,35 @@ test io-53.15 {[ed29c4da21] DoRead: fblocked seen as error} -setup {
 } -result 100
 test io-53.16 {[ed29c4da21] MBRead: fblocked seen as error} -setup {
     proc driver {cmd args} {
-        variable buffer
-        variable index
-        variable blocked
-        set chan [lindex $args 0]
-        switch -- $cmd {
-            initialize {
-                set index($chan) 0
-                set buffer($chan) [encoding convertto utf-8 \
-                        [string repeat a 100]]
-                set blocked($chan) 1
-                return {initialize finalize watch read}
-            }
-            finalize {
-                unset index($chan) buffer($chan) blocked($chan)
-                return
-            }
-            watch {}
-            read {
-                if {$blocked($chan)} {
-                    set blocked($chan) [expr {!$blocked($chan)}]
-                    return -code error EAGAIN
-                }
-                set n [lindex $args 1]
-                set new [expr {$index($chan) + $n}]
-                set result [string range $buffer($chan) $index($chan) $new-1]
-                set index($chan) $new
-                return $result
-            }
-        }
+	variable buffer
+	variable index
+	variable blocked
+	set chan [lindex $args 0]
+	switch -- $cmd {
+	    initialize {
+		set index($chan) 0
+		set buffer($chan) [encoding convertto utf-8 \
+			[string repeat a 100]]
+		set blocked($chan) 1
+		return {initialize finalize watch read}
+	    }
+	    finalize {
+		unset index($chan) buffer($chan) blocked($chan)
+		return
+	    }
+	    watch {}
+	    read {
+		if {$blocked($chan)} {
+		    set blocked($chan) [expr {!$blocked($chan)}]
+		    return -code error EAGAIN
+		}
+		set n [lindex $args 1]
+		set new [expr {$index($chan) + $n}]
+		set result [string range $buffer($chan) $index($chan) $new-1]
+		set index($chan) $new
+		return $result
+	    }
+	}
     }
     set c [chan create read [namespace which driver]]
     chan configure $c -encoding utf-8 -translation lf
@@ -8493,29 +8509,29 @@ test io-53.16 {[ed29c4da21] MBRead: fblocked seen as error} -setup {
 } -result 100
 test io-53.17 {[7c187a3773] MBWrite: proper inQueueTail handling} -setup {
     proc driver {cmd args} {
-        variable buffer
-        variable index
-        set chan [lindex $args 0]
-        switch -- $cmd {
-            initialize {
-                set index($chan) 0
-                set buffer($chan) [encoding convertto utf-8 \
-                        line\n[string repeat a 100]line\n]
-                return {initialize finalize watch read}
-            }
-            finalize {
-                unset index($chan) buffer($chan)
-                return
-            }
-            watch {}
-            read {
-                set n [lindex $args 1]
-                set new [expr {$index($chan) + $n}]
-                set result [string range $buffer($chan) $index($chan) $new-1]
-                set index($chan) $new
-                return $result
-            }
-        }
+	variable buffer
+	variable index
+	set chan [lindex $args 0]
+	switch -- $cmd {
+	    initialize {
+		set index($chan) 0
+		set buffer($chan) [encoding convertto utf-8 \
+			line\n[string repeat a 100]line\n]
+		return {initialize finalize watch read}
+	    }
+	    finalize {
+		unset index($chan) buffer($chan)
+		return
+	    }
+	    watch {}
+	    read {
+		set n [lindex $args 1]
+		set new [expr {$index($chan) + $n}]
+		set result [string range $buffer($chan) $index($chan) $new-1]
+		set index($chan) $new
+		return $result
+	    }
+	}
     }
     set c [chan create read [namespace which driver]]
     chan configure $c -encoding utf-8 -translation lf -buffersize 107
diff --git a/tests/ioCmd.test b/tests/ioCmd.test
index 1c06ba31914d..471659aafc14 100644
--- a/tests/ioCmd.test
+++ b/tests/ioCmd.test
@@ -1367,7 +1367,7 @@ test iocmd-24.15 {chan write, EAGAIN means that writing is not allowed at this t
 
 test iocmd-25.1 {chan configure, cgetall, standard options} -match glob -body {
     set res {}
-    proc foo {args} {oninit; onfinal; track; note MUST_NOT_HAPPEN; return}
+    proc foo args {oninit; onfinal; track; note MUST_NOT_HAPPEN; return}
     set c [chan create {r w} foo]
     note [fconfigure $c]
     close $c
@@ -1376,7 +1376,7 @@ test iocmd-25.1 {chan configure, cgetall, standard options} -match glob -body {
 } -result {{-blocking 1 -buffering full -buffersize 4096 -encoding * -eofchar {} -profile * -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 ""}
+    proc foo args {oninit cget cgetall; onfinal; track; return ""}
     set c [chan create {r w} foo]
     note [fconfigure $c]
     close $c
@@ -1385,9 +1385,9 @@ test iocmd-25.2 {chan configure, cgetall, no options} -match glob -body {
 } -result {{cgetall rc*} {-blocking 1 -buffering full -buffersize 4096 -encoding * -eofchar {} -profile * -translation {auto *}}}
 test iocmd-25.3 {chan configure, cgetall, regular result} -match glob -body {
     set res {}
-    proc foo {args} {
+    proc foo args {
 	oninit cget cgetall; onfinal; track
-	return "-bar foo -snarf x"
+	return {-bar foo -snarf x}
     }
     set c [chan create {r w} foo]
     note [fconfigure $c]