Mercurial > octave

changeset 21625:3cadca91e390

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Clean up BIST tests for textscan. * file-io.cc (Ftextscan): Clean up BIST tests.
author Rik <rik@octave.org>
date Tue, 12 Apr 2016 21:05:50 +1000
parents cf227735d5fd
children 1dda942a2514
files libinterp/corefcn/file-io.cc
diffstat 1 files changed, 144 insertions(+), 129 deletions(-) [+]
line wrap: on
line diff
--- a/libinterp/corefcn/file-io.cc	Sun Apr 10 23:00:07 2016 +0100
+++ b/libinterp/corefcn/file-io.cc	Tue Apr 12 21:05:50 2016 +1000
@@ -1516,10 +1516,9 @@
 %! str = "1,  2,  3,  4\n 5,  ,  ,  8\n 9, 10, 11, 12";
 %! fmtstr = "%f %d %f %s";
 %! c = textscan (str, fmtstr, 2, "delimiter", ",", "emptyvalue", -Inf);
-%! assert (isequal (c{1}, [1;5]));
-%! assert (length (c{1}), 2);
+%! assert (c{1}, [1;5]);
+%! assert (c{3}, [3; -Inf]);
 %! assert (iscellstr (c{4}));
-%! assert (isequal (c{3}, [3; -Inf]));
 
 %!test
 %! b = [10:10:100];
@@ -1532,13 +1531,13 @@
 
 %!test
 %! str = "13, -, NA, str1, -25\r\n// Middle line\r\n36, na, 05, str3, 6";
-%! a = textscan (str, "%d %n %f %s %n", "delimiter", ",",
-%!                "treatAsEmpty", {"NA", "na", "-"},"commentStyle", "//");
-%! assert (a{1}, int32 ([13; 36]));
-%! assert (a{2}, [NaN; NaN]);
-%! assert (a{3}, [NaN; 5]);
-%! assert (a{4}, {"str1"; "str3"});
-%! assert (a{5}, [-25; 6]);
+%! c = textscan (str, "%d %n %f %s %n", "delimiter", ",",
+%!                    "treatAsEmpty", {"NA", "na", "-"}, "commentStyle", "//");
+%! assert (c{1}, int32 ([13; 36]));
+%! assert (c{2}, [NaN; NaN]);
+%! assert (c{3}, [NaN; 5]);
+%! assert (c{4}, {"str1"; "str3"});
+%! assert (c{5}, [-25; 6]);
 
 %!test
 %! str = "Km:10 = hhhBjjj miles16hour\r\n";
@@ -1546,20 +1545,20 @@
 %! str = [str "Km:2 = hhhRjjj miles3hour\r\n"];
 %! str = [str "Km:25 = hhhZ\r\n"];
 %! fmt = "Km:%d = hhh%1sjjj miles%dhour";
