Mercurial > octave-nkf

comparison src/strfns.cc @ 14429:eff4a5933e28

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Update %!tests in src/ directory with Octave coding conventions. * data.cc, defaults.cc, dirfns.cc, file-io.cc, graphics.cc, mappers.cc, oct-map.cc, octave.cc, ov-base.cc, ov-bool-mat.cc, ov-cell.cc, ov-fcn-handle.cc, ov-fcn-inline.cc, ov-flt-re-mat.cc, ov-int16.cc, ov-int32.cc, ov-int64.cc, ov-int8.cc, ov-null-mat.cc, ov-oncleanup.cc, ov-range.cc, ov-re-mat.cc, ov-struct.cc, ov-typeinfo.cc, ov-uint16.cc, ov-uint32.cc, ov-uint64.cc, ov-uint8.cc, ov.cc, pr-output.cc, pt-binop.cc, pt-eval.cc, pt-idx.cc, pt-mat.cc, sighandlers.cc, strfns.cc, symtab.cc, syscalls.cc, sysdep.cc, toplev.cc, utils.cc, variables.cc: Update %!tests in src/ directory with Octave coding conventions.
author Rik <octave@nomad.inbox5.com>
date Sun, 04 Mar 2012 12:21:10 -0800
parents 97883071e8e4
children afa5e1d20671
comparison
equal deleted inserted replaced
14428:099bd779466c 14429:eff4a5933e28
150 return retval; 150 return retval;
151 } 151 }
152 152
153 /* 153 /*
154 %!assert (char (), ''); 154 %!assert (char (), '');
155 %!assert (char (100) == "d"); 155 %!assert (char (100), "d");
156 %!assert (all(char (100,100) == ["d";"d"])); 156 %!assert (char (100,100), ["d";"d"])
157 %!assert (all(char ({100,100}) == ["d";"d"])); 157 %!assert (char ({100,100}), ["d";"d"])
158 %!assert (all(char ([100,100]) == ["dd"])); 158 %!assert (char ([100,100]), ["dd"])
159 %!assert (all(char ({100,{100}}) == ["d";"d"])); 159 %!assert (char ({100,{100}}), ["d";"d"])
160 %!assert (all(char (100, [], 100) == ["d";" ";"d"])) 160 %!assert (char (100, [], 100), ["d";" ";"d"])
161 %!assert (all(char ({100, [], 100}) == ["d";" ";"d"])) 161 %!assert (char ({100, [], 100}), ["d";" ";"d"])
162 %!assert (all(char ({100,{100, {""}}}) == ["d";"d";" "])) 162 %!assert (char ({100,{100, {""}}}), ["d";"d";" "])
163 %!assert (all(char (["a";"be"], {"c", 100}) == ["a";"be";"c";"d"])) 163 %!assert (char (["a";"be"], {"c", 100}), ["a";"be";"c";"d"])
164 %!assert(strcmp (char ("a", "bb", "ccc"), ["a "; "bb "; "ccc"])); 164 %!assert (char ("a", "bb", "ccc"), ["a "; "bb "; "ccc"])
165 %!assert(strcmp (char ([65, 83, 67, 73, 73]), "ASCII")); 165 %!assert (char ([65, 83, 67, 73, 73]), "ASCII")
166 166
167 %!test 167 %!test
168 %! x = char ("foo", "bar", "foobar"); 168 %! x = char ("foo", "bar", "foobar");
169 %! assert((strcmp (x(1,:), "foo ") 169 %! assert (x(1,:), "foo ");
170 %! && strcmp (x(2,:), "bar ") 170 %! assert (x(2,:), "bar ");
171 %! && strcmp (x(3,:), "foobar"))); 171 %! assert (x(3,:), "foobar");
172 */ 172 */
173 173
174 DEFUN (strvcat, args, , 174 DEFUN (strvcat, args, ,
175 "-*- texinfo -*-\n\ 175 "-*- texinfo -*-\n\
176 @deftypefn {Built-in Function} {} strvcat (@var{x})\n\ 176 @deftypefn {Built-in Function} {} strvcat (@var{x})\n\
284 284
285 return retval; 285 return retval;
286 } 286 }
287 287
288 /* 288 /*
289 %!error <Invalid call to strvcat> strvcat()
290 %!assert (strvcat (""), ""); 289 %!assert (strvcat (""), "");
291 %!assert (strvcat (100) == "d"); 290 %!assert (strvcat (100) == "d");
292 %!assert (all(strvcat (100,100) == ["d";"d"])); 291 %!assert (strvcat (100,100), ["d";"d"])
293 %!assert (all(strvcat ({100,100}) == ["d";"d"])); 292 %!assert (strvcat ({100,100}), ["d";"d"])
294 %!assert (all(strvcat ([100,100]) == ["dd"])); 293 %!assert (strvcat ([100,100]), ["dd"])
295 %!assert (all(strvcat ({100,{100}}) == ["d";"d"])); 294 %!assert (strvcat ({100,{100}}), ["d";"d"])
296 %!assert (all(strvcat (100, [], 100) == ["d";"d"])) 295 %!assert (strvcat (100, [], 100), ["d";"d"])
297 %!assert (all(strvcat ({100, [], 100}) == ["d";"d"])) 296 %!assert (strvcat ({100, [], 100}), ["d";"d"])
298 %!assert (all(strvcat ({100,{100, {""}}}) == ["d";"d"])) 297 %!assert (strvcat ({100,{100, {""}}}), ["d";"d"])
299 %!assert (all(strvcat (["a";"be"], {"c", 100}) == ["a";"be";"c";"d"])) 298 %!assert (strvcat (["a";"be"], {"c", 100}), ["a";"be";"c";"d"])
300 %!assert(strcmp (strvcat ("a", "bb", "ccc"), ["a "; "bb "; "ccc"])); 299 %!assert (strvcat ("a", "bb", "ccc"), ["a "; "bb "; "ccc"])
300
301 %!error strvcat ()
301 */ 302 */
302 303
303 304
304 DEFUN (ischar, args, , 305 DEFUN (ischar, args, ,
305 "-*- texinfo -*-\n\ 306 "-*- texinfo -*-\n\
319 320
320 return retval; 321 return retval;
321 } 322 }
322 323
323 /* 324 /*
324 %!assert (ischar ("a"), logical (1)); 325 %!assert (ischar ("a"), true)
325 %!assert (ischar (["ab";"cd"]), logical (1)); 326 %!assert (ischar (["ab";"cd"]), true)
326 %!assert (ischar ({"ab"}), logical (0)); 327 %!assert (ischar ({"ab"}), false)
327 %!assert (ischar (1), logical (0)); 328 %!assert (ischar (1), false)
328 %!assert(ischar ([1, 2]), logical (0)); 329 %!assert (ischar ([1, 2]), false)
329 %!assert(ischar ([]), logical (0)); 330 %!assert (ischar ([]), false)
330 %!assert(ischar ([1, 2; 3, 4]), logical (0)); 331 %!assert (ischar ([1, 2; 3, 4]), false)
331 %!assert(ischar (""), logical (1)); 332 %!assert (ischar (""), true)
332 %!assert(ischar ("test"), logical (1)); 333 %!assert (ischar ("test"), true)
333 %!assert(ischar (["test"; "ing"]), logical (1)); 334 %!assert (ischar (["test"; "ing"]), true)
334 %!assert(ischar (struct ("foo", "bar")), logical (0)); 335 %!assert (ischar (struct ("foo", "bar")), false)
335 %!error <Invalid call to ischar> ischar (); 336
336 %!error <Invalid call to ischar> ischar ("test", 1); 337 %!error ischar ()
338 %!error ischar ("test", 1)
337 */ 339 */
338 340
339 static octave_value 341 static octave_value
340 do_strcmp_fun (const octave_value& arg0, const octave_value& arg1, 342 do_strcmp_fun (const octave_value& arg0, const octave_value& arg1,
341 octave_idx_type n, const char *fcn_name, 343 octave_idx_type n, const char *fcn_name,
587 589
588 return retval; 590 return retval;
589 } 591 }
590 592
591 /* 593 /*
592 %!error <Invalid call to strcmp> strcmp ();
593 %!error <Invalid call to strcmp> strcmp ("foo", "bar", 3);
594 %!
595 %!shared x 594 %!shared x
596 %! x = char (zeros (0, 2)); 595 %! x = char (zeros (0, 2));
597 %!assert (strcmp ('', x) == false); 596 %!assert (strcmp ("", x), false)
598 %!assert (strcmp (x, '') == false); 597 %!assert (strcmp (x, ""), false)
599 %!assert (strcmp (x, x) == true); 598 %!assert (strcmp (x, x), true)
600 ## %!assert (strcmp ({''}, x) == true); 599 ## %!assert (strcmp ({""}, x), true)
601 ## %!assert (strcmp ({x}, '') == false); 600 ## %!assert (strcmp ({x}, ""), false)
602 ## %!assert (strcmp ({x}, x) == true); 601 ## %!assert (strcmp ({x}, x), true)
603 ## %!assert (strcmp ('', {x}) == false); 602 ## %!assert (strcmp ("", {x}), false)
604 ## %!assert (strcmp (x, {''}) == false); 603 ## %!assert (strcmp (x, {""}), false)
605 ## %!assert (strcmp (x, {x}) == true); 604 ## %!assert (strcmp (x, {x}), true)
606 ## %!assert (all (strcmp ({x; x}, '') == [false; false])); 605 ## %!assert (strcmp ({x; x}, ""), [false; false])
607 ## %!assert (all (strcmp ({x; x}, {''}) == [false; false])); 606 ## %!assert (strcmp ({x; x}, {""}), [false; false])
608 ## %!assert (all (strcmp ('', {x; x}) == [false; false])); 607 ## %!assert (strcmp ("", {x; x}), [false; false])
609 ## %!assert (all (strcmp ({''}, {x; x}) == [false; false])); 608 ## %!assert (strcmp ({""}, {x; x}), [false; false])
610 %!assert (strcmp ({'foo'}, x) == false); 609 %!assert (strcmp ({"foo"}, x), false)
611 %!assert (strcmp ({'foo'}, 'foo') == true); 610 %!assert (strcmp ({"foo"}, "foo"), true)
612 %!assert (strcmp ({'foo'}, x) == false); 611 %!assert (strcmp ({"foo"}, x), false)
613 %!assert (strcmp (x, {'foo'}) == false); 612 %!assert (strcmp (x, {"foo"}), false)
614 %!assert (strcmp ('foo', {'foo'}) == true); 613 %!assert (strcmp ("foo", {"foo"}), true)
615 %!assert (strcmp (x, {'foo'}) == false); 614 %!assert (strcmp (x, {"foo"}), false)
616 %!shared y 615 %!shared y
617 %! y = char (zeros (2, 0)); 616 %! y = char (zeros (2, 0));
618 %!assert (strcmp ('', y) == false); 617 %!assert (strcmp ("", y), false)
619 %!assert (strcmp (y, '') == false); 618 %!assert (strcmp (y, ""), false)
620 %!assert (strcmp (y, y) == true); 619 %!assert (strcmp (y, y), true)
621 %!assert (all (strcmp ({''}, y) == [true; true])); 620 %!assert (strcmp ({""}, y), [true; true])
622 %!assert (strcmp ({y}, '') == true); 621 %!assert (strcmp ({y}, ""), true)
623 %!assert (all (strcmp ({y}, y) == [true; true])); 622 %!assert (strcmp ({y}, y), [true; true])
624 %!assert (all (strcmp ('', {y}) == [true; true])); 623 %!assert (strcmp ("", {y}), true)
625 %!assert (all (strcmp (y, {''}) == [true; true])); 624 %!assert (strcmp (y, {""}), [true; true])
626 %!assert (all (strcmp (y, {y}) == [true; true])); 625 %!assert (strcmp (y, {y}), [true; true])
627 %!assert (all (strcmp ({y; y}, '') == [true; true])); 626 %!assert (strcmp ({y; y}, ""), [true; true])
628 %!assert (all (strcmp ({y; y}, {''}) == [true; true])); 627 %!assert (strcmp ({y; y}, {""}), [true; true])
629 %!assert (all (strcmp ('', {y; y}) == [true; true])); 628 %!assert (strcmp ("", {y; y}), [true; true])
630 %!assert (all (strcmp ({''}, {y; y}) == [true; true])); 629 %!assert (strcmp ({""}, {y; y}), [true; true])
631 %!assert (all (strcmp ({'foo'}, y) == [false; false])); 630 %!assert (strcmp ({"foo"}, y), [false; false])
632 %!assert (all (strcmp ({'foo'}, y) == [false; false])); 631 %!assert (strcmp ({"foo"}, y), [false; false])
633 %!assert (all (strcmp (y, {'foo'}) == [false; false])); 632 %!assert (strcmp (y, {"foo"}), [false; false])
634 %!assert (all (strcmp (y, {'foo'}) == [false; false])); 633 %!assert (strcmp (y, {"foo"}), [false; false])
635 %!assert (strcmp ("foobar", "foobar"), true); 634 %!assert (strcmp ("foobar", "foobar"), true)
636 %!assert (strcmp ("fooba", "foobar"), false); 635 %!assert (strcmp ("fooba", "foobar"), false)
636
637 %!error strcmp ()
638 %!error strcmp ("foo", "bar", 3)
637 */ 639 */
638 640
639 // Apparently, Matlab ignores the dims with strncmp. It also 641 // Apparently, Matlab ignores the dims with strncmp. It also
640 static bool 642 static bool
641 strncmp_array_op (const charNDArray& s1, const charNDArray& s2, octave_idx_type n) 643 strncmp_array_op (const charNDArray& s1, const charNDArray& s2, octave_idx_type n)
710 712
711 return retval; 713 return retval;
712 } 714 }
713 715
714 /* 716 /*
715 %!error <Invalid call to strncmp> strncmp (); 717 %!assert (strncmp ("abce", "abc", 3), true)
716 %!error <Invalid call to strncmp> strncmp ("abc", "def"); 718 %!assert (strncmp (100, 100, 1), false)
717 %!assert (strncmp ("abce", "abc", 3) == 1) 719 %!assert (strncmp ("abce", {"abcd", "bca", "abc"}, 3), logical ([1, 0, 1]))
718 %!assert (strncmp (100, 100, 1) == 0) 720 %!assert (strncmp ("abc", {"abcd", "bca", "abc"}, 4), logical ([0, 0, 0]))
719 %!assert (all (strncmp ("abce", {"abcd", "bca", "abc"}, 3) == [1, 0, 1])) 721 %!assert (strncmp ({"abcd", "bca", "abc"},"abce", 3), logical ([1, 0, 1]))
720 %!assert (all (strncmp ("abc", {"abcd", "bca", "abc"}, 4) == [0, 0, 0])) 722 %!assert (strncmp ({"abcd", "bca", "abc"},{"abcd", "bca", "abe"}, 3), logical ([1, 1, 0]))
721 %!assert (all (strncmp ({"abcd", "bca", "abc"},"abce", 3) == [1, 0, 1])) 723 %!assert (strncmp ("abc", {"abcd", 10}, 2), logical ([1, 0]))
722 %!assert (all (strncmp ({"abcd", "bca", "abc"},{"abcd", "bca", "abe"}, 3) == [1, 1, 0])) 724
723 %!assert (all (strncmp("abc", {"abcd", 10}, 2) == [1, 0])) 725 %!error strncmp ()
726 %!error strncmp ("abc", "def")
724 */ 727 */
725 728
726 // case-insensitive character equality functor 729 // case-insensitive character equality functor
727 struct icmp_char_eq : public std::binary_function<char, char, bool> 730 struct icmp_char_eq : public std::binary_function<char, char, bool>
728 { 731 {
781 784
782 return retval; 785 return retval;
783 } 786 }
784 787
785 /* 788 /*
786 %!assert (strcmpi("abc123", "ABC123"), logical(1)); 789 %!assert (strcmpi ("abc123", "ABC123"), true)
787 */ 790 */
788 791
789 // Like strncmp. 792 // Like strncmp.
790 static bool 793 static bool
791 strncmpi_array_op (const charNDArray& s1, const charNDArray& s2, octave_idx_type n) 794 strncmpi_array_op (const charNDArray& s1, const charNDArray& s2, octave_idx_type n)
848 851
849 return retval; 852 return retval;
850 } 853 }
851 854
852 /* 855 /*
853 %!assert (strncmpi("abc123", "ABC456", 3), logical(1)); 856 %!assert (strncmpi ("abc123", "ABC456", 3), true)
854 */ 857 */
855 858
856 DEFUN (list_in_columns, args, , 859 DEFUN (list_in_columns, args, ,
857 "-*- texinfo -*-\n\ 860 "-*- texinfo -*-\n\
858 @deftypefn {Built-in Function} {} list_in_columns (@var{arg}, @var{width})\n\ 861 @deftypefn {Built-in Function} {} list_in_columns (@var{arg}, @var{width})\n\
921 924
922 return retval; 925 return retval;
923 } 926 }
924 927
925 /* 928 /*
926 %!error <Invalid call to list_in_columns> list_in_columns ();
927 %!error <Invalid call to list_in_columns> list_in_columns (["abc", "def"], 20, 2);
928 %!error <invalid conversion from string to real scalar> list_in_columns (["abc", "def"], "a");
929 %!test 929 %!test
930 %! input = {"abc", "def", "ghijkl", "mnop", "qrs", "tuv"}; 930 %! input = {"abc", "def", "ghijkl", "mnop", "qrs", "tuv"};
931 %! result = "abc mnop\ndef qrs\nghijkl tuv\n"; 931 %! result = "abc mnop\ndef qrs\nghijkl tuv\n";
932 %! assert (list_in_columns (input, 20) == result); 932 %! assert (list_in_columns (input, 20), result);
933 %!test 933 %!test
934 %! input = ["abc"; "def"; "ghijkl"; "mnop"; "qrs"; "tuv"]; 934 %! input = ["abc"; "def"; "ghijkl"; "mnop"; "qrs"; "tuv"];
935 %! result = "abc mnop \ndef qrs \nghijkl tuv \n"; 935 %! result = "abc mnop \ndef qrs \nghijkl tuv \n";
936 %! assert (list_in_columns (input, 20) == result); 936 %! assert (list_in_columns (input, 20), result);
937
938 %!error list_in_columns ()
939 %!error list_in_columns (["abc", "def"], 20, 2)
940 %!error <invalid conversion from string to real scalar> list_in_columns (["abc", "def"], "a")
937 */ 941 */