function test_suite = test_slice
% tests for cosmo_slice
%
% #   For CoSMoMVPA's copyright information and license terms,   #
% #   see the COPYING file distributed with CoSMoMVPA.           #
    try % assignment of 'localfunctions' is necessary in Matlab >= 2016
        test_functions=localfunctions();
    catch % no problem; early Matlab versions can use initTestSuite fine
    end
    initTestSuite;


function test_slice_arrays
    if cosmo_wtf('is_matlab')
        err_id_invalid_index='MATLAB:badsubscript';
        err_id_out_of_bounds='MATLAB:badsubscript';
    else
        err_id_invalid_index='Octave:invalid-index';
        err_id_out_of_bounds='Octave:index-out-of-bounds';
    end

    % helper functions
    b=@(x)logical(x); % conversion to boolean

    % assert-equal
    aeq=@(args,v) assertEqual(cosmo_slice(args{:}),v);

    % assert-raises with id
    aet_with=@(args,id) assertExceptionThrown(@()cosmo_slice(args{:}),...
                                            id);
    % assert-raises with empty exception
    aet=@(args) aet_with(args,'');

    % support boolean arrays
    xs={[0,1,2;3,4,5],{'a','b','c';'d','ee',''},b([0 1 1; 0 1 0])};
    for k=1:numel(xs)
        x=xs{k};

        aeq({x,1},x(1,:))
        aeq({x,2},x(2,:))
        aeq({x,[1 2]},x)
        aeq({x,[2 1]},x([2 1],:))
        aeq({x,[2 2 1]},x([2 2 1],:))
        aeq({x,[2 2 1]'},x([2 2 1],:))

        aeq({x,1,1},x(1,:))
        aeq({x,2,1},x(2,:))
        aeq({x,[1 2],1},x)
        aeq({x,[2 1],1},x([2 1],:))
        aeq({x,[2 2 1],1},x([2 2 1],:))
        aeq({x,[2 2 1]',1},x([2 2 1],:))

        aeq({x,1,2},x(:,1))
        aeq({x,2,2},x(:,2))
        aeq({x,3,2},x(:,3))
        aeq({x,[1 3],2},x(:,[1 3]))
        aeq({x,[3 1],2},x(:,[3 1]))
        aeq({x,[3 1 1],2},x(:,[3 1 1]))
        aeq({x,[3 1 1]',2},x(:,[3 1 1]))


        % boolean slicing
        aeq({x,b([0 1]),1},x(b([0 1]),:))
        aeq({x,b([0 1 0]),2},x(:,b([0 1 0])))

        aet({x,b([0]),1})
        aet({x,b([0 1]),2})
        aet({x,b([0 1 0]),1})
        aet({x,b([0 1 0 0]),2})

        % indices out of bounds
        aet_with({x,0},err_id_invalid_index)
        aet_with({x,3},err_id_out_of_bounds)
        aet_with({x,0,1},err_id_invalid_index)
        aet_with({x,3,1},err_id_out_of_bounds)
        aet_with({x,0,2},err_id_invalid_index)
        aet_with({x,4,2},err_id_out_of_bounds)

        % no support for 3D arrays
        x=repmat(x,[1 1 2]);
        aet({x,1})
        aet({x,1})
        aet({x,1,1})
        aet({x,1,1})
        aet({x,1,2})
        aet({x,1,2})

    end

function test_slice_datasets()
    % (assumes that slicing of arrays works properly)


    if cosmo_wtf('is_matlab')
        err_id_out_of_bounds='MATLAB:badsubscript';
    else
        err_id_out_of_bounds='Octave:index-out-of-bounds';
    end

    ds=cosmo_synthetic_dataset('size','normal');

    % index- and mask-based slicing
    rand_=@(n)rand(n,1);
    ridx=@(n) ceil(rand_(n*2)*n);
    bmsk=@(n) rand_(n)>.5;

    % helper function
    aet=@(a,b,exc)assertExceptionThrown(@()cosmo_slice(ds,a,b),exc);

    % f generates the indices or boolean values
    % dim is the dimension
    % oob means whether to generate thinks going out of bounds
    param2slice_arg=@(f,dim,oob)f(size(ds.samples,dim)*(1+oob));

    params=cosmo_cartprod({{ridx,bmsk},{1,2},{true,false}});

    attr_labels={'sa','fa'};
    for k=1:size(params,1)
        param=params(k,:);
        slice_arg=param2slice_arg(param{:});
        slice_dim=param{2};
        oob=param{3};

        % slice ds
        if oob
            if isnumeric(slice_arg)
                exc=err_id_out_of_bounds;
            else
                exc='';
            end
            aet(slice_arg, slice_dim, exc);
            continue;
        end

        d=cosmo_slice(ds,slice_arg,slice_dim);

        % samples should match
        assertEqual(d.samples,cosmo_slice(ds.samples,slice_arg,slice_dim));

        % dataset attribues should match
        assertEqual(d.a, ds.a);

        % test .sa and .fa
        for dim=1:numel(attr_labels);
            attr_label=attr_labels{dim};
            assertEqual(fieldnames(d.(attr_label)), ...
                            fieldnames(ds.(attr_label)));

            labels=fieldnames(ds.(attr_label));
            for m=1:numel(labels)
                label=labels{m};
                v=ds.(attr_label).(label);
                w=d.(attr_label).(label);

                if slice_dim==dim
                    % assumes slicing array works fine
                    v=cosmo_slice(v, slice_arg, slice_dim);
                end

                assertEqual(v,w);
            end

            % check slicing of structs
            if slice_dim==dim
                v=ds.(attr_label);
                w=d.(attr_label);
                assertEqual(cosmo_slice(v,slice_arg,dim,'struct'),w);
            end

        end
    end

function test_slice_sa
    helper_test_dataset_slice(1);

function test_slice_fa
    helper_test_dataset_slice(2);

function helper_test_dataset_slice(dim)
    % dataset_slice_{fa,sa} are deprecated, so shows a warning
    warning_state=cosmo_warning();
    warning_state_resetter=onCleanup(@()cosmo_warning(warning_state));
    empty_state=warning_state;
    empty_state.show_warnings={};

    ds=cosmo_synthetic_dataset();

    % select half of samples or features
    sz=size(ds);
    n=sz(dim);
    rp=randperm(n);
    rp=rp(1:round(n/2));

    % set selected result
    expected_result=cosmo_slice(ds,rp,dim);

    % set warning to empty
    cosmo_warning(empty_state);
    cosmo_warning('off');

    % slice dataset
    if dim==1
        result=cosmo_dataset_slice_sa(ds,rp);
    else
        result=cosmo_dataset_slice_fa(ds,rp);
    end

    % compare with expected result
    assertEqual(expected_result,result);

    % warning must have been shown
    w=cosmo_warning();
    assert(~isempty(w.shown_warnings));
    assert(iscellstr(w.shown_warnings));



function test_slice_datasets_exceptions
    aet=@(varargin)assertExceptionThrown(@()...
                    cosmo_slice(varargin{:}),'');

    % struct must have field .samples
    aet(struct,1);

    % cannot have function handle as first input
    aet(@abs,1);

    % slicing a struct with size mismatch gives an error
    ds=struct();
    ds.foo=[1 2];
    ds.bar=[1;2];
    aet(ds,1,1,'struct');
    aet(ds,1,2,'struct');

    % dim must be 1 or 2
    aet(zeros(2),1,3);
    aet(zeros(2),1,'foo');
    aet(zeros(2),1,[1 2]);
    aet(zeros(2),1,[1 1]);

    % selector must be a vector
    aet(zeros(2),ones(2),1);
    aet(zeros(2),ones(2),2);