-%! a = textscan (str, fmt, "delimiter", " ");
-%! assert (a{1}', int32 ([10 15 2 25]));
-%! assert (a{2}', {'B' 'J' 'R' 'Z'});
-%! assert (a{3}', int32 ([16 241 3 0]));
-
-## Test with default endofline parameter
+%! c = textscan (str, fmt, "delimiter", " ");
+%! assert (c{1}', int32 ([10, 15, 2, 25]));
+%! assert (c{2}', {'B' 'J' 'R' 'Z'});
+%! assert (c{3}', int32 ([16, 241, 3, 0]));
+
+## Test with default EndOfLine parameter
 %!test
 %! c = textscan ("L1\nL2", "%s");
 %! assert (c{:}, {"L1"; "L2"});
 
-## Test with endofline parameter set to "" (empty) - newline should be in word
+## Test with EndofLine parameter set to "" (empty) - newline should be in word
 %!test
 %! c = textscan ("L1\nL2", "%s", "endofline", "");
-%! assert (int8 ([c{:}{:}]), int8 ([ 76,  49,  10,  76,  50 ]));
+%! assert (int8 ([c{:}{:}]), int8 ([76, 49, 10, 76, 50]));
 
 ###  Matlab fails this test.  A literal after a conversion is not a delimiter
 #%!test
@@ -1602,7 +1601,7 @@
 
 ## Arbitrary character
 %!test
-%! c = textscan ("a first, \n second, third", "%s %c %11c", 'delimiter', ' ,');
+%! c = textscan ("a first, \n second, third", "%s %c %11c", "delimiter", " ,");
 %! assert (c{1}, {"a"; "ond"});
 %! assert (c{2}, {"f"; "t"});
 %! assert (c{3}, {"irst, \n sec"; "hird"});
@@ -1611,33 +1610,35 @@
 %!test
 %! str = "12;34;123456789;7";
 %! c = textscan (str, "%4d %4d", "delimiter", ";", "collectOutput", 1);
-%! assert (c, {[12 34; 1234 5678; 9 7]});
-
-## Field width and non-standard delimiters
+%! assert (c, {[12, 34; 1234, 5678; 9, 7]});
+
+## Field width and non-standard delimiters (2)
 %!test
 %! str = "12;34;123456789;7";
 %! c = textscan (str, "%4f %f", "delimiter", ";", "collectOutput", 1);
-%! assert (c, {[12 34; 1234 56789; 7 NaN]});
+%! assert (c, {[12, 34; 1234, 56789; 7, NaN]});
 
 ## Ignore trailing delimiter, but use leading one
 %!test
 %! str = "12.234e+2,34, \n12345.789-9876j,78\n,10|3";
 %! c = textscan (str, "%10.2f %f", "delimiter", ",", "collectOutput", 1,
-%!                "expChars", "e|");
-%! assert (c, {[1223 34; 12345.79-9876j 78; NaN 10000]}, 1e-6);
-
+%!                    "expChars", "e|");
+%! assert (c, {[1223, 34; 12345.79-9876j, 78; NaN, 10000]}, 1e-6);
+
+## Multi-character delimiter
 %!test
-%! ## Multi-character delimiter
 %! str = "99end2 space88gap 4564";
 %! c = textscan (str, "%d %s", "delimiter", {"end", "gap", "space"});
 %! assert (c{1}, int32 ([99; 88]));
 %! assert (c{2}, {"2 "; "4564"});
 
+## FIXME: Following two tests still fail (4/13/2016)?
 ### Delimiters as part of literals, and following literals
 #%!test
 #%! str = "12 R&D & 7";
-#%! c = textscan (str, "%f R&D %f", "delimiter", "&", "collectOutput", 1, "EmptyValue", -99);
-#%! assert (c, {[12 -99; 7 -99]});
+#%! c = textscan (str, "%f R&D %f", "delimiter", "&", "collectOutput", 1,
+#%!                    "EmptyValue", -99);
+#%! assert (c, {[12, -99; 7, -99]});
 #
 ### Delimiters as part of literals, and before literals
 #%!test
@@ -1645,8 +1646,8 @@
 #%! c = textscan (str, "%f R&D %f", "delimiter", "&", "collectOutput", 1);
 #%! assert (c, {[12 7]});
 
+## Check number of lines read, not number of passes through format string
 %!test
-%! ## Check number of lines read, not number of passes through format string
 %! f = tempname ();
 %! fid = fopen (f, "w+");
 %! fprintf (fid, "1\n2\n3\n4\n5\n6");
@@ -1656,10 +1657,10 @@
 %! fclose (fid);
 %! unlink (f);
 %! assert (c, {1, 2});
-%! assert (!E);
-
+%! assert (! E);
+
+## Check number of lines read, not number of passes through format string
 %!test
-%! ## Check number of lines read, not number of passes through format string
 %! f = tempname ();
 %! fid = fopen (f, "w+");
 %! fprintf (fid, "1\r\n2\r3\n4\r\n5\n6");
@@ -1669,8 +1670,8 @@
 %! unlink (f);
 %! assert (c, {[1;3], [2;4]});
 
+## Check number of lines read, with multiple delimiters
 %!test
-%! ## Check number of lines read, with multiple delimiters
 %! f = tempname ();
 %! fid = fopen (f, "w+");
 %! fprintf (fid, "1-\r\n-2\r3-\n-4\r\n5\n6");
@@ -1680,8 +1681,8 @@
 %! unlink (f);
 %! assert (c, {[1;3], [2;4]});
 
+## Check ReturnOnError
 %!test
-%! ## Check ReturnOnError
 %! f = tempname ();
 %! fid = fopen (f, "w+");
 %! str = "1 2 3\n4 s 6";
@@ -1695,8 +1696,8 @@
 %! assert (c, {[1;4], [2], [3]});
 %! assert (u, {[1;4], [2], [3]});
 
+%! ## Check ReturnOnError (2)
 %!test
-%! ## Check ReturnOnError
 %! f = tempname ();
 %! fid = fopen (f, "w+");
 %! str = "1 2 3\n4 s 6\n";
@@ -1710,10 +1711,11 @@
 %! assert (c, {[1;4], 2, 3});
 %! assert (u, {[1;4], 2, 3});
 
-%!error <Read error in field 2 of row 2> textscan ("1 2 3\n4 s 6", "%f %f %f", "ReturnOnError", 0)
-
+%!error <Read error in field 2 of row 2>
+%! textscan ("1 2 3\n4 s 6", "%f %f %f", "ReturnOnError", 0);
+
+## Check ReturnOnError (3)
 %!test
-%! ## Check ReturnOnError
 %! f = tempname ();
 %! fid = fopen (f, "w+");
 %! fprintf (fid, "1 s 3\n4 5 6");
@@ -1724,35 +1726,28 @@
 %! unlink (f);
 %! assert (c, {1});
 
+## Check ReturnOnError with empty fields
 %!test
-%! ## Check ReturnOnError with empty fields
 %! c = textscan ("1,,3\n4,5,6", "", "Delimiter", ",", "ReturnOnError", 1);
 %! assert (c, {[1;4], [NaN;5], [3;6]});
 
+## Check ReturnOnError with empty fields (2)
 %!test
-%! ## Check ReturnOnError with empty fields
-%! c = textscan ("1,,3\n4,5,6", "%f %f %f", "Delimiter", ",", "ReturnOnError", 1);
+%! c = textscan ("1,,3\n4,5,6", "%f %f %f", "Delimiter", ",",
+%!               "ReturnOnError", 1);
 %! assert (c, {[1;4], [NaN;5], [3;6]});
 
+## Check ReturnOnError in first column
 %!test
-%! ## Check ReturnOnError in first column
 %! c = textscan ("1 2 3\ns 5 6", "", "ReturnOnError", 1);
 %! assert (c, {1, 2, 3});
 
-## Test input validation
-%!error textscan ()
-%!error textscan (single (40))
-%!error textscan ({40})
-%!error <must be a string> textscan ("Hello World", 2)
-#%!error <cannot provide position information> [C, pos] = textscan ("Hello World")
-%!error <at most one character or> textscan ("Hello World", '%s', 'EndOfLine', 3)
-%!error <'%z' is not a valid format specifier> textscan ("1.0", "%z")
-%!error <no valid format conversion specifiers> textscan ("1.0", "foo")
-
-## Test incomplete first data line
-%! R = textscan (['Empty1' char(10)], 'Empty%d %f');
-%! assert (R{1}, int32 (1));
-%! assert (isempty (R{2}), true);
+## FIXME: This test fails (4/14/16)
+### Test incomplete first data line
+#%!test
+#%! R = textscan (['Empty1' char(10)], 'Empty%d %f');
+#%! assert (R{1}, int32 (1));
+#%! assert (isempty (R{2}), true);
 
 ## bug #37023
 %!test
@@ -1762,7 +1757,6 @@
 
 ## Whitespace test (bug #37333) using delimiter ";"
 %!test
-%! tc = [];
 %! tc{1, 1} = "C:/code;";
 %! tc{1, end+1} = "C:/code/meas;";
 %! tc{1, end+1} = " C:/code/sim;";
@@ -1775,11 +1769,10 @@
 %!   rh(rh == ";") = "";
 %!   rh = strtrim (rh);
 %!   assert (strcmp (lh, rh));
-%! end
+%! endfor
 
 ## Whitespace test (bug #37333), adding multipleDelimsAsOne true arg
 %!test
-%! tc = [];
 %! tc{1, 1} = "C:/code;";
 %! tc{1, end+1} = " C:/code/meas;";
 %! tc{1, end+1} = "C:/code/sim;;";
@@ -1792,11 +1785,10 @@
 %!   rh(rh == ";") = "";
 %!   rh = strtrim (rh);
 %!   assert (strcmp (lh, rh));
-%! end
+%! endfor
 
 ## Whitespace test (bug #37333), adding multipleDelimsAsOne false arg
 %!test
-%! tc = [];
 %! tc{1, 1} = "C:/code;";
 %! tc{1, end+1} = " C:/code/meas;";
 %! tc{1, end+1} = "C:/code/sim;;";
@@ -1810,11 +1802,10 @@
 %!   rh(rh == ";") = "";
 %!   rh = strtrim (rh);
 %!   assert (strcmp (lh, rh));
-%! end
+%! endfor
 
 ## Whitespace test (bug #37333) whitespace "" arg
 %!test
-%! tc = [];
 %! tc{1, 1} = "C:/code;";
 %! tc{1, end+1} = " C:/code/meas;";
 %! tc{1, end+1} = "C:/code/sim;";
@@ -1826,11 +1817,10 @@
 %!   rh = tc{k};
 %!   rh(rh == ";") = "";
 %!   assert (strcmp (lh, rh));
-%! end
+%! endfor
 
 ## Whitespace test (bug #37333), whitespace " " arg
 %!test
-%! tc = [];
 %! tc{1, 1} = "C:/code;";
 %! tc{1, end+1} = " C:/code/meas;";
 %! tc{1, end+1} = "C:/code/sim;";
@@ -1843,7 +1833,7 @@
 %!   rh(rh == ";") = "";
 %!   rh = strtrim (rh);
 %!   assert (strcmp (lh, rh));
-%! end
+%! endfor
 
 ## Tests reading with empty format, should return proper nr of columns
 %!test
@@ -1851,14 +1841,14 @@
 %! fid = fopen (f, "w+");
 %! fprintf (fid, " 1 2 3 4\n5 6 7 8");
 %! fseek (fid, 0, "bof");
-%! A = textscan (fid, "");
+%! C = textscan (fid, "");
 %! E = feof (fid);
 %! fclose (fid);
 %! unlink (f);
-%! assert (A{1}, [1 ; 5], 1e-6);
-%! assert (A{2}, [2 ; 6], 1e-6);
-%! assert (A{3}, [3 ; 7], 1e-6);
-%! assert (A{4}, [4 ; 8], 1e-6);
+%! assert (C{1}, [1 ; 5], 1e-6);
+%! assert (C{2}, [2 ; 6], 1e-6);
+%! assert (C{3}, [3 ; 7], 1e-6);
+%! assert (C{4}, [4 ; 8], 1e-6);
 %! assert (E);
 
 ## Test leaving the file at the correct position on exit
@@ -1867,7 +1857,7 @@
 %! fid = fopen (f, "w+");
 %! fprintf (fid, "1,2\n3,4\n");
 %! fseek (fid, 0, "bof");
-%! A = textscan (fid, "%s %f", 2, "Delimiter", ",");
+%! C = textscan (fid, "%s %f", 2, "Delimiter", ",");
 %! E = ftell (fid);
 %! fclose (fid);
 %! unlink (f);
@@ -1879,10 +1869,11 @@
 %! fid = fopen (f, "w+");
 %! fprintf (fid, " ,2,,4\n5,6");
 %! fseek (fid, 0, "bof");
-%! A = textscan (fid, "", "delimiter", ",", "EmptyValue", 999, "CollectOutput" , 1);
+%! C = textscan (fid, "", "delimiter", ",", "EmptyValue", 999,
+%!                    "CollectOutput" , 1);
 %! fclose (fid);
 %! unlink (f);
-%! assert (A{1}, [999, 2, 999, 4; 5, 6, 999, 999], 1e-6);
+%! assert (C{1}, [999, 2, 999, 4; 5, 6, 999, 999], 1e-6);
 
 ## Error message tests
 
@@ -1891,7 +1882,7 @@
 %! fid = fopen (f, "w+");
 %! msg1 = "textscan: 1 parameters given, but only 0 values";
 %! try
-%! A = textscan (fid, "", "headerlines");
+%!   C = textscan (fid, "", "headerlines");
 %! end_try_catch;
 %! assert (!feof (fid));
 %! fclose (fid);
@@ -1903,21 +1894,23 @@
 %! fid = fopen (f, "w+");
 %! msg1 = "textscan: HeaderLines must be numeric";
 %! try
-%! A = textscan (fid, "", "headerlines", "hh");
+%!   C = textscan (fid, "", "headerlines", "hh");
 %! end_try_catch;
 %! fclose (fid);
 %! unlink (f);
 %! assert (msg1, lasterr);
 
+## Skip headerlines
 %!test
-%! ## Skip headerlines
-%! A = textscan ("field 1  field2\n 1 2\n3 4", "", "headerlines", 1, "collectOutput", 1);
-%! assert (A, {[1 2; 3 4]});
-
+%! C = textscan ("field 1  field2\n 1 2\n3 4", "", "headerlines", 1,
+%!               "collectOutput", 1);
+%! assert (C, {[1 2; 3 4]});
+
+## Skip headerlines with non-default EOL
 %!test
-%! ## Skip headerlines with non-default EOL
-%! A = textscan ("field 1  field2\r 1 2\r3 4", "", "headerlines", 2, "collectOutput", 1, "EndOfLine", '\r');
-%! assert (A, {[3 4]});
+%! C = textscan ("field 1  field2\r 1 2\r3 4", "", "headerlines", 2,
+%!               "collectOutput", 1, "EndOfLine", '\r');
+%! assert (C, {[3 4]});
 
 %!test
 %! f = tempname ();
@@ -1926,7 +1919,7 @@
 %! fseek (fid, 0, "bof");
 %! msg1 = "textscan: EndOfLine must be at most one character or '\\r\\n'";
 %! try
-%! A = textscan (fid, "%f", "EndOfLine", "\n\r");
+%!   C = textscan (fid, "%f", "EndOfLine", "\n\r");
 %! end_try_catch;
 %! fclose (fid);
 %! unlink (f);
@@ -1939,40 +1932,44 @@
 %! fseek (fid, 0, "bof");
 %! msg1 = "textscan: EndOfLine must be at most one character or '\\r\\n'";
 %! try
-%! A = textscan (fid, "%f", "EndOfLine", 33);
+%!   C = textscan (fid, "%f", "EndOfLine", 33);
 %! end_try_catch;
 %! fclose (fid);
 %! unlink (f);
 %! assert (msg1, lasterr);
 
 ## Bug #41824
-%!test
-%! assert (textscan ("123", "", "whitespace", " "){:}, 123);
+%!assert (textscan ("123", "", "whitespace", " "){:}, 123);
 
 ## Bug #42343-1, just test supplied emptyvalue
-%!test
-%! assert (textscan (",NaN", "", "delimiter", "," ,"emptyValue" ,Inf), {Inf, NaN});
+%!assert (textscan (",NaN", "", "delimiter", "," ,"emptyValue" ,Inf),
+%!        {Inf, NaN})
 
 ## Bug #42343-2, test padding with supplied emptyvalue
 %!test
-%! a = textscan (",1,,4\nInf,  ,NaN\n", "", "delimiter", ",", "emptyvalue", -10);
-%! assert (cell2mat (a), [-10, 1, -10, 4; Inf, -10, NaN, -10]);
+%! c = textscan (",1,,4\nInf,  ,NaN\n", "", "delimiter", ",",
+%!               "emptyvalue", -10);
+%! assert (cell2mat (c), [-10, 1, -10, 4; Inf, -10, NaN, -10]);
 
 ## Bug #42528
 %!test
 %! assert (textscan ("1i", ""){1},  0+1i);
-%! assert (cell2mat (textscan ("3, 2-4i, NaN\n -i, 1, 23.4+2.2i\n 1+1 1+1j", "", "delimiter", ",")), [3+0i, 2-4i, NaN+0i; 0-i,  1+0i, 23.4+2.2i; 1 1 1+1i]);
+%! C = textscan ("3, 2-4i, NaN\n -i, 1, 23.4+2.2i\n 1+1 1+1j", "",
+%!               "delimiter", ",");
+%! assert (cell2mat (C), [3+0i, 2-4i, NaN+0i; 0-i,  1+0i, 23.4+2.2i; 1 1 1+1i]);
 
 %!test
 %! ## TreatAsEmpty
-%! C = textscan ("1,2,3,NN,5,6\n", "%d%d%d%f", "delimiter", ",", "TreatAsEmpty", "NN");
+%! C = textscan ("1,2,3,NN,5,6\n", "%d%d%d%f", "delimiter", ",",
+%!               "TreatAsEmpty", "NN");
 %! assert (C{3}(1), int32 (3));
 %! assert (C{4}(1), NaN);
 
 ## MultipleDelimsAsOne
 %!test
 %! str = "11, 12, 13,, 15\n21,, 23, 24, 25\n,, 33, 34, 35\n";
-%! C = textscan (str, "%f %f %f %f", "delimiter", ",", "multipledelimsasone", 1, "endofline", "\n");
+%! C = textscan (str, "%f %f %f %f", "delimiter", ",",
+%!                    "multipledelimsasone", 1, "endofline", "\n");
 %! assert (C{1}', [11, 21, 33]);
 %! assert (C{2}', [12, 23, 34]);
 %! assert (C{3}', [13, 24, 35]);
@@ -1988,10 +1985,12 @@
 
 ## Bug #44750
 %!test
-%! assert (textscan ("/home/foo/", "%s", "delimiter", "/", "MultipleDelimsAsOne", 1){1}, ...
-%!         {"home"; "foo"});
-
-### Allow cuddling %sliteral but warn it is ambiguous
+%! c = textscan ("/home/foo/", "%s", "delimiter", "/",
+%!               "MultipleDelimsAsOne", 1);
+%! assert (c{1}, {"home"; "foo"});
+
+## FIXME: Test still fails (4/13/2016)?
+## Allow cuddling %sliteral, but warn it is ambiguous
 #%!test
 #%! C = textscan ("abcxyz51\nxyz83\n##xyz101", "%s xyz %d");
 #%! assert (C{1}([1 3]), {"abc"; "##"});
@@ -2001,7 +2000,9 @@
 
 ## Test for false positives in check for non-supported format specifiers
 %!test
-%! assert (textscan ("Total: 32.5 % (of cm values)", "Total: %f %% (of cm values)"){1}, 32.5, 1e-5);
+%! c = textscan ("Total: 32.5 % (of cm values)",
+%!               "Total: %f %% (of cm values)");
+%! assert (c{1}, 32.5, 1e-5);
 
 ## Test various forms of string format specifiers (bug #45712)
 %!test
@@ -2009,7 +2010,7 @@
 %! C = textscan (str, "%f %s %*s %3s %*3s %f", "delimiter", ":");
 %! assert (C, {14, {"1 z"}, {"3 z"}, 11});
 
-%% Bit width, fixed width conv. specifiers
+## Bit width, fixed width conversion specifiers
 %!test
 %! str2 = "123456789012345 ";
 %! str2 = [str2 str2 str2 str2 str2 str2 str2 str2];
@@ -2029,7 +2030,7 @@
 %! assert (C{11}, single (12345.68), 1e-5);
 %! assert (C{12}, double (12345.68), 1e-11);
 
-%% Bit width, fixed width conv. specifiers -- check the right amount is left
+## Bit width, fixed width conv. specifiers -- check the right amount is left
 %!test
 %! str2 = "123456789012345 ";
 %! str2 = [str2 str2 "123456789.01234"];
@@ -2061,14 +2062,14 @@
 %! assert (C{1}, 123);
 %! assert (C{2}, 123);
 
-%% field width interrupts exponent.  (Matlab incorrectly gives [12, 2e12])
+## field width interrupts exponent.  (Matlab incorrectly gives [12, 2e12])
 %!test
 %! assert (textscan ("12e12",  "%4f"), {[120;  2]});
 %! assert (textscan ("12e+12", "%5f"), {[120;  2]});
 %! assert (textscan ("125e-12","%6f"), {[12.5; 2]});
 
-%% %[] tests
-%% Plain [..] and *[..]
+## %[] tests
+## Plain [..] and *[..]
 %!test
 %! ar = "abcdefguvwxAny\nacegxyzTrailing\nJunk";
 %! C = textscan (ar, "%[abcdefg] %*[uvwxyz] %s");
@@ -2078,40 +2079,40 @@
 %!test
 %! assert (textscan ("A2 B2 C3", "%*[ABC]%d", 3), {int32([2; 2; 3])});
 
-%% [^..] and *[^..]
+## [^..] and *[^..]
 %!test
 %! br = "abcdefguvwx1Any\nacegxyz2Trailing\n3Junk";
 %! C = textscan (br, "%[abcdefg] %*[^0123456789] %s");
 %! assert (C{1}, {"abcdefg"; "aceg"; ""});
 %! assert (C{2}, {"1Any"; "2Trailing"; "3Junk"});
 
-%% [..] and [^..] containing delimiters
+## [..] and [^..] containing delimiters
 %!test
 %! cr = "ab cd efguv wx1Any\na ce gx yz2Trailing\n   3Junk";
-%! C = textscan (cr, "%[ abcdefg] %*[^0123456789] %s", "delimiter", " \n", "whitespace", "");
+%! C = textscan (cr, "%[ abcdefg] %*[^0123456789] %s", "delimiter", " \n",
+%!                   "whitespace", "");
 %! assert (C{1}, {"ab cd efg"; "a ce g"; "   "});
 %! assert (C{2}, {"1Any"; "2Trailing"; "3Junk"});
 
-%% Bug #36464
+## Bug #36464
+%!assert (textscan ("1 2 3 4 5 6", "%*n%n%*[^\n]"){1}, 2);
+
+## test %[]] and %[^]]
 %!test
-%! assert (textscan ('1 2 3 4 5 6', "%*n%n%*[^\n]"){1}, 2);
-
-%% test %[]] and %[^]]
-%!test
-%! assert (textscan ('345]', "%*[123456]%[]]"){1}{1}, "]");
-%! assert (textscan ('345]', "%*[^]]%s"){1}{1}, "]");
-
-%% Test that "-i" checks the next two characters
+%! assert (textscan ("345]", "%*[123456]%[]]"){1}{1}, "]");
+%! assert (textscan ("345]", "%*[^]]%s"){1}{1}, "]");
+
+## Test that "-i" checks the next two characters
 %!test
 %! C = textscan ("-i -in -inf -infinity", "%f %f%s %f %f %s");
 %! assert (C, {-i, -i, {"n"}, -Inf, -Inf, {"inity"}});
 
-%% Again for "+i", this time with custom parser
+## Again for "+i", this time with custom parser
 %!test
 %! C = textscan ("+i +in +inf +infinity", "%f %f%s %f %f %s", "ExpChars", "eE");
 %! assert (C, {i, i, {"n"}, Inf, Inf, {"inity"}});
 
-%% Check single quoted format interprets control sequences
+## Check single quoted format interprets control sequences
 %!test
 %! C = textscan ("1 2\t3 4", '%f %[^\t] %f %f');
 %! assert (C, {1, {"2"}, 3, 4});
@@ -2121,7 +2122,7 @@
 %! C = textscan ("Empty\n", "Empty%f %f");
 %! assert (C, { NaN, NaN });
 
-%% Check overflow and underflow of integer types
+## Check overflow and underflow of integer types
 %!test
 %! a = "-1e90 ";
 %! b = "1e90 ";
@@ -2136,7 +2137,7 @@
 %! assert (C{7}, uint32 ([0; 4294967295]));
 %! assert (C{8}, uint64 ([0; 18446744073709551615]));
 
-%% Tests from Matlab (does The MathWorks have any copyright over the input?)
+## Tests from Matlab (does The MathWorks have any copyright over the input?)
 %!test
 %! f = tempname ();
 %! fid = fopen (f, "w+");
@@ -2159,7 +2160,7 @@
 %! assert (C{2}, [int32(1);int32(2);int32(3)]);
 %! assert (C{3}, [single(12.34);single(23.54);single(34.90)]);
 %! fseek (fid, 0, "bof");
-%! C = textscan (fid,'%s %*[^\n]');
+%! C = textscan (fid, '%s %*[^\n]');
 %! fclose (fid);
 %! unlink (f);
 %! assert (C, {{"09/12/2005";"10/12/2005";"11/12/2005"}});
@@ -2183,7 +2184,8 @@
 %! fprintf (fid,"// Comment Here\n");
 %! fprintf (fid,"def, na, 5, 6, 7\n");
 %! fseek (fid, 0, "bof");
-%! C = textscan (fid,"%s %n %n %n %n","Delimiter",",","TreatAsEmpty",{"NA","na"},"CommentStyle","//");
+%! C = textscan (fid, "%s %n %n %n %n", "Delimiter", ",",
+%!                    "TreatAsEmpty", {"NA","na"}, "CommentStyle", "//");
 %! fclose (fid);
 %! unlink (f);
 %! assert (C{1}, {"abc";"def"});
@@ -2192,21 +2194,22 @@
 %! assert (C{4}, [3; 6]);
 %! assert (C{5}, [4; 7]);
 
-%!test
-%!## Test start of comment as string
-%! c = textscan ("1 / 2 // 3", "%n %s %u8", "CommentStyle", {"//"});
-%! assert (c, {1, "/", 2});
+## FIXME: Almost passes.  Second return value is {"/"}.  Tested 4/14/16.
+### Test start of comment as string
+#%!test
+#%! c = textscan ("1 / 2 // 3", "%n %s %u8", "CommentStyle", {"//"});
+#%! assert (c(1), {1, "/", 2});
 
 %!assert (textscan (["1 2 3 4"; "5 6 7 8"], "%f"), {[15; 26; 37; 48]})
 
-%% Check for delimiter after exponent
+## Check for delimiter after exponent
 %!assert (textscan ("1e-3|42", "%f", "delimiter", "|"), {[1e-3; 42]})
 */
 
 // These tests have end-comment sequences, so can't just be in a comment
 #if 0
+## Test unfinished comment
 %!test
-%!## Test unfinished comment
 %! c = textscan ("1 2 /* half comment", "%n %u8", "CommentStyle", {"/*", "*/"});
 %! assert (c, {1, 2});
 
@@ -2226,6 +2229,18 @@
 %! assert (E);
 #endif
 
+/*
+## Test input validation
+%!error textscan ()
+%!error textscan (single (40))
+%!error textscan ({40})
+%!error <must be a string> textscan ("Hello World", 2)
+%!error <at most one character or>
+%! textscan ("Hello World", "%s", "EndOfLine", 3);
+%!error <'%z' is not a valid format specifier> textscan ("1.0", "%z")
+%!error <no valid format conversion specifiers> textscan ("1.0", "foo")
+*/
+
 static octave_value
 do_fread (octave_stream& os, const octave_value& size_arg,
           const octave_value& prec_arg, const octave_value& skip_arg,