Mercurial > octave-dspies
view test/args.tst @ 19009:8d47ce2053f2 draft
Added safety checks to Array::xelem
There's no reason to have a method which never checks invariants, ever. Added
debugging checks to Array::xelem to help catch and debug out-of-bounds errors
and reference overlap
* configure.ac: Added configuration option for uniqueness-checking with xelem
* jit-typeinfo.cc (octave_jit_paren_scalar): Call const Array::xelem rather
than Array::xelem
* Array-util.h, Array-util.cc (check_out_of_range): Extract common pattern to
method
(check_index): Methods to check index is in-bounds
(compute_index): Added bool parameter check. does not check bounds when check
is false and BOUNDS_CHECKING is off
* Array.h, Array.cc (xelem): Use methods from Array-util.h to compute indices
(is_unique): Check if this is the only reference to data
* CmplxQR.cc, dbleQR.cc, fCmplxQR.cc, floatQR.cc
(form): Move second assignment to after the call to xelem
* lo-array-gripes.h, lo-array-gripes.cc (gripe_modifying_nonunique): Added
error message for when non-const xelem is called on non-unique array
author | David Spies <dnspies@gmail.com> |
---|---|
date | Mon, 14 Jul 2014 13:07:59 -0600 |
parents | d63878346099 |
children |
line wrap: on
line source
## Copyright (C) 2006-2013 John W. Eaton ## ## This file is part of Octave. ## ## Octave is free software; you can redistribute it and/or modify it ## under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or (at ## your option) any later version. ## ## Octave is distributed in the hope that it will be useful, but ## WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ## General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with Octave; see the file COPYING. If not, see ## <http://www.gnu.org/licenses/>. ######################################## ## No inputs or no outputs ## no input or output arguments %!function f () %! assert (nargin, 0); %! assert (nargout, 0); %!endfunction %!test %! f; ## one input with two possible inputs %!function f (x, y) %! assert (nargin, 1); %! assert (nargout, 0); %!endfunction %!test %! f (1); ## no inputs, one of multiple outputs %!function [x, y] = f () %! assert (nargin, 0); %! assert (nargout, 1); %! x = 2; %!endfunction %!test %! assert (f (), 2); ## one of multiple inputs, one of multiple outputs %!function [x, y] = f (a, b) %! assert (nargin, 1); %! assert (nargout, 1); %! x = a; %!endfunction %!test %! assert (f (1), 1); ######################################## ## Varargin, varargout ## varargin and varargout with no inputs or outputs %!function [varargout] = f (varargin) %! assert (nargin, 0); %! assert (nargout, 0); %!endfunction %!test %! f; ## varargin and varargout with one input %!function [varargout] = f (x, varargin) %! assert (nargin, 1); %! assert (nargout, 0); %!endfunction %!test %! f (1); ## varargin and varargout with one output %!function [x, varargout] = f (varargin) %! assert (nargin, 0); %! assert (nargout, 1); %! x = 2; %!endfunction %!test %! assert (f (), 2); ## varargin and varargout with one input and output %!function [varargout] = f (varargin) %! assert (nargin, 1); %! assert (nargout, 1); %! varargout{1} = varargin{1}; %!endfunction %!test %! assert (f (1), 1); ## multiple inputs, multiple outputs, but not all of either ## WARNING: The original test did not assign the outputs, it just ## requested them, and I think that is supposed to be an error. It also ## still has a non-assigned output argument. %!function [x, y, z] = f (a, b, c, d, e) %! assert (nargin, 4); %! assert (nargout, 2); %! x = a; %! y = b; %!endfunction %!test %! [s, t] = f (1, 2, 3, 4); %! assert ([s t], [1 2]); ## Fully used varargin and varargout %!function [varargout] = f (varargin) %! assert (nargin, 3); %! assert (nargout, 4); %! varargout{1} = varargin{1}; %! varargout{2} = varargin{2}; %! varargout{3} = varargin{3}; %! varargout{4} = 4; %!endfunction %!test %! [s, t, u, v] = f (1, 2, 3); %! assert ([s t u v], [1 2 3 4]); ## Test default arguments ## numeric %!function f (x = 0) %! assert (x, 0); %!endfunction %!test %! f() ## numeric vector (spaces) %!function f (x = [0 1 2]) %! assert (x, [0 1 2]); %!endfunction %!test %! f() ## numeric vector (range) %!function f (x = 1:3) %! assert (x, 1:3); %!endfunction %!test %! f() ## numeric vector (commas) %!function f (x = [0,1,2]) %! assert (x, [0 1 2]); %!endfunction %!test %! f() ## numeric vector (commas and spaces) %!function f (x = [0, 1, 2]) %! assert (x, [0 1 2]); %!endfunction %!test %! f() ## numeric matrix %!function f (x = [0, 1, 2;3, 4, 5]) %! assert (x, [0 1 2;3 4 5]); %!endfunction %!test %! f() ## empty cell %!function f (x = {}) %! assert (x, {}); %!endfunction %!test %! f() ## full cell %!function f (x = {1}) %! assert (x, {1}); %!endfunction %!test %! f() ## many cells %!function f (x = {1 'a' "b" 2.0 struct("a", 3)}) %! assert (x, {1 'a' "b" 2.0 struct("a", 3)}); %!endfunction %!test %! f() ## struct %!function f (x = struct("a", 3)) %! assert (x, struct ("a", 3)); %!endfunction %!test %! f() ## char (double quotes) %!function f (x = "a") %! assert (x, "a"); %!endfunction %!test %! f() ## char (single quotes) %!function f (x = 'a') %! assert (x, "a"); %!endfunction %!test %! f() ## char (string, double quotes) %!function f (x = "abc123") %! assert (x, "abc123"); %!endfunction %!test %! f() ## char (string, double quotes, punctuation) %!function f (x = "abc123`1234567890-=~!@#$%^&*()_+[]{}|;':\",./<>?\\") %! assert (x, "abc123`1234567890-=~!@#$%^&*()_+[]{}|;':\",./<>?\\"); %!endfunction %!test %! f() ## Function handle (builtin) %!function f (x = @sin) %! finfo = functions (x); %! fname = finfo.function; %! assert (isa (x, "function_handle") && strcmp (fname, "sin")); %!endfunction %!test %! f() ## Function handle (anonymous) %!function f (x = @(x) x.^2) %! finfo = functions (x); %! ftype = finfo.type; %! assert (isa (x, "function_handle") && strcmp (ftype, "anonymous")); %!endfunction %!test %! f()