1function gbtest43
2%GBTEST43 test error handling
3% All errors generated by this test are expected.
4
5% SuiteSparse:GraphBLAS, Timothy A. Davis, (c) 2017-2021, All Rights Reserved.
6% SPDX-License-Identifier: GPL-3.0-or-later
7
8rng ('default') ;
9ok = true ;
10G = GrB (magic (5)) ;
11
12try
13    x = prod (G, 'gunk') ; %#ok<*NASGU>
14    ok = false %#ok<*NOPRT>
15catch expected_error
16    expected_error
17    disp (expected_error.stack (end-1))
18end
19assert (ok) ;
20
21try
22    x = min (G, [ ], 'gunk') ;
23    ok = false ;
24catch expected_error
25    expected_error
26    disp (expected_error.stack (end-1))
27end
28assert (ok) ;
29
30try
31    x = max (G, [ ], 'gunk') ;
32    ok = false ;
33catch expected_error
34    expected_error
35    disp (expected_error.stack (end-1))
36end
37assert (ok) ;
38
39try
40    x = min (G, [ ], 1, G) ;
41    ok = false ;
42catch expected_error
43    expected_error
44end
45assert (ok) ;
46
47try
48    x = max (G, [ ], 1, G) ;
49    ok = false ;
50catch expected_error
51    expected_error
52end
53assert (ok) ;
54
55try
56    x = sum (G, 'gunk') ;
57    ok = false ;
58catch expected_error
59    expected_error
60    disp (expected_error.stack (end-1))
61end
62assert (ok) ;
63
64try
65    x = all (G, 'gunk') ;
66    ok = false ;
67catch expected_error
68    expected_error
69    disp (expected_error.stack (end-1))
70end
71assert (ok) ;
72
73try
74    x = any (G, 'gunk') ;
75    ok = false ;
76catch expected_error
77    expected_error
78    disp (expected_error.stack (end-1))
79end
80assert (ok) ;
81
82try
83    [x, y] = bandwidth (G, 'lower') ; %#ok<*ASGLU>
84    ok = false ;
85catch expected_error
86    expected_error
87    disp (expected_error.stack (end-1))
88end
89assert (ok) ;
90
91try
92    x = bandwidth (G, 'gunk') ;
93    ok = false ;
94catch expected_error
95    expected_error
96    disp (expected_error.stack (end-1))
97end
98assert (ok) ;
99
100try
101    x = GrB.eye (1, 2, 3) ;
102    ok = false ;
103catch expected_error
104    expected_error
105    disp (expected_error.stack (end-1))
106end
107assert (ok) ;
108
109try
110    x = GrB.eye ([1, 2, 3]) ;
111    ok = false ;
112catch expected_error
113    expected_error
114    disp (expected_error.stack (end-1))
115end
116assert (ok) ;
117
118try
119    G.stuff = 3 ;
120    ok = false ;
121catch expected_error
122    expected_error
123    disp (expected_error.stack (end-1))
124end
125assert (ok) ;
126
127try
128    G (2,1,1) = 3 ;
129    ok = false ;
130catch expected_error
131    expected_error
132    disp (expected_error.stack (end-1))
133end
134assert (ok) ;
135
136H = GrB (rand (4,3)) ;
137try
138    C = H^H ;
139    ok = false ;
140catch expected_error
141    expected_error
142    disp (expected_error.stack (end-1))
143end
144assert (ok) ;
145
146try
147    C = G^H ;
148    ok = false ;
149catch expected_error
150    expected_error
151    disp (expected_error.stack (end-1))
152end
153assert (ok) ;
154
155try
156    C = G^(-1) ;
157    ok = false ;
158catch expected_error
159    expected_error
160    disp (expected_error.stack (end-1))
161end
162assert (ok) ;
163
164try
165    C = G(1,2).stuff(3,4) ;
166    ok = false ;
167catch expected_error
168    expected_error
169    disp (expected_error.stack (end-1))
170end
171assert (ok) ;
172
173try
174    C = G.stuff ;
175    ok = false ;
176catch expected_error
177    expected_error
178    disp (expected_error.stack (end-1))
179end
180assert (ok) ;
181
182try
183    C = G (3:4) ;
184    ok = false ;
185catch expected_error
186    expected_error
187    disp (expected_error.stack (end-1))
188end
189assert (ok) ;
190
191try
192    C = G (1,2,2) ;
193    ok = false ;
194catch expected_error
195    expected_error
196    disp (expected_error.stack (end-1))
197end
198assert (ok) ;
199
200try
201    C = spones (G, 'gunk') ;
202    ok = false ;
203catch expected_error
204    expected_error
205    disp (expected_error.stack (end-1))
206end
207assert (ok) ;
208
209try
210    C = spones (G, G) ;
211    ok = false ;
212catch expected_error
213    expected_error
214    disp (expected_error.stack (end-1))
215end
216assert (ok) ;
217
218G = GrB (magic (2), 'int16') ;
219try
220    C = eps (G)
221    ok = false ;
222catch expected_error
223    expected_error
224    disp (expected_error.stack (end-1))
225end
226assert (ok) ;
227
228try
229    C = GrB.entries (G, 'gunk')
230    ok = false ;
231catch expected_error
232    expected_error
233    disp (expected_error.stack (end-1))
234end
235assert (ok) ;
236
237try
238    C = GrB.entries (G, 'all', 'degree')
239    ok = false ;
240catch expected_error
241    expected_error
242    disp (expected_error.stack (end-1))
243end
244assert (ok) ;
245
246try
247    C = norm (G, 0) ;
248    ok = false ;
249catch expected_error
250    expected_error
251    disp (expected_error.stack (end-1))
252end
253assert (ok) ;
254
255try
256    C = norm (G, 42) ;
257    ok = false ;
258catch expected_error
259    expected_error
260    disp (expected_error.stack (end-1))
261end
262assert (ok) ;
263
264try
265    C = norm (G, -inf) ;
266    ok = false ;
267catch expected_error
268    expected_error
269    disp (expected_error.stack (end-1))
270end
271assert (ok) ;
272
273try
274    C = norm (G, 2) ;
275    ok = false ;
276catch expected_error
277    expected_error
278    disp (expected_error.stack (end-1))
279end
280assert (ok) ;
281
282v = GrB (rand (4,1)) ;
283try
284    C = norm (G, 42) ;
285    ok = false ;
286catch expected_error
287    expected_error
288    disp (expected_error.stack (end-1))
289end
290assert (ok) ;
291
292try
293    C = reshape (v, 42, 42) ;
294    ok = false ;
295catch expected_error
296    expected_error
297    disp (expected_error.stack (end-1))
298end
299assert (ok) ;
300
301try
302    C = reshape (v, [2 2 2]) ;
303    ok = false ;
304catch expected_error
305    expected_error
306    disp (expected_error.stack (end-1))
307end
308assert (ok) ;
309
310try
311    C = zeros (3, 3, 'crud', G) ; %#ok<*PREALL>
312    ok = false ;
313catch expected_error
314    expected_error
315    disp (expected_error.stack (end-1))
316end
317assert (ok) ;
318
319try
320    C = zeros ([3, 3], 'crud', G) ;
321    ok = false ;
322catch expected_error
323    expected_error
324    disp (expected_error.stack (end-1))
325end
326assert (ok) ;
327
328try
329    C = zeros (3, 3, 'like', G, 'gunk') ;
330    ok = false ;
331catch expected_error
332    expected_error
333end
334assert (ok) ;
335
336try
337    C = reshape (v, [2 2], 2) ;
338    ok = false ;
339catch expected_error
340    expected_error
341    disp (expected_error.stack (end-1))
342end
343assert (ok) ;
344
345try
346    C = norm (v, 'gunk') ;
347    ok = false ;
348catch expected_error
349    expected_error
350    disp (expected_error.stack (end-1))
351end
352assert (ok) ;
353
354try
355    C = norm (v, 3) ;
356    ok = false ;
357catch expected_error
358    expected_error
359    disp (expected_error.stack (end-1))
360end
361assert (ok) ;
362
363try
364    C = norm (G) ;
365    ok = false ;
366catch expected_error
367    expected_error
368    disp (expected_error.stack (end-1))
369end
370assert (ok) ;
371
372try
373    v = GrB.bfs (v, 1) ;
374    ok = false ;
375catch expected_error
376    expected_error
377    disp (expected_error.stack (end-1))
378end
379assert (ok) ;
380
381try
382    v = GrB.bfs (G, 1, 'gunk') ;
383    ok = false ;
384catch expected_error
385    expected_error
386    disp (expected_error.stack (end-1))
387end
388assert (ok) ;
389
390try
391    % G must be symmetric
392    v = GrB.bfs (G, 1, 'symmetric', 'check') ;
393    ok = false ;
394catch expected_error
395    expected_error
396    disp (expected_error.stack (end-1))
397end
398assert (ok) ;
399
400try
401    v = [G v] ;     % (concatenate with horzcat)
402    ok = false ;
403catch expected_error
404    expected_error
405    disp (expected_error.stack (end-1))
406end
407assert (ok) ;
408
409try
410    v = [G ; v] ;   % (concatenate with vertcat)
411    ok = false ;
412catch expected_error
413    expected_error
414    disp (expected_error.stack (end-1))
415end
416assert (ok) ;
417
418try
419    C = GrB.empty (4, 4) ;
420    ok = false ;
421catch expected_error
422    expected_error
423    disp (expected_error.stack (end-1))
424end
425assert (ok) ;
426
427try
428    C = GrB.empty ([0, 4, 4]) ;
429    ok = false ;
430catch expected_error
431    expected_error
432    disp (expected_error.stack (end-1))
433end
434assert (ok) ;
435
436try
437    c = GrB.tricount (v) ;
438    ok = false ;
439catch expected_error
440    expected_error
441    disp (expected_error.stack (end-1))
442end
443assert (ok) ;
444
445try
446    r = GrB.pagerank (rand (3,4)) ;
447    ok = false ;
448catch expected_error
449    expected_error
450    disp (expected_error.stack (end-1))
451end
452assert (ok) ;
453
454A = magic (5) ;
455A (5,1) = 0 ;
456G = GrB.prune (A) ;
457try
458    c = GrB.tricount (G, 'check') ;
459    assert (false) ;
460catch expected_error
461    expected_error
462    disp (expected_error.stack (end-1))
463end
464
465n = 10 ;
466A = sprand (n, n, 0.4) ;
467S = tril (A, -1) ;
468S = S+S' ;
469G = GrB (S) ;
470
471try
472    L = GrB.laplacian (G, 'uint8') ;
473    ok = false ;
474catch expected_error
475    expected_error
476    disp (expected_error.stack (end-1))
477end
478assert (ok) ;
479
480try
481    L = GrB.laplacian (A, 'double', 'check') ;
482    ok = false ;
483catch expected_error
484    expected_error
485    disp (expected_error.stack (end-1))
486end
487assert (ok) ;
488
489try
490    DiGraph = digraph (GrB (ones (4,3))) ;
491    ok = false ;
492catch expected_error
493    expected_error
494    disp (expected_error.stack (end-1))
495end
496assert (ok );
497
498try
499    DiGraph = digraph (GrB (ones (4)), 'crud') ;
500    ok = false ;
501catch expected_error
502    expected_error
503    disp (expected_error.stack (end-1))
504end
505assert (ok );
506
507clear d
508d.in0 = 'crud' ;
509try
510    GrB.descriptorinfo (d) ;
511    ok = false ;
512catch expected_error
513    expected_error
514    disp (expected_error.stack (end-1))
515end
516assert (ok) ;
517
518clear d
519d.in0 = 42 ;
520try
521    GrB.descriptorinfo (d) ;
522    ok = false ;
523catch expected_error
524    expected_error
525    disp (expected_error.stack (end-1))
526end
527assert (ok) ;
528
529clear d
530d.nthreads = 'something' ;
531try
532    GrB.descriptorinfo (d) ;
533    ok = false ;
534catch expected_error
535    expected_error
536    disp (expected_error.stack (end-1))
537end
538assert (ok) ;
539
540clear d
541d.chunk = 'something' ;
542try
543    GrB.descriptorinfo (d) ;
544    ok = false ;
545catch expected_error
546    expected_error
547    disp (expected_error.stack (end-1))
548end
549assert (ok) ;
550
551try
552    E = GrB.incidence (ones (4,3)) ;
553    ok = false ;
554catch expected_error
555    expected_error
556    disp (expected_error.stack (end-1))
557end
558assert (ok) ;
559
560try
561    E = GrB.incidence (ones (4), 'gunk') ;
562    ok = false ;
563catch expected_error
564    expected_error
565    disp (expected_error.stack (end-1))
566end
567assert (ok) ;
568
569try
570    Graph = graph (GrB (ones (4,3))) ;
571    ok = false ;
572catch expected_error
573    expected_error
574    disp (expected_error.stack (end-1))
575end
576assert (ok) ;
577
578try
579    Graph = graph (GrB (ones (4)), 'crud') ;
580    ok = false ;
581catch expected_error
582    expected_error
583    disp (expected_error.stack (end-1))
584end
585assert (ok) ;
586
587try
588    C = GrB.ktruss (rand (4), 2) ;
589    ok = false ;
590catch expected_error
591    expected_error
592    disp (expected_error.stack (end-1))
593end
594assert (ok) ;
595
596try
597    C = GrB.ktruss (rand (3,4)) ;
598    ok = false ;
599catch expected_error
600    expected_error
601    disp (expected_error.stack (end-1))
602end
603assert (ok) ;
604
605A = sprand (10, 10, 0.5) ;
606try
607    C = GrB.ktruss (A, 3, 'check') ;
608    ok = false ;
609catch expected_error
610    expected_error
611    disp (expected_error.stack (end-1))
612end
613assert (ok) ;
614
615A = A+A' ;
616try
617    C = GrB.ktruss (A, 3, 'check') ;
618    ok = false ;
619catch expected_error
620    expected_error
621    disp (expected_error.stack (end-1))
622end
623assert (ok) ;
624
625G = GrB (magic (2)) ;
626try
627    G = G (2:end)
628    ok = false ;
629catch expected_error
630    expected_error
631    disp (expected_error.stack (end-1))
632end
633assert (ok)
634
635try
636    G = G (2:end, 1:end, 1:end)
637    ok = false ;
638catch expected_error
639    expected_error
640    disp (expected_error.stack (end-1))
641end
642assert (ok)
643
644try
645    iset = GrB.mis (ones (3,4)) ;
646    ok = false ;
647catch expected_error
648    expected_error
649    disp (expected_error.stack (end-1))
650end
651assert (ok) ;
652
653try
654    iset = GrB.mis (ones (3), 'gunk') ;
655    ok = false ;
656catch expected_error
657    expected_error
658    disp (expected_error.stack (end-1))
659end
660assert (ok) ;
661
662try
663    iset = GrB.mis (ones (3), 'check') ;
664    ok = false ;
665catch expected_error
666    expected_error
667    disp (expected_error.stack (end-1))
668end
669assert (ok) ;
670
671A = sprand (10, 10, 0.5) ;
672try
673    iset = GrB.mis (GrB.offdiag (A), 'check') ;
674    ok = false ;
675catch expected_error
676    expected_error
677    disp (expected_error.stack (end-1))
678end
679assert (ok) ;
680
681try
682    iset = GrB.mis (ones (3)) ;
683    ok = false ;
684catch expected_error
685    expected_error
686    disp (expected_error.stack (end-1))
687end
688assert (ok) ;
689
690try
691    G = GrB (A, 'gunk') ;
692    ok = false ;
693catch expected_error
694    expected_error
695    disp (expected_error.stack (end-1))
696end
697assert (ok) ;
698
699try
700    G = GrB (A, 'gunk', 'crud') ;
701    ok = false ;
702catch expected_error
703    expected_error
704    disp (expected_error.stack (end-1))
705end
706assert (ok) ;
707
708try
709    G = GrB (4, 3, 'gunk') ;
710    ok = false ;
711catch expected_error
712    expected_error
713    disp (expected_error.stack (end-1))
714end
715assert (ok) ;
716
717try
718    G = GrB (4, 3, 'gunk', 'crud') ;
719    ok = false ;
720catch expected_error
721    expected_error
722    disp (expected_error.stack (end-1))
723end
724assert (ok) ;
725
726try
727    G = GrB (A, A) ;
728    ok = false ;
729catch expected_error
730    expected_error
731    disp (expected_error.stack (end-1))
732end
733assert (ok) ;
734
735try
736    G = GrB (A, A, A) ;
737    ok = false ;
738catch expected_error
739    expected_error
740    disp (expected_error.stack (end-1))
741end
742assert (ok) ;
743
744try
745    G = GrB (A, A, A, A) ;
746    ok = false ;
747catch expected_error
748    expected_error
749    disp (expected_error.stack (end-1))
750end
751assert (ok) ;
752
753try
754    G = GrB.assign (A, {1}, {1}, {1}, pi) ;
755    ok = false ;
756catch expected_error
757    expected_error
758    disp (expected_error.stack (end-1))
759end
760assert (ok) ;
761
762try
763    G = GrB.assign (A, '+', '+', {1}, {1}, pi) ;
764    ok = false ;
765catch expected_error
766    expected_error
767    disp (expected_error.stack (end-1))
768end
769assert (ok) ;
770
771try
772    G = GrB.assign (A, A, A, A) ;
773    ok = false ;
774catch expected_error
775    expected_error
776    disp (expected_error.stack (end-1))
777end
778assert (ok) ;
779
780try
781    G = GrB.assign (A, {1}, {1}) ;
782    ok = false ;
783catch expected_error
784    expected_error
785    disp (expected_error.stack (end-1))
786end
787assert (ok) ;
788
789try
790    GrB.semiringinfo ('') ;
791    ok = false ;
792catch expected_error
793    expected_error
794    disp (expected_error.stack (end-1))
795end
796assert (ok) ;
797
798try
799    G = GrB.mxm ('', 1, 1) ;
800    ok = false ;
801catch expected_error
802    expected_error
803    disp (expected_error.stack (end-1))
804end
805assert (ok) ;
806
807try
808    c = GrB.reduce (ones (2), '+', '+', 1) ;
809    ok = false ;
810catch expected_error
811    expected_error
812    disp (expected_error.stack (end-1))
813end
814assert (ok) ;
815
816try
817    GrB.monoidinfo ('/', 'double') ;
818    ok = false ;
819catch expected_error
820    expected_error
821    disp (expected_error.stack (end-1))
822end
823assert (ok) ;
824
825try
826    GrB.monoidinfo ('') ;
827    ok = false ;
828catch expected_error
829    expected_error
830    disp (expected_error.stack (end-1))
831end
832assert (ok) ;
833
834try
835    GrB.apply ('',1) ;
836    ok = false ;
837catch expected_error
838    expected_error
839    disp (expected_error.stack (end-1))
840end
841assert (ok) ;
842
843try
844    GrB.extract (pi, {1}, {1}, {1}) ;
845    ok = false ;
846catch expected_error
847    expected_error
848    disp (expected_error.stack (end-1))
849end
850assert (ok) ;
851
852try
853    GrB.extract (pi, pi, '+', '+', pi) ;
854    ok = false ;
855catch expected_error
856    expected_error
857    disp (expected_error.stack (end-1))
858end
859assert (ok) ;
860
861try
862    GrB.extract (pi, pi, pi, pi) ;
863    ok = false ;
864catch expected_error
865    expected_error
866    disp (expected_error.stack (end-1))
867end
868assert (ok) ;
869
870try
871    GrB.extract ('+') ;
872    ok = false ;
873catch expected_error
874    expected_error
875    disp (expected_error.stack (end-1))
876end
877assert (ok) ;
878
879try
880    GrB.build (int8(1), int8(1), pi)
881    ok = false ;
882catch expected_error
883    expected_error
884    disp (expected_error.stack (end-1))
885end
886assert (ok) ;
887
888try
889    GrB.extract ('+', pi) ;
890    ok = false ;
891catch expected_error
892    expected_error
893    disp (expected_error.stack (end-1))
894end
895assert (ok) ;
896
897try
898    GrB.select (pi, pi) ;
899    ok = false ;
900catch expected_error
901    expected_error
902    disp (expected_error.stack (end-1))
903end
904assert (ok) ;
905
906try
907    GrB.extract (pi, {1}, {1}, struct ('kind', 'gunk')) ;
908    ok = false ;
909catch expected_error
910    expected_error
911    disp (expected_error.stack (end-1))
912end
913assert (ok) ;
914
915try
916    GrB.extract (pi, {1}, {1}, struct ('format', 'gunk')) ;
917    ok = false ;
918catch expected_error
919    expected_error
920    disp (expected_error.stack (end-1))
921end
922assert (ok) ;
923
924try
925    [i,j,x] = find (G, [3 4]) ;
926    ok = false ;
927catch expected_error
928    expected_error
929    disp (expected_error.stack (end-1))
930end
931assert (ok) ;
932
933try
934    [i,j,x] = find (G, 3, 'crud') ;
935    ok = false ;
936catch expected_error
937    expected_error
938    disp (expected_error.stack (end-1))
939end
940assert (ok) ;
941
942try
943    [i,j,x] = find (G, -1, 'first') ;
944    ok = false ;
945catch expected_error
946    expected_error
947    disp (expected_error.stack (end-1))
948end
949assert (ok) ;
950
951try
952    C = flip (G, -1) ;
953    ok = false ;
954catch expected_error
955    expected_error
956    disp (expected_error.stack (end-1))
957end
958assert (ok) ;
959
960try
961    C = flip (G, [2 2]) ;
962    ok = false ;
963catch expected_error
964    expected_error
965    disp (expected_error.stack (end-1))
966end
967assert (ok) ;
968
969try
970    G = GrB.random (10, 10, 0.5, 'crud') ;
971    ok = false ;
972catch expected_error
973    expected_error
974    disp (expected_error.stack (end-1))
975end
976assert (ok) ;
977
978try
979    G = GrB.random (rand (4,5), 'symmetric') ;
980    ok = false ;
981catch expected_error
982    expected_error
983    disp (expected_error.stack (end-1))
984end
985assert (ok) ;
986
987try
988    G = GrB.random (10, 10, 10, 0.5) ;
989    ok = false ;
990catch expected_error
991    expected_error
992    disp (expected_error.stack (end-1))
993end
994assert (ok) ;
995
996try
997    G = GrB.mxm ('to', 'many', 'strings') ;
998    ok = false ;
999catch expected_error
1000    expected_error
1001    disp (expected_error.stack (end-1))
1002end
1003assert (ok) ;
1004
1005try
1006    G = GrB.mxm (G, G, G, G, G) ;
1007    ok = false ;
1008catch expected_error
1009    expected_error
1010    disp (expected_error.stack (end-1))
1011end
1012assert (ok) ;
1013
1014try
1015    G = GrB.build (1:3, 1:4, 1:4) ;
1016    ok = false ;
1017catch expected_error
1018    expected_error
1019    disp (expected_error.stack (end-1))
1020end
1021assert (ok) ;
1022
1023try
1024    GrB.select ('tril', A) ;
1025    ok = false ;
1026catch expected_error
1027    expected_error
1028    disp (expected_error.stack (end-1))
1029end
1030assert (ok) ;
1031
1032try
1033    GrB.select (A, A, A, A, 'zero') ;
1034    ok = false ;
1035catch expected_error
1036    expected_error
1037    disp (expected_error.stack (end-1))
1038end
1039assert (ok) ;
1040
1041try
1042    I = GrB.extracttuples (A, struct ('base', 'crud'))
1043    ok = false ;
1044catch expected_error
1045    expected_error
1046    disp (expected_error.stack (end-1))
1047end
1048assert (ok) ;
1049
1050fprintf ('gbtest43: all tests passed\n') ;
1051
1052