Debian Codegraph @

tests/heterogeneity/test_field_validation.m

raw
1 function [testFailed, testResults] = test_field_validation(M_, options_, steady_state, testFailed, testResults)
2 %test_field_validation Tests for field validation in heterogeneity.check_steady_state_input
3 %
4 % Comprehensive tests for field existence, types, and sizes in steady-state structure
5 %
6 % INPUTS:
7 % M_ [struct] Dynare model structure
8 % options_ [struct] Dynare options structure
9 % steady_state [struct] Steady state structure
10 % testFailed [scalar] Number of tests failed so far
11 % testResults [array] Array of test result structures
12 %
13 % OUTPUTS:
14 % testFailed [scalar] Updated number of tests failed
15 % testResults [array] Updated array of test results
16
17 fprintf('\n');
18 fprintf('Testing field validation\n');
19 fprintf('========================\n');
20
21 verbose = true;
22
23 %% === SHOCK FIELD TESTS ===
24
25 % Missing `shocks` field
26 ss_test = steady_state;
27 ss_test = rmfield(ss_test, 'shocks');
28 [testFailed, result] = expect_error(@() heterogeneity.check_steady_state_input(M_, options_.heterogeneity.check, ss_test), ...
29 'Missing `shocks` field', testFailed, verbose);
30 testResults = [testResults; result];
31
32 % Wrong type for `shocks.grids.e`
33 ss_test = steady_state;
34 ss_test.shocks.grids.e = ones(3,3); % invalid: matrix instead of vector
35 [testFailed, result] = expect_error(@() heterogeneity.check_steady_state_input(M_, options_.heterogeneity.check, ss_test), ...
36 'shocks.grids.e are not dense real vectors', testFailed, verbose);
37 testResults = [testResults; result];
38
39 % Wrong type for `shocks.Pi.e` (sparse instead of dense)
40 ss_test = steady_state;
41 ss_test.shocks.Pi.e = speye(numel(steady_state.shocks.grids.e));
42 [testFailed, result] = expect_error(@() heterogeneity.check_steady_state_input(M_, options_.heterogeneity.check, ss_test), ...
43 'shocks.Pi.e is not a dense real matrix', testFailed, verbose);
44 testResults = [testResults; result];
45
46 % Markov matrix wrong row number
47 ss_test = steady_state;
48 ss_test.shocks.Pi.e = rand(3, 7); % Should be square matching grid
49 [testFailed, result] = expect_error(@() heterogeneity.check_steady_state_input(M_, options_.heterogeneity.check, ss_test), ...
50 'shocks.Pi.e row count does not match', testFailed, verbose);
51 testResults = [testResults; result];
52
53 % Markov matrix wrong column number
54 ss_test = steady_state;
55 ss_test.shocks.Pi.e = rand(7, 3); % Should be square matching grid
56 [testFailed, result] = expect_error(@() heterogeneity.check_steady_state_input(M_, options_.heterogeneity.check, ss_test), ...
57 'shocks.Pi.e column count does not match', testFailed, verbose);
58 testResults = [testResults; result];
59
60 % Markov matrix has negative elements
61 ss_test = steady_state;
62 ss_test.shocks.Pi.e(1,1) = -0.1;
63 [testFailed, result] = expect_error(@() heterogeneity.check_steady_state_input(M_, options_.heterogeneity.check, ss_test), ...
64 'shocks.Pi.e contains negative elements', testFailed, verbose);
65 testResults = [testResults; result];
66
67 % Markov matrix does not sum to 1
68 ss_test = steady_state;
69 ss_test.shocks.Pi.e = steady_state.shocks.Pi.e * 2;
70 [testFailed, result] = expect_error(@() heterogeneity.check_steady_state_input(M_, options_.heterogeneity.check, ss_test), ...
71 'shocks.Pi.e has row sums different from 1', testFailed, verbose);
72 testResults = [testResults; result];
73
74 %% === POLICY TESTS ===
75
76 % Missing `pol` field
77 ss_test = steady_state;
78 ss_test = rmfield(ss_test, 'pol');
79 [testFailed, result] = expect_error(@() heterogeneity.check_steady_state_input(M_, options_.heterogeneity.check, ss_test), ...
80 'Missing `pol` field', testFailed, verbose);
81 testResults = [testResults; result];
82
83 % Missing `pol.grids`
84 ss_test = steady_state;
85 ss_test.pol = rmfield(steady_state.pol, 'grids');
86 [testFailed, result] = expect_error(@() heterogeneity.check_steady_state_input(M_, options_.heterogeneity.check, ss_test), ...
87 'Missing `pol.grids`', testFailed, verbose);
88 testResults = [testResults; result];
89
90 % Missing one state grid
91 steady_state_test = steady_state;
92 ss_test.pol.grids = rmfield(steady_state.pol.grids, 'a');
93 [testFailed, result] = expect_error(@() heterogeneity.check_steady_state_input(M_, options_.heterogeneity.check, ss_test), ...
94 'Missing state grid for a', testFailed, verbose);
95 testResults = [testResults; result];
96
97 % Wrong type for `pol.grids.a`
98 ss_test = steady_state;
99 ss_test.pol.grids.a = ones(3, 3); % should be a vector
100 [testFailed, result] = expect_error(@() heterogeneity.check_steady_state_input(M_, options_.heterogeneity.check, ss_test), ...
101 'pol.grids.a should be a vector', testFailed, verbose);
102 testResults = [testResults; result];
103
104 % Missing `pol.values`
105 ss_test = steady_state;
106 ss_test.pol = rmfield(steady_state.pol, 'values');
107 [testFailed, result] = expect_error(@() heterogeneity.check_steady_state_input(M_, options_.heterogeneity.check, ss_test), ...
108 'Missing `pol.values`', testFailed, verbose);
109 testResults = [testResults; result];
110
111 % Missing policy value for declared variable
112 ss_test = steady_state;
113 ss_test.pol.values = rmfield(steady_state.pol.values, 'a');
114 [testFailed, result] = expect_error(@() heterogeneity.check_steady_state_input(M_, options_.heterogeneity.check, ss_test), ...
115 'Missing policy value for a', testFailed, verbose);
116 testResults = [testResults; result];
117
118 % Wrong type for `pol.values.a`
119 ss_test = steady_state;
120 ss_test.pol.values.a = rand(2, 2, 2);
121 [testFailed, result] = expect_error(@() heterogeneity.check_steady_state_input(M_, options_.heterogeneity.check, ss_test), ...
122 'pol.values.a should be a matrix', testFailed, verbose);
123 testResults = [testResults; result];
124
125 % Incompatible policy matrix row size (shocks × states)
126 ss_test = steady_state;
127 ss_test.pol.values.a = rand(99, size(steady_state.pol.values.a, 2));
128 [testFailed, result] = expect_error(@() heterogeneity.check_steady_state_input(M_, options_.heterogeneity.check, ss_test), ...
129 'Wrong number of rows in policy matrix', testFailed, verbose);
130 testResults = [testResults; result];
131
132 % Incompatible policy matrix column size
133 ss_test = steady_state;
134 ss_test.pol.values.a = rand(size(steady_state.pol.values.a, 1), 99);
135 [testFailed, result] = expect_error(@() heterogeneity.check_steady_state_input(M_, options_.heterogeneity.check, ss_test), ...
136 'Wrong number of columns in policy matrix', testFailed, verbose);
137 testResults = [testResults; result];
138
139 %% === DISTRIBUTION TESTS ===
140
141 % Missing `d` field
142 ss_test = steady_state;
143 ss_test = rmfield(ss_test, 'd');
144 [testFailed, result] = expect_error(@() heterogeneity.check_steady_state_input(M_, options_.heterogeneity.check, ss_test), ...
145 'Missing distribution structure `d`', testFailed, verbose);
146 testResults = [testResults; result];
147
148 % Wrong type for `steady_state.d.grids.a`
149 ss_test = steady_state;
150 ss_test.d.grids.a = rand(3, 3); % not a vector
151 [testFailed, result] = expect_error(@() heterogeneity.check_steady_state_input(M_, options_.heterogeneity.check, ss_test), ...
152 'd.grids.a should be a vector', testFailed, verbose);
153 testResults = [testResults; result];
154
155 % Missing `d.hist`
156 ss_test = steady_state;
157 ss_test.d = rmfield(steady_state.d, 'hist');
158 [testFailed, result] = expect_error(@() heterogeneity.check_steady_state_input(M_, options_.heterogeneity.check, ss_test), ...
159 'Missing d.hist', testFailed, verbose);
160 testResults = [testResults; result];
161
162 % Wrong type for `steady_state.d.hist`
163 ss_test = steady_state;
164 ss_test.d.hist = rand(2,2,2);
165 [testFailed, result] = expect_error(@() heterogeneity.check_steady_state_input(M_, options_.heterogeneity.check, ss_test), ...
166 'd.hist should be a matrix', testFailed, verbose);
167 testResults = [testResults; result];
168
169 % Wrong row size in `d.hist`
170 ss_test = steady_state;
171 ss_test.d.hist = rand(99, size(steady_state.d.hist,2));
172 [testFailed, result] = expect_error(@() heterogeneity.check_steady_state_input(M_, options_.heterogeneity.check, ss_test), ...
173 'Wrong number of rows in d.hist', testFailed, verbose);
174 testResults = [testResults; result];
175
176 % Wrong column size in `d.hist`
177 ss_test = steady_state;
178 ss_test.d.hist = rand(size(steady_state.d.hist,1), 99);
179 [testFailed, result] = expect_error(@() heterogeneity.check_steady_state_input(M_, options_.heterogeneity.check, ss_test), ...
180 'Wrong number of columns in d.hist', testFailed, verbose);
181 testResults = [testResults; result];
182
183 %% === AGGREGATES TESTS ===
184
185 % Missing `agg` field
186 ss_test = steady_state;
187 ss_test = rmfield(ss_test, 'agg');
188 [testFailed, result] = expect_error(@() heterogeneity.check_steady_state_input(M_, options_.heterogeneity.check, ss_test), ...
189 'Missing `agg` field', testFailed, verbose);
190 testResults = [testResults; result];
191
192 % Remove one required aggregate variable
193 ss_test = steady_state;
194 ss_test.agg = rmfield(steady_state.agg, 'r'); % remove interest rate
195 [testFailed, result] = expect_error(@() heterogeneity.check_steady_state_input(M_, options_.heterogeneity.check, ss_test), ...
196 'Missing aggregate variable r', testFailed, verbose);
197 testResults = [testResults; result];
198
199 % Wrong type for `steady_state.agg.r`
200 ss_test = steady_state;
201 ss_test.agg.r = 'non-numeric';
202 [testFailed, result] = expect_error(@() heterogeneity.check_steady_state_input(M_, options_.heterogeneity.check, ss_test), ...
203 'agg.r should be numeric', testFailed, verbose);
204 testResults = [testResults; result];
205
206 %% === PERMUTATION TESTS ===
207
208 % pol.order is not a string or cellstr
209 ss_test = steady_state;
210 ss_test.pol.order = 123;
211 [testFailed, result] = expect_error(@() heterogeneity.check_steady_state_input(M_, options_.heterogeneity.check, ss_test), ...
212 'pol.order is not a string array or cellstr', testFailed, verbose);
213 testResults = [testResults; result];
214
215 % pol.order has wrong names
216 ss_test = steady_state;
217 ss_test.pol.order = {'wrong_name'};
218 [testFailed, result] = expect_error(@() heterogeneity.check_steady_state_input(M_, options_.heterogeneity.check, ss_test), ...
219 'pol.order fieldnames is not consistent', testFailed, verbose);
220 testResults = [testResults; result];
221
222 % d.order is not a string or cellstr
223 ss_test = steady_state;
224 ss_test.d.order = 3.14;
225 [testFailed, result] = expect_error(@() heterogeneity.check_steady_state_input(M_, options_.heterogeneity.check, ss_test), ...
226 'd.order is not a string array or cellstr', testFailed, verbose);
227 testResults = [testResults; result];
228
229 % d.order inconsistent with pol.order
230 ss_test = steady_state;
231 ss_test.d.order = {'ghost_shock'};
232 [testFailed, result] = expect_error(@() heterogeneity.check_steady_state_input(M_, options_.heterogeneity.check, ss_test), ...
233 'd.order not matching pol.order', testFailed, verbose);
234 testResults = [testResults; result];
235
236 %% === NaN TESTS ===
237
238 % NaN in shocks.grids.e
239 ss_test = steady_state;
240 ss_test.shocks.grids.e(3) = NaN;
241 [testFailed, result] = expect_error(@() heterogeneity.check_steady_state_input(M_, options_.heterogeneity.check, ss_test), ...
242 'shocks.grids.e contain NaN elements', testFailed, verbose);
243 testResults = [testResults; result];
244
245 % NaN in shocks.Pi.e
246 ss_test = steady_state;
247 ss_test.shocks.Pi.e(2,3) = NaN;
248 [testFailed, result] = expect_error(@() heterogeneity.check_steady_state_input(M_, options_.heterogeneity.check, ss_test), ...
249 'shocks.Pi.e contains NaN elements', testFailed, verbose);
250 testResults = [testResults; result];
251
252 % NaN in pol.grids.a
253 ss_test = steady_state;
254 ss_test.pol.grids.a(10) = NaN;
255 [testFailed, result] = expect_error(@() heterogeneity.check_steady_state_input(M_, options_.heterogeneity.check, ss_test), ...
256 'pol.grids.a contain NaN elements', testFailed, verbose);
257 testResults = [testResults; result];
258
259 % NaN in pol.values.a
260 ss_test = steady_state;
261 ss_test.pol.values.a(5,10) = NaN;
262 [testFailed, result] = expect_error(@() heterogeneity.check_steady_state_input(M_, options_.heterogeneity.check, ss_test), ...
263 'pol.values.a contain NaN elements', testFailed, verbose);
264 testResults = [testResults; result];
265
266 % NaN in d.grids.a
267 ss_test = steady_state;
268 ss_test.d.grids.a(20) = NaN;
269 [testFailed, result] = expect_error(@() heterogeneity.check_steady_state_input(M_, options_.heterogeneity.check, ss_test), ...
270 'd.grids.a contain NaN elements', testFailed, verbose);
271 testResults = [testResults; result];
272
273 % NaN in d.hist
274 ss_test = steady_state;
275 ss_test.d.hist(3,15) = NaN;
276 [testFailed, result] = expect_error(@() heterogeneity.check_steady_state_input(M_, options_.heterogeneity.check, ss_test), ...
277 'd.hist contains NaN elements', testFailed, verbose);
278 testResults = [testResults; result];
279
280 % NaN in agg.r
281 ss_test = steady_state;
282 ss_test.agg.r = NaN;
283 [testFailed, result] = expect_error(@() heterogeneity.check_steady_state_input(M_, options_.heterogeneity.check, ss_test), ...
284 'agg.r contain NaN values', testFailed, verbose);
285 testResults = [testResults; result];
286
287 %% === MONOTONICITY TESTS ===
288
289 % Non-monotonic shocks.grids.e (decreasing)
290 ss_test = steady_state;
291 ss_test.shocks.grids.e = [1; 2; 3; 2.5; 4; 5; 6]; % element 4 < element 3
292 [testFailed, result] = expect_error(@() heterogeneity.check_steady_state_input(M_, options_.heterogeneity.check, ss_test), ...
293 'shocks.grids.e are not strictly increasing', testFailed, verbose);
294 testResults = [testResults; result];
295
296 % Non-monotonic shocks.grids.e (equal consecutive values)
297 ss_test = steady_state;
298 ss_test.shocks.grids.e = [1; 2; 3; 3; 4; 5; 6]; % element 3 == element 4
299 [testFailed, result] = expect_error(@() heterogeneity.check_steady_state_input(M_, options_.heterogeneity.check, ss_test), ...
300 'shocks.grids.e are not strictly increasing (equal values)', testFailed, verbose);
301 testResults = [testResults; result];
302
303 % Non-monotonic pol.grids.a (decreasing)
304 ss_test = steady_state;
305 ss_test.pol.grids.a(50) = steady_state.pol.grids.a(49) - 0.1; % Make element 50 < element 49
306 [testFailed, result] = expect_error(@() heterogeneity.check_steady_state_input(M_, options_.heterogeneity.check, ss_test), ...
307 'pol.grids.a are not strictly increasing', testFailed, verbose);
308 testResults = [testResults; result];
309
310 % Non-monotonic pol.grids.a (equal consecutive values)
311 ss_test = steady_state;
312 ss_test.pol.grids.a(25) = steady_state.pol.grids.a(24); % Make element 25 == element 24
313 [testFailed, result] = expect_error(@() heterogeneity.check_steady_state_input(M_, options_.heterogeneity.check, ss_test), ...
314 'pol.grids.a are not strictly increasing (equal values)', testFailed, verbose);
315 testResults = [testResults; result];
316
317 %% === GRID BOUNDS TESTS ===
318
319 % d.grids minimum differs from pol.grids minimum
320 ss_test = steady_state;
321 ss_test.d.grids.a = steady_state.pol.grids.a;
322 ss_test.d.grids.a(1) = steady_state.pol.grids.a(1) - 0.1; % Different minimum
323 [testFailed, result] = expect_error(@() heterogeneity.check_steady_state_input(M_, options_.heterogeneity.check, ss_test), ...
324 'd.grids.a minimum differs from pol.grids.a', testFailed, verbose);
325 testResults = [testResults; result];
326
327 % d.grids maximum differs from pol.grids maximum
328 ss_test = steady_state;
329 ss_test.d.grids.a = steady_state.pol.grids.a;
330 ss_test.d.grids.a(end) = steady_state.pol.grids.a(end) + 0.1; % Different maximum
331 [testFailed, result] = expect_error(@() heterogeneity.check_steady_state_input(M_, options_.heterogeneity.check, ss_test), ...
332 'd.grids.a maximum differs from pol.grids.a', testFailed, verbose);
333 testResults = [testResults; result];
334
335 %% === REDUNDANCY TESTS ===
336
337 % shocks.Pi contains redundant entry (not in shocks.grids)
338 ss_test = steady_state;
339 ss_test.shocks.Pi.extra = eye(length(steady_state.shocks.grids.e)); % not listed in shocks.grids
340 try
341 [out_ss, sizes] = heterogeneity.check_steady_state_input(M_, options_.heterogeneity.check, ss_test);
342 fprintf('✔ Redundant shocks.Pi entry accepted (warning expected)\n');
343 testResults = [testResults; struct('name', 'Redundant shocks.Pi entry', 'passed', true, 'message', '')];
344 catch ME
345 testFailed = testFailed+1;
346 fprintf('❌ Unexpected error from redundant shocks.Pi entry: %s\n', ME.message);
347 testResults = [testResults; struct('name', 'Redundant shocks.Pi entry', 'passed', false, 'message', ME.message)];
348 end
349
350 % pol.values contains redundant field (not in model's pol_symbs)
351 ss_test = steady_state;
352 ss_test.pol.values.redundant_var = ones(size(steady_state.pol.values.a));
353 try
354 [out_ss, sizes] = heterogeneity.check_steady_state_input(M_, options_.heterogeneity.check, ss_test);
355 fprintf('✔ Redundant pol.values field accepted (warning expected)\n');
356 testResults = [testResults; struct('name', 'Redundant pol.values field', 'passed', true, 'message', '')];
357 catch ME
358 testFailed = testFailed+1;
359 fprintf('❌ Unexpected error from redundant pol.values field: %s\n', ME.message);
360 testResults = [testResults; struct('name', 'Redundant pol.values field', 'passed', false, 'message', ME.message)];
361 end
362
363 % d.grids contains redundant field (not a declared state)
364 ss_test = steady_state;
365 ss_test.d.grids.not_a_state = [0;1;2]; % not in M_.heterogeneity.state_var
366 try
367 [out_ss, sizes] = heterogeneity.check_steady_state_input(M_, options_.heterogeneity.check, ss_test);
368 fprintf('✔ Redundant d.grids field accepted (warning expected)\n');
369 testResults = [testResults; struct('name', 'Redundant d.grids field', 'passed', true, 'message', '')];
370 catch ME
371 testFailed = testFailed+1;
372 fprintf('❌ Unexpected error from redundant d.grids field: %s\n', ME.message);
373 testResults = [testResults; struct('name', 'Redundant d.grids field', 'passed', false, 'message', ME.message)];
374 end
375
376 % agg contains extra field (not in M_.endo_names)
377 ss_test = steady_state;
378 ss_test.agg.extra_agg = 999;
379 try
380 [out_ss, sizes] = heterogeneity.check_steady_state_input(M_, options_.heterogeneity.check, ss_test);
381 fprintf('✔ Redundant agg field accepted (warning expected)\n');
382 testResults = [testResults; struct('name', 'Redundant agg field', 'passed', true, 'message', '')];
383 catch ME
384 testFailed = testFailed+1;
385 fprintf('❌ Unexpected error from redundant agg field: %s\n', ME.message);
386 testResults = [testResults; struct('name', 'Redundant agg field', 'passed', false, 'message', ME.message)];
387 end
388
389 end