function test_suite=test_surface_io()
% tests for surface input/output
%
% # 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_surface_dataset_gifti()
if cosmo_skip_test_if_no_external('gifti')
return;
end
save_and_load('gii');
function test_surface_dataset_niml_dset()
if cosmo_skip_test_if_no_external('afni')
return;
end
save_and_load('niml_dset');
function test_surface_dataset_bv_smp()
if cosmo_skip_test_if_no_external('neuroelf')
return;
end
save_and_load('bv_smp');
function test_surface_dataset_pymvpa()
save_and_load('pymvpa');
function test_surface_io_exceptions()
aet_in=@(varargin)assertExceptionThrown(@()...
cosmo_surface_dataset(varargin{:}),'');
aet_out=@(varargin)assertExceptionThrown(@()...
cosmo_map2surface(varargin{:}),'');
tmp_fn=cosmo_make_temp_filename();
aet_in(tmp_fn);
aet_in(struct());
aet_in({});
ds=cosmo_synthetic_dataset('type','surface');
aet_out(struct,'-bv_smp');
aet_out(struct,'-gii');
aet_out(struct,'-niml_dset');
aet_out(ds,tmp_fn);
aet_out(ds,'-foo');
aet_out(ds,struct());
aet_out(ds,{});
function test_pymvpa_3d_string_array()
py_ds=struct();
py_ds.samples=rand(3,4);
py_ds.fa.node_indices=[0,3,4,6];
sa_labels={'foo';'bar';'foobaz'};
sa_labels_3d=reshape(strvcat(sa_labels),[3 1 6]);
py_ds.sa.labels=sa_labels_3d;
ds=cosmo_surface_dataset(py_ds);
assertEqual(ds.sa.labels,sa_labels);
function props=format2props(format)
f2p=struct();
f2p.gii.ext='.gii';
f2p.gii.writer=@(fn,x)save(x,fn);
f2p.gii.reader=@(fn)gifti(fn);
f2p.gii.cleaner=@do_nothing;
f2p.gii.isa=@(x)isa(x,'gifti');
f2p.bv_smp.ext='.smp';
f2p.bv_smp.writer=@(fn,x)x.SaveAs(fn);
f2p.bv_smp.reader=@read_bv_and_bless;
f2p.bv_smp.cleaner=@(x)x.ClearObject();
f2p.bv_smp.isa=@(x)isa(x,'xff');
f2p.niml_dset.ext='.niml.dset';
f2p.niml_dset.writer=@(fn,x)afni_niml_writesimple(x,fn);
f2p.niml_dset.reader=@(fn)afni_niml_readsimple(fn);
f2p.niml_dset.cleaner=@do_nothing;
f2p.niml_dset.isa=@(x)isstruct(x) && isfield(x,'node_indices');
f2p.pymvpa.ext='.mat';
f2p.pymvpa.writer=@write_mat_struct;
f2p.pymvpa.reader=@import_struct_data_with_error_if_illegal;
f2p.pymvpa.cleaner=@do_nothing;
f2p.pymvpa.map2surface=@(x,fn)write_mat_struct(fn,...
cosmo_map2surface(x,'','format','pymvpa'));
f2p.pymvpa.isa=@(x)isstruct(x) && ...
cosmo_isfield(x,{'samples'}) && ...
~cosmo_isfield(x,'a.fdim');
props=f2p.(format);
function x=read_bv_and_bless(fn)
x=xff(fn);
neuroelf_bless_wrapper(x);
function x=do_nothing(x)
% do nothing
function result=neuroelf_bless_wrapper(arg)
% deals with recent neuroelf (>v1.1), where bless is deprecated
s=warning('off','neuroelf:xff:deprecated');
resetter=onCleanup(@()warning(s));
result=bless(arg);
function write_mat_struct(fn,s)
save(fn,'-struct','s');
function s=import_struct_data_with_error_if_illegal(fn)
try
s=load(fn);
catch
error('Unable to read %s',fn);
end
function save_and_load(format)
ds=cosmo_synthetic_dataset('type','surface','nchunks',1);
nfeatures=size(ds.samples,2);
ds.fa.node_indices=ds.fa.node_indices(nonid_randperm(nfeatures));
if strcmp(format,'bv_smp')
xff_count_orig=helper_count_xff_objects();
% ensure count of objects does not increase
else
xff_count_orig=NaN;
% also permute node indices
ds.a.fdim.values{1}=ds.a.fdim.values{1}(nonid_randperm(nfeatures));
end
ds.sa=struct();
ds.sa.stats={'Ftest(3,4)';'Zscore()'};
ds.sa.labels={'label1';'label2'};
props=format2props(format);
ext=props.ext;
tmp_fn2=cosmo_make_temp_filename('_tmp',ext);
tmp_file_cleaner=onCleanup(@()delete(tmp_fn2));
if isfield(props,'map2surface')
mapper=props.map2surface;
else
mapper=@cosmo_map2surface;
end
helper_assert_memory_use_equal(format,xff_count_orig);
mapper(ds,tmp_fn2);
helper_assert_memory_use_equal(format,xff_count_orig);
ds2=cosmo_surface_dataset(tmp_fn2);
helper_assert_memory_use_equal(format,xff_count_orig);
assert_dataset_equal(ds,ds2,format);
if strcmp(format,'bv_smp')
ds2.a.fdim.values{1}=ds.a.fdim.values{1}(...
nonid_randperm(nfeatures));
assertExceptionThrown(@()cosmo_map2surface(ds2,tmp_fn2),'');
helper_assert_memory_use_equal(format,xff_count_orig);
end
o=cosmo_map2surface(ds,['-' format]);
writer=props.writer;
reader=props.reader;
cleaner=props.cleaner;
writer(tmp_fn2,o);
cleaner(o);
helper_assert_memory_use_equal(format,xff_count_orig);
o2=reader(tmp_fn2);
ds3=cosmo_surface_dataset(o2);
assert_dataset_equal(ds,ds3,format);
% extra format-specific tests
switch format
case 'gii'
o3=gifti(struct('cdata',o2.cdata));
ds4=cosmo_surface_dataset(o3);
ds3.a.fdim.values{1}=1:nfeatures;
assert_dataset_equal(ds3,ds4,format);
case 'niml'
o2=rmfield(o2,'node_indices');
ds4=cosmo_surface_dataset(o2);
ds3.a.fdim.values{1}=1:nfeatures;
assert_dataset_equal(ds3,ds4,format);
end
% clean up intermediate objects
cleaner(o2);
helper_assert_memory_use_equal(format,xff_count_orig);
% use format explicitly
o4=cosmo_map2surface(ds,'','format',format);
assert_isa_func=props.isa;
assert_isa_func(o4);
ds4=cosmo_surface_dataset(o4);
assert_dataset_equal(ds,ds4,format);
cleaner(o4);
% test with dataset attributes
targets=[3 4];
chunks=5;
ds4=cosmo_surface_dataset(ds,'targets',targets,'chunks',chunks);
ds4_expected=ds;
ds4_expected.sa.chunks=[chunks; chunks];
ds4_expected.sa.targets=targets(:);
assertEqual(ds4,ds4_expected);
% make illegal dataset
fid=fopen(tmp_fn2,'w');
fprintf(fid,'foo');
fclose(fid);
switch format
case 'bv_smp'
exception_io_failed='xff:XFFioFailed';
% neuroelf v<1.1 did not have the 'neuroelf:' prefix
exception_bad_content={'xff:BadFileContent',...
'neuroelf:xff:badFileContent'};
otherwise
exception_io_failed='';
exception_bad_content='';
end
% file should not be readable
assertExceptionThrown(@()reader(tmp_fn2),...
exception_io_failed);
% file should not exist
tmp_fn2=cosmo_make_temp_filename();
assert_helper_any_exception_thrown(@()reader(tmp_fn2),...
exception_bad_content);
helper_assert_memory_use_equal(format,xff_count_orig);
function helper_assert_memory_use_equal(format,xff_count_orig)
if strcmp(format,'bv_smp')
xff_count_final=helper_count_xff_objects();
delta=xff_count_final-xff_count_orig;
assert(delta==0,sprintf('count increased by %d',delta));
end
function rp=nonid_randperm(n)
assert(n>1);
while true
rp=randperm(n);
if ~isequal(rp,1:n)
return;
end
end
function assert_dataset_equal(x,y,format)
mp=cosmo_align(y.fa.node_indices,x.fa.node_indices);
mp2=cosmo_align(y.a.fdim.values{1},x.a.fdim.values{1});
z=cosmo_slice(y,mp(mp2),2);
z.a.fdim.values{1}=z.a.fdim.values{1}(mp2);
assertEqual(x.a,z.a);
assertEqual(x.fa,z.fa);
assertElementsAlmostEqual(x.samples,z.samples,'absolute',1e-4);
if ~strcmp(format,'gii')
assertEqual(x.sa,z.sa);
end
function assert_helper_any_exception_thrown(f, exception)
if ischar(exception)
assertExceptionThrown(f,exception);
return
end
assert(iscell(exception))
try
f();
error('no exception thrown');
catch
e=lasterror();
i=strmatch(e.identifier,exception,'exact');
if isempty(i)
error('None of the following exceptions was thrown: %s',...
cosmo_strjoin(exception,', '));
end
end
function count=helper_count_xff_objects
if cosmo_skip_test_if_no_external('!evalc')
return;
end
xff_str=evalc('xff()');
lines=cosmo_strsplit(xff_str,'\n');
pre_idx=strmatch(' # | Type | ',lines);
line_idxs=strmatch('------------------',lines);
if isempty(pre_idx)
% Neuroelf < v1.1, no objects
assert(isempty(line_idxs));
count=0;
return;
end
post_idx=line_idxs(line_idxs>(pre_idx+2));
assert(numel(pre_idx)==1);
if numel(post_idx)==0
count=0;
return;
end
assert(numel(post_idx)==1);
offset=2;
count=post_idx-pre_idx-offset;
