1 /* SPDX-License-Identifier: BSD-2-Clause */
2 /*******************************************************************************
3  * Copyright 2017-2018, Fraunhofer SIT sponsored by Infineon Technologies AG
4  * All rights reserved.
5  *******************************************************************************/
6 
7 #ifdef HAVE_CONFIG_H
8 #include <config.h>
9 #endif
10 
11 #include <stdarg.h>
12 #include <stdlib.h>
13 #include <inttypes.h>
14 #include <string.h>
15 
16 #include <setjmp.h>
17 #include <cmocka.h>
18 
19 #include "tss2_esys.h"
20 
21 #include "tss2-esys/esys_iutil.h"
22 #define LOGMODULE tests
23 #include "util/log.h"
24 #include "util/aux_util.h"
25 
26 /*
27  * Tests whether all ESAPI finish calls handle wrong internal states with the correct
28  * error response TSS2_ESYS_RC_BAD_SEQUENCE.
29  */
30 
31 static TSS2_RC
tcti_failure_transmit(TSS2_TCTI_CONTEXT * tctiContext,size_t size,const uint8_t * buffer)32 tcti_failure_transmit(TSS2_TCTI_CONTEXT * tctiContext,
33                       size_t size, const uint8_t * buffer)
34 {
35     UNUSED(tctiContext);
36     UNUSED(size);
37     UNUSED(buffer);
38 
39     return TSS2_RC_SUCCESS;
40 }
41 
42 const uint8_t failure_response[] = {
43     0x80, 0x01,                 /* TPM_ST_NO_SESSION */
44     0x00, 0x00, 0x00, 0x0A,     /* Response Size 10 */
45     0x00, 0x00, 0x01, 0x01      /* TPM_RC_FAILURE */
46 };
47 
48 static TSS2_RC
tcti_failure_receive(TSS2_TCTI_CONTEXT * tctiContext,size_t * response_size,uint8_t * response_buffer,int32_t timeout)49 tcti_failure_receive(TSS2_TCTI_CONTEXT * tctiContext,
50                      size_t * response_size,
51                      uint8_t * response_buffer, int32_t timeout)
52 {
53     *response_size = sizeof(failure_response);
54     if (response_buffer != NULL)
55         memcpy(response_buffer, &failure_response[0], sizeof(failure_response));
56 
57     return TSS2_RC_SUCCESS;
58 }
59 
60 /**
61  * Prepare ESAPI context with a reference to SAPI and TCTI context.
62  */
63 static int
esys_unit_setup(void ** state)64 esys_unit_setup(void **state)
65 {
66     TSS2_RC r;
67     ESYS_CONTEXT *esys_context;
68 
69     /* This is a fake tcti context */
70     TSS2_TCTI_CONTEXT_COMMON_V1 *tcti =
71         calloc(1, sizeof(TSS2_TCTI_CONTEXT_COMMON_V1));
72     tcti->version = 1;
73     TSS2_TCTI_TRANSMIT (tcti) = tcti_failure_transmit;
74     TSS2_TCTI_RECEIVE (tcti) = tcti_failure_receive;
75 
76     r = Esys_Initialize(&esys_context, (TSS2_TCTI_CONTEXT *) tcti, NULL);
77     assert_int_equal(r, TSS2_RC_SUCCESS);
78     *state = (void *)esys_context;
79     return 0;
80 }
81 
82 /**
83  * Free  ESAPI, SAPI and TCTI context.
84  */
85 static int
esys_unit_teardown(void ** state)86 esys_unit_teardown(void **state)
87 {
88     TSS2_RC r;
89     ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
90     TSS2_TCTI_CONTEXT *tcti;
91     r = Esys_GetTcti(esys_context, &tcti);
92     assert_int_equal(r, TSS2_RC_SUCCESS);
93     Esys_Finalize(&esys_context);
94     free(tcti);
95     return 0;
96 }
97 
98 void
check_Startup(void ** state)99 check_Startup(void **state)
100 {
101     TSS2_RC r;
102     ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
103     enum _ESYS_STATE esys_states[3] = {
104         _ESYS_STATE_INIT,
105         _ESYS_STATE_INTERNALERROR
106     };
107     for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
108         esys_context->state = esys_states[i];
109         r = Esys_Startup_Finish(esys_context);
110         assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
111     }
112 }
113 
114 void
check_Shutdown(void ** state)115 check_Shutdown(void **state)
116 {
117     TSS2_RC r;
118     ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
119     enum _ESYS_STATE esys_states[3] = {
120         _ESYS_STATE_INIT,
121         _ESYS_STATE_INTERNALERROR
122     };
123     for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
124         esys_context->state = esys_states[i];
125         r = Esys_Shutdown_Finish(esys_context);
126         assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
127     }
128 }
129 
130 void
check_SelfTest(void ** state)131 check_SelfTest(void **state)
132 {
133     TSS2_RC r;
134     ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
135     enum _ESYS_STATE esys_states[3] = {
136         _ESYS_STATE_INIT,
137         _ESYS_STATE_INTERNALERROR
138     };
139     for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
140         esys_context->state = esys_states[i];
141         r = Esys_SelfTest_Finish(esys_context);
142         assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
143     }
144 }
145 
146 void
check_IncrementalSelfTest(void ** state)147 check_IncrementalSelfTest(void **state)
148 {
149     TSS2_RC r;
150     ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
151     enum _ESYS_STATE esys_states[3] = {
152         _ESYS_STATE_INIT,
153         _ESYS_STATE_INTERNALERROR
154     };
155     TPML_ALG *toDoList;
156     for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
157         esys_context->state = esys_states[i];
158         r = Esys_IncrementalSelfTest_Finish(esys_context, &toDoList);
159         assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
160     }
161 }
162 
163 void
check_GetTestResult(void ** state)164 check_GetTestResult(void **state)
165 {
166     TSS2_RC r;
167     ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
168     enum _ESYS_STATE esys_states[3] = {
169         _ESYS_STATE_INIT,
170         _ESYS_STATE_INTERNALERROR
171     };
172     TPM2B_MAX_BUFFER *outData;
173     TPM2_RC testResult;
174     for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
175         esys_context->state = esys_states[i];
176         r = Esys_GetTestResult_Finish(esys_context, &outData, &testResult);
177         assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
178     }
179 }
180 
181 void
check_StartAuthSession(void ** state)182 check_StartAuthSession(void **state)
183 {
184     TSS2_RC r;
185     ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
186     enum _ESYS_STATE esys_states[3] = {
187         _ESYS_STATE_INIT,
188         _ESYS_STATE_INTERNALERROR
189     };
190     ESYS_TR sessionHandle_handle;
191     for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
192         esys_context->state = esys_states[i];
193         r = Esys_StartAuthSession_Finish(esys_context,
194                                          &sessionHandle_handle);
195         assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
196     }
197 }
198 
199 void
check_PolicyRestart(void ** state)200 check_PolicyRestart(void **state)
201 {
202     TSS2_RC r;
203     ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
204     enum _ESYS_STATE esys_states[3] = {
205         _ESYS_STATE_INIT,
206         _ESYS_STATE_INTERNALERROR
207     };
208     for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
209         esys_context->state = esys_states[i];
210         r = Esys_PolicyRestart_Finish(esys_context);
211         assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
212     }
213 }
214 
215 void
check_Create(void ** state)216 check_Create(void **state)
217 {
218     TSS2_RC r;
219     ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
220     enum _ESYS_STATE esys_states[3] = {
221         _ESYS_STATE_INIT,
222         _ESYS_STATE_INTERNALERROR
223     };
224     TPM2B_PRIVATE *outPrivate;
225     TPM2B_PUBLIC *outPublic;
226     TPM2B_CREATION_DATA *creationData;
227     TPM2B_DIGEST *creationHash;
228     TPMT_TK_CREATION *creationTicket;
229     for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
230         esys_context->state = esys_states[i];
231         r = Esys_Create_Finish(esys_context,
232                                &outPrivate,
233                                &outPublic,
234                                &creationData, &creationHash, &creationTicket);
235         assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
236     }
237 }
238 
239 void
check_Load(void ** state)240 check_Load(void **state)
241 {
242     TSS2_RC r;
243     ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
244     enum _ESYS_STATE esys_states[3] = {
245         _ESYS_STATE_INIT,
246         _ESYS_STATE_INTERNALERROR
247     };
248     ESYS_TR objectHandle_handle;
249     for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
250         esys_context->state = esys_states[i];
251         r = Esys_Load_Finish(esys_context, &objectHandle_handle);
252         assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
253     }
254 }
255 
256 void
check_LoadExternal(void ** state)257 check_LoadExternal(void **state)
258 {
259     TSS2_RC r;
260     ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
261     enum _ESYS_STATE esys_states[3] = {
262         _ESYS_STATE_INIT,
263         _ESYS_STATE_INTERNALERROR
264     };
265     ESYS_TR objectHandle_handle;
266     for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
267         esys_context->state = esys_states[i];
268         r = Esys_LoadExternal_Finish(esys_context, &objectHandle_handle);
269         assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
270     }
271 }
272 
273 void
check_ReadPublic(void ** state)274 check_ReadPublic(void **state)
275 {
276     TSS2_RC r;
277     ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
278     enum _ESYS_STATE esys_states[3] = {
279         _ESYS_STATE_INIT,
280         _ESYS_STATE_INTERNALERROR
281     };
282     TPM2B_PUBLIC *outPublic;
283     TPM2B_NAME *name;
284     TPM2B_NAME *qualifiedName;
285     for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
286         esys_context->state = esys_states[i];
287         r = Esys_ReadPublic_Finish(esys_context,
288                                    &outPublic, &name, &qualifiedName);
289         assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
290     }
291 }
292 
293 void
check_ActivateCredential(void ** state)294 check_ActivateCredential(void **state)
295 {
296     TSS2_RC r;
297     ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
298     enum _ESYS_STATE esys_states[3] = {
299         _ESYS_STATE_INIT,
300         _ESYS_STATE_INTERNALERROR
301     };
302     TPM2B_DIGEST *certInfo;
303     for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
304         esys_context->state = esys_states[i];
305         r = Esys_ActivateCredential_Finish(esys_context, &certInfo);
306         assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
307     }
308 }
309 
310 void
check_MakeCredential(void ** state)311 check_MakeCredential(void **state)
312 {
313     TSS2_RC r;
314     ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
315     enum _ESYS_STATE esys_states[3] = {
316         _ESYS_STATE_INIT,
317         _ESYS_STATE_INTERNALERROR
318     };
319     TPM2B_ID_OBJECT *credentialBlob;
320     TPM2B_ENCRYPTED_SECRET *secret;
321     for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
322         esys_context->state = esys_states[i];
323         r = Esys_MakeCredential_Finish(esys_context, &credentialBlob, &secret);
324         assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
325     }
326 }
327 
328 void
check_Unseal(void ** state)329 check_Unseal(void **state)
330 {
331     TSS2_RC r;
332     ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
333     enum _ESYS_STATE esys_states[3] = {
334         _ESYS_STATE_INIT,
335         _ESYS_STATE_INTERNALERROR
336     };
337     TPM2B_SENSITIVE_DATA *outData;
338     for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
339         esys_context->state = esys_states[i];
340         r = Esys_Unseal_Finish(esys_context, &outData);
341         assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
342     }
343 }
344 
345 void
check_ObjectChangeAuth(void ** state)346 check_ObjectChangeAuth(void **state)
347 {
348     TSS2_RC r;
349     ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
350     enum _ESYS_STATE esys_states[3] = {
351         _ESYS_STATE_INIT,
352         _ESYS_STATE_INTERNALERROR
353     };
354     TPM2B_PRIVATE *outPrivate;
355     for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
356         esys_context->state = esys_states[i];
357         r = Esys_ObjectChangeAuth_Finish(esys_context, &outPrivate);
358         assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
359     }
360 }
361 
362 void
check_CreateLoaded(void ** state)363 check_CreateLoaded(void **state)
364 {
365     TSS2_RC r;
366     ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
367     enum _ESYS_STATE esys_states[3] = {
368         _ESYS_STATE_INIT,
369         _ESYS_STATE_INTERNALERROR
370     };
371     ESYS_TR objectHandle_handle;
372     TPM2B_PRIVATE *outPrivate;
373     TPM2B_PUBLIC *outPublic;
374     for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
375         esys_context->state = esys_states[i];
376         r = Esys_CreateLoaded_Finish(esys_context,
377                                      &objectHandle_handle,
378                                      &outPrivate, &outPublic);
379         assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
380     }
381 }
382 
383 void
check_Duplicate(void ** state)384 check_Duplicate(void **state)
385 {
386     TSS2_RC r;
387     ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
388     enum _ESYS_STATE esys_states[3] = {
389         _ESYS_STATE_INIT,
390         _ESYS_STATE_INTERNALERROR
391     };
392     TPM2B_DATA *encryptionKeyOut;
393     TPM2B_PRIVATE *duplicate;
394     TPM2B_ENCRYPTED_SECRET *outSymSeed;
395     for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
396         esys_context->state = esys_states[i];
397         r = Esys_Duplicate_Finish(esys_context,
398                                   &encryptionKeyOut, &duplicate, &outSymSeed);
399         assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
400     }
401 }
402 
403 void
check_Rewrap(void ** state)404 check_Rewrap(void **state)
405 {
406     TSS2_RC r;
407     ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
408     enum _ESYS_STATE esys_states[3] = {
409         _ESYS_STATE_INIT,
410         _ESYS_STATE_INTERNALERROR
411     };
412     TPM2B_PRIVATE *outDuplicate;
413     TPM2B_ENCRYPTED_SECRET *outSymSeed;
414     for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
415         esys_context->state = esys_states[i];
416         r = Esys_Rewrap_Finish(esys_context, &outDuplicate, &outSymSeed);
417         assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
418     }
419 }
420 
421 void
check_Import(void ** state)422 check_Import(void **state)
423 {
424     TSS2_RC r;
425     ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
426     enum _ESYS_STATE esys_states[3] = {
427         _ESYS_STATE_INIT,
428         _ESYS_STATE_INTERNALERROR
429     };
430     TPM2B_PRIVATE *outPrivate;
431     for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
432         esys_context->state = esys_states[i];
433         r = Esys_Import_Finish(esys_context, &outPrivate);
434         assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
435     }
436 }
437 
438 void
check_RSA_Encrypt(void ** state)439 check_RSA_Encrypt(void **state)
440 {
441     TSS2_RC r;
442     ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
443     enum _ESYS_STATE esys_states[3] = {
444         _ESYS_STATE_INIT,
445         _ESYS_STATE_INTERNALERROR
446     };
447     TPM2B_PUBLIC_KEY_RSA *outData;
448     for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
449         esys_context->state = esys_states[i];
450         r = Esys_RSA_Encrypt_Finish(esys_context, &outData);
451         assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
452     }
453 }
454 
455 void
check_RSA_Decrypt(void ** state)456 check_RSA_Decrypt(void **state)
457 {
458     TSS2_RC r;
459     ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
460     enum _ESYS_STATE esys_states[3] = {
461         _ESYS_STATE_INIT,
462         _ESYS_STATE_INTERNALERROR
463     };
464     TPM2B_PUBLIC_KEY_RSA *message;
465     for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
466         esys_context->state = esys_states[i];
467         r = Esys_RSA_Decrypt_Finish(esys_context, &message);
468         assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
469     }
470 }
471 
472 void
check_ECDH_KeyGen(void ** state)473 check_ECDH_KeyGen(void **state)
474 {
475     TSS2_RC r;
476     ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
477     enum _ESYS_STATE esys_states[3] = {
478         _ESYS_STATE_INIT,
479         _ESYS_STATE_INTERNALERROR
480     };
481     TPM2B_ECC_POINT *zPoint;
482     TPM2B_ECC_POINT *pubPoint;
483     for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
484         esys_context->state = esys_states[i];
485         r = Esys_ECDH_KeyGen_Finish(esys_context, &zPoint, &pubPoint);
486         assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
487     }
488 }
489 
490 void
check_ECDH_ZGen(void ** state)491 check_ECDH_ZGen(void **state)
492 {
493     TSS2_RC r;
494     ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
495     enum _ESYS_STATE esys_states[3] = {
496         _ESYS_STATE_INIT,
497         _ESYS_STATE_INTERNALERROR
498     };
499     TPM2B_ECC_POINT *outPoint;
500     for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
501         esys_context->state = esys_states[i];
502         r = Esys_ECDH_ZGen_Finish(esys_context, &outPoint);
503         assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
504     }
505 }
506 
507 void
check_ECC_Parameters(void ** state)508 check_ECC_Parameters(void **state)
509 {
510     TSS2_RC r;
511     ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
512     enum _ESYS_STATE esys_states[3] = {
513         _ESYS_STATE_INIT,
514         _ESYS_STATE_INTERNALERROR
515     };
516     TPMS_ALGORITHM_DETAIL_ECC *parameters;
517     for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
518         esys_context->state = esys_states[i];
519         r = Esys_ECC_Parameters_Finish(esys_context, &parameters);
520         assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
521     }
522 }
523 
524 void
check_ZGen_2Phase(void ** state)525 check_ZGen_2Phase(void **state)
526 {
527     TSS2_RC r;
528     ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
529     enum _ESYS_STATE esys_states[3] = {
530         _ESYS_STATE_INIT,
531         _ESYS_STATE_INTERNALERROR
532     };
533     TPM2B_ECC_POINT *outZ1;
534     TPM2B_ECC_POINT *outZ2;
535     for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
536         esys_context->state = esys_states[i];
537         r = Esys_ZGen_2Phase_Finish(esys_context, &outZ1, &outZ2);
538         assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
539     }
540 }
541 
542 void
check_EncryptDecrypt(void ** state)543 check_EncryptDecrypt(void **state)
544 {
545     TSS2_RC r;
546     ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
547     enum _ESYS_STATE esys_states[3] = {
548         _ESYS_STATE_INIT,
549         _ESYS_STATE_INTERNALERROR
550     };
551     TPM2B_MAX_BUFFER *outData;
552     TPM2B_IV *ivOut;
553     for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
554         esys_context->state = esys_states[i];
555         r = Esys_EncryptDecrypt_Finish(esys_context, &outData, &ivOut);
556         assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
557     }
558 }
559 
560 void
check_EncryptDecrypt2(void ** state)561 check_EncryptDecrypt2(void **state)
562 {
563     TSS2_RC r;
564     ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
565     enum _ESYS_STATE esys_states[3] = {
566         _ESYS_STATE_INIT,
567         _ESYS_STATE_INTERNALERROR
568     };
569     TPM2B_MAX_BUFFER *outData;
570     TPM2B_IV *ivOut;
571     for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
572         esys_context->state = esys_states[i];
573         r = Esys_EncryptDecrypt2_Finish(esys_context, &outData, &ivOut);
574         assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
575     }
576 }
577 
578 void
check_Hash(void ** state)579 check_Hash(void **state)
580 {
581     TSS2_RC r;
582     ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
583     enum _ESYS_STATE esys_states[3] = {
584         _ESYS_STATE_INIT,
585         _ESYS_STATE_INTERNALERROR
586     };
587     TPM2B_DIGEST *outHash;
588     TPMT_TK_HASHCHECK *validation;
589     for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
590         esys_context->state = esys_states[i];
591         r = Esys_Hash_Finish(esys_context, &outHash, &validation);
592         assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
593     }
594 }
595 
596 void
check_HMAC(void ** state)597 check_HMAC(void **state)
598 {
599     TSS2_RC r;
600     ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
601     enum _ESYS_STATE esys_states[3] = {
602         _ESYS_STATE_INIT,
603         _ESYS_STATE_INTERNALERROR
604     };
605     TPM2B_DIGEST *outHMAC;
606     for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
607         esys_context->state = esys_states[i];
608         r = Esys_HMAC_Finish(esys_context, &outHMAC);
609         assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
610     }
611 }
612 
613 void
check_GetRandom(void ** state)614 check_GetRandom(void **state)
615 {
616     TSS2_RC r;
617     ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
618     enum _ESYS_STATE esys_states[3] = {
619         _ESYS_STATE_INIT,
620         _ESYS_STATE_INTERNALERROR
621     };
622     TPM2B_DIGEST *randomBytes;
623     for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
624         esys_context->state = esys_states[i];
625         r = Esys_GetRandom_Finish(esys_context, &randomBytes);
626         assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
627     }
628 }
629 
630 void
check_StirRandom(void ** state)631 check_StirRandom(void **state)
632 {
633     TSS2_RC r;
634     ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
635     enum _ESYS_STATE esys_states[3] = {
636         _ESYS_STATE_INIT,
637         _ESYS_STATE_INTERNALERROR
638     };
639     for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
640         esys_context->state = esys_states[i];
641         r = Esys_StirRandom_Finish(esys_context);
642         assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
643     }
644 }
645 
646 void
check_HMAC_Start(void ** state)647 check_HMAC_Start(void **state)
648 {
649     TSS2_RC r;
650     ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
651     enum _ESYS_STATE esys_states[3] = {
652         _ESYS_STATE_INIT,
653         _ESYS_STATE_INTERNALERROR
654     };
655     ESYS_TR sequenceHandle_handle;
656     for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
657         esys_context->state = esys_states[i];
658         r = Esys_HMAC_Start_Finish(esys_context, &sequenceHandle_handle);
659         assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
660     }
661 }
662 
663 void
check_HashSequenceStart(void ** state)664 check_HashSequenceStart(void **state)
665 {
666     TSS2_RC r;
667     ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
668     enum _ESYS_STATE esys_states[3] = {
669         _ESYS_STATE_INIT,
670         _ESYS_STATE_INTERNALERROR
671     };
672     ESYS_TR sequenceHandle_handle;
673     for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
674         esys_context->state = esys_states[i];
675         r = Esys_HashSequenceStart_Finish(esys_context, &sequenceHandle_handle);
676         assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
677     }
678 }
679 
680 void
check_SequenceUpdate(void ** state)681 check_SequenceUpdate(void **state)
682 {
683     TSS2_RC r;
684     ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
685     enum _ESYS_STATE esys_states[3] = {
686         _ESYS_STATE_INIT,
687         _ESYS_STATE_INTERNALERROR
688     };
689     for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
690         esys_context->state = esys_states[i];
691         r = Esys_SequenceUpdate_Finish(esys_context);
692         assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
693     }
694 }
695 
696 void
check_SequenceComplete(void ** state)697 check_SequenceComplete(void **state)
698 {
699     TSS2_RC r;
700     ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
701     enum _ESYS_STATE esys_states[3] = {
702         _ESYS_STATE_INIT,
703         _ESYS_STATE_INTERNALERROR
704     };
705     TPM2B_DIGEST *result;
706     TPMT_TK_HASHCHECK *validation;
707     for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
708         esys_context->state = esys_states[i];
709         r = Esys_SequenceComplete_Finish(esys_context, &result, &validation);
710         assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
711     }
712 }
713 
714 void
check_EventSequenceComplete(void ** state)715 check_EventSequenceComplete(void **state)
716 {
717     TSS2_RC r;
718     ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
719     enum _ESYS_STATE esys_states[3] = {
720         _ESYS_STATE_INIT,
721         _ESYS_STATE_INTERNALERROR
722     };
723     TPML_DIGEST_VALUES *results;
724     for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
725         esys_context->state = esys_states[i];
726         r = Esys_EventSequenceComplete_Finish(esys_context, &results);
727         assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
728     }
729 }
730 
731 void
check_Certify(void ** state)732 check_Certify(void **state)
733 {
734     TSS2_RC r;
735     ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
736     enum _ESYS_STATE esys_states[3] = {
737         _ESYS_STATE_INIT,
738         _ESYS_STATE_INTERNALERROR
739     };
740     TPM2B_ATTEST *certifyInfo;
741     TPMT_SIGNATURE *signature;
742     for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
743         esys_context->state = esys_states[i];
744         r = Esys_Certify_Finish(esys_context, &certifyInfo, &signature);
745         assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
746     }
747 }
748 
749 void
check_CertifyCreation(void ** state)750 check_CertifyCreation(void **state)
751 {
752     TSS2_RC r;
753     ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
754     enum _ESYS_STATE esys_states[3] = {
755         _ESYS_STATE_INIT,
756         _ESYS_STATE_INTERNALERROR
757     };
758     TPM2B_ATTEST *certifyInfo;
759     TPMT_SIGNATURE *signature;
760     for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
761         esys_context->state = esys_states[i];
762         r = Esys_CertifyCreation_Finish(esys_context, &certifyInfo, &signature);
763         assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
764     }
765 }
766 
767 void
check_Quote(void ** state)768 check_Quote(void **state)
769 {
770     TSS2_RC r;
771     ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
772     enum _ESYS_STATE esys_states[3] = {
773         _ESYS_STATE_INIT,
774         _ESYS_STATE_INTERNALERROR
775     };
776     TPM2B_ATTEST *quoted;
777     TPMT_SIGNATURE *signature;
778     for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
779         esys_context->state = esys_states[i];
780         r = Esys_Quote_Finish(esys_context, &quoted, &signature);
781         assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
782     }
783 }
784 
785 void
check_GetSessionAuditDigest(void ** state)786 check_GetSessionAuditDigest(void **state)
787 {
788     TSS2_RC r;
789     ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
790     enum _ESYS_STATE esys_states[3] = {
791         _ESYS_STATE_INIT,
792         _ESYS_STATE_INTERNALERROR
793     };
794     TPM2B_ATTEST *auditInfo;
795     TPMT_SIGNATURE *signature;
796     for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
797         esys_context->state = esys_states[i];
798         r = Esys_GetSessionAuditDigest_Finish(esys_context,
799                                               &auditInfo, &signature);
800         assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
801     }
802 }
803 
804 void
check_GetCommandAuditDigest(void ** state)805 check_GetCommandAuditDigest(void **state)
806 {
807     TSS2_RC r;
808     ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
809     enum _ESYS_STATE esys_states[3] = {
810         _ESYS_STATE_INIT,
811         _ESYS_STATE_INTERNALERROR
812     };
813     TPM2B_ATTEST *auditInfo;
814     TPMT_SIGNATURE *signature;
815     for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
816         esys_context->state = esys_states[i];
817         r = Esys_GetCommandAuditDigest_Finish(esys_context,
818                                               &auditInfo, &signature);
819         assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
820     }
821 }
822 
823 void
check_GetTime(void ** state)824 check_GetTime(void **state)
825 {
826     TSS2_RC r;
827     ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
828     enum _ESYS_STATE esys_states[3] = {
829         _ESYS_STATE_INIT,
830         _ESYS_STATE_INTERNALERROR
831     };
832     TPM2B_ATTEST *timeInfo;
833     TPMT_SIGNATURE *signature;
834     for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
835         esys_context->state = esys_states[i];
836         r = Esys_GetTime_Finish(esys_context, &timeInfo, &signature);
837         assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
838     }
839 }
840 
841 void
check_Commit(void ** state)842 check_Commit(void **state)
843 {
844     TSS2_RC r;
845     ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
846     enum _ESYS_STATE esys_states[3] = {
847         _ESYS_STATE_INIT,
848         _ESYS_STATE_INTERNALERROR
849     };
850     TPM2B_ECC_POINT *K;
851     TPM2B_ECC_POINT *L;
852     TPM2B_ECC_POINT *E;
853     UINT16 counter;
854     for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
855         esys_context->state = esys_states[i];
856         r = Esys_Commit_Finish(esys_context, &K, &L, &E, &counter);
857         assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
858     }
859 }
860 
861 void
check_EC_Ephemeral(void ** state)862 check_EC_Ephemeral(void **state)
863 {
864     TSS2_RC r;
865     ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
866     enum _ESYS_STATE esys_states[3] = {
867         _ESYS_STATE_INIT,
868         _ESYS_STATE_INTERNALERROR
869     };
870     TPM2B_ECC_POINT *Q;
871     UINT16 counter;
872     for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
873         esys_context->state = esys_states[i];
874         r = Esys_EC_Ephemeral_Finish(esys_context, &Q, &counter);
875         assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
876     }
877 }
878 
879 void
check_VerifySignature(void ** state)880 check_VerifySignature(void **state)
881 {
882     TSS2_RC r;
883     ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
884     enum _ESYS_STATE esys_states[3] = {
885         _ESYS_STATE_INIT,
886         _ESYS_STATE_INTERNALERROR
887     };
888     TPMT_TK_VERIFIED *validation;
889     for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
890         esys_context->state = esys_states[i];
891         r = Esys_VerifySignature_Finish(esys_context, &validation);
892         assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
893     }
894 }
895 
896 void
check_Sign(void ** state)897 check_Sign(void **state)
898 {
899     TSS2_RC r;
900     ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
901     enum _ESYS_STATE esys_states[3] = {
902         _ESYS_STATE_INIT,
903         _ESYS_STATE_INTERNALERROR
904     };
905     TPMT_SIGNATURE *signature;
906     for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
907         esys_context->state = esys_states[i];
908         r = Esys_Sign_Finish(esys_context, &signature);
909         assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
910     }
911 }
912 
913 void
check_SetCommandCodeAuditStatus(void ** state)914 check_SetCommandCodeAuditStatus(void **state)
915 {
916     TSS2_RC r;
917     ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
918     enum _ESYS_STATE esys_states[3] = {
919         _ESYS_STATE_INIT,
920         _ESYS_STATE_INTERNALERROR
921     };
922     for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
923         esys_context->state = esys_states[i];
924         r = Esys_SetCommandCodeAuditStatus_Finish(esys_context);
925         assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
926     }
927 }
928 
929 void
check_PCR_Extend(void ** state)930 check_PCR_Extend(void **state)
931 {
932     TSS2_RC r;
933     ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
934     enum _ESYS_STATE esys_states[3] = {
935         _ESYS_STATE_INIT,
936         _ESYS_STATE_INTERNALERROR
937     };
938     for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
939         esys_context->state = esys_states[i];
940         r = Esys_PCR_Extend_Finish(esys_context);
941         assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
942     }
943 }
944 
945 void
check_PCR_Event(void ** state)946 check_PCR_Event(void **state)
947 {
948     TSS2_RC r;
949     ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
950     enum _ESYS_STATE esys_states[3] = {
951         _ESYS_STATE_INIT,
952         _ESYS_STATE_INTERNALERROR
953     };
954     TPML_DIGEST_VALUES *digests;
955     for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
956         esys_context->state = esys_states[i];
957         r = Esys_PCR_Event_Finish(esys_context, &digests);
958         assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
959     }
960 }
961 
962 void
check_PCR_Read(void ** state)963 check_PCR_Read(void **state)
964 {
965     TSS2_RC r;
966     ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
967     enum _ESYS_STATE esys_states[3] = {
968         _ESYS_STATE_INIT,
969         _ESYS_STATE_INTERNALERROR
970     };
971     TPML_PCR_SELECTION *pcrSelectionOut;
972     TPML_DIGEST *pcrValues;
973     UINT32 pcrUpdateCounter;
974     for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
975         esys_context->state = esys_states[i];
976         r = Esys_PCR_Read_Finish(esys_context,
977                                  &pcrUpdateCounter,
978                                  &pcrSelectionOut, &pcrValues);
979         assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
980     }
981 }
982 
983 void
check_PCR_Allocate(void ** state)984 check_PCR_Allocate(void **state)
985 {
986     TSS2_RC r;
987     ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
988     enum _ESYS_STATE esys_states[3] = {
989         _ESYS_STATE_INIT,
990         _ESYS_STATE_INTERNALERROR
991     };
992     TPMI_YES_NO allocationSuccess;
993     UINT32 maxPCR;
994     UINT32 sizeNeeded;
995     UINT32 sizeAvailable;
996     for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
997         esys_context->state = esys_states[i];
998         r = Esys_PCR_Allocate_Finish(esys_context,
999                                      &allocationSuccess,
1000                                      &maxPCR, &sizeNeeded, &sizeAvailable);
1001         assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
1002     }
1003 }
1004 
1005 void
check_PCR_SetAuthPolicy(void ** state)1006 check_PCR_SetAuthPolicy(void **state)
1007 {
1008     TSS2_RC r;
1009     ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1010     enum _ESYS_STATE esys_states[3] = {
1011         _ESYS_STATE_INIT,
1012         _ESYS_STATE_INTERNALERROR
1013     };
1014     for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
1015         esys_context->state = esys_states[i];
1016         r = Esys_PCR_SetAuthPolicy_Finish(esys_context);
1017         assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
1018     }
1019 }
1020 
1021 void
check_PCR_SetAuthValue(void ** state)1022 check_PCR_SetAuthValue(void **state)
1023 {
1024     TSS2_RC r;
1025     ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1026     enum _ESYS_STATE esys_states[3] = {
1027         _ESYS_STATE_INIT,
1028         _ESYS_STATE_INTERNALERROR
1029     };
1030     for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
1031         esys_context->state = esys_states[i];
1032         r = Esys_PCR_SetAuthValue_Finish(esys_context);
1033         assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
1034     }
1035 }
1036 
1037 void
check_PCR_Reset(void ** state)1038 check_PCR_Reset(void **state)
1039 {
1040     TSS2_RC r;
1041     ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1042     enum _ESYS_STATE esys_states[3] = {
1043         _ESYS_STATE_INIT,
1044         _ESYS_STATE_INTERNALERROR
1045     };
1046     for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
1047         esys_context->state = esys_states[i];
1048         r = Esys_PCR_Reset_Finish(esys_context);
1049         assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
1050     }
1051 }
1052 
1053 void
check_PolicySigned(void ** state)1054 check_PolicySigned(void **state)
1055 {
1056     TSS2_RC r;
1057     ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1058     enum _ESYS_STATE esys_states[3] = {
1059         _ESYS_STATE_INIT,
1060         _ESYS_STATE_INTERNALERROR
1061     };
1062     TPM2B_TIMEOUT *timeout;
1063     TPMT_TK_AUTH *policyTicket;
1064     for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
1065         esys_context->state = esys_states[i];
1066         r = Esys_PolicySigned_Finish(esys_context, &timeout, &policyTicket);
1067         assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
1068     }
1069 }
1070 
1071 void
check_PolicySecret(void ** state)1072 check_PolicySecret(void **state)
1073 {
1074     TSS2_RC r;
1075     ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1076     enum _ESYS_STATE esys_states[3] = {
1077         _ESYS_STATE_INIT,
1078         _ESYS_STATE_INTERNALERROR
1079     };
1080     TPM2B_TIMEOUT *timeout;
1081     TPMT_TK_AUTH *policyTicket;
1082     for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
1083         esys_context->state = esys_states[i];
1084         r = Esys_PolicySecret_Finish(esys_context, &timeout, &policyTicket);
1085         assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
1086     }
1087 }
1088 
1089 void
check_PolicyTicket(void ** state)1090 check_PolicyTicket(void **state)
1091 {
1092     TSS2_RC r;
1093     ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1094     enum _ESYS_STATE esys_states[3] = {
1095         _ESYS_STATE_INIT,
1096         _ESYS_STATE_INTERNALERROR
1097     };
1098     for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
1099         esys_context->state = esys_states[i];
1100         r = Esys_PolicyTicket_Finish(esys_context);
1101         assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
1102     }
1103 }
1104 
1105 void
check_PolicyOR(void ** state)1106 check_PolicyOR(void **state)
1107 {
1108     TSS2_RC r;
1109     ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1110     enum _ESYS_STATE esys_states[3] = {
1111         _ESYS_STATE_INIT,
1112         _ESYS_STATE_INTERNALERROR
1113     };
1114     for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
1115         esys_context->state = esys_states[i];
1116         r = Esys_PolicyOR_Finish(esys_context);
1117         assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
1118     }
1119 }
1120 
1121 void
check_PolicyPCR(void ** state)1122 check_PolicyPCR(void **state)
1123 {
1124     TSS2_RC r;
1125     ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1126     enum _ESYS_STATE esys_states[3] = {
1127         _ESYS_STATE_INIT,
1128         _ESYS_STATE_INTERNALERROR
1129     };
1130     for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
1131         esys_context->state = esys_states[i];
1132         r = Esys_PolicyPCR_Finish(esys_context);
1133         assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
1134     }
1135 }
1136 
1137 void
check_PolicyLocality(void ** state)1138 check_PolicyLocality(void **state)
1139 {
1140     TSS2_RC r;
1141     ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1142     enum _ESYS_STATE esys_states[3] = {
1143         _ESYS_STATE_INIT,
1144         _ESYS_STATE_INTERNALERROR
1145     };
1146     for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
1147         esys_context->state = esys_states[i];
1148         r = Esys_PolicyLocality_Finish(esys_context);
1149         assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
1150     }
1151 }
1152 
1153 void
check_PolicyNV(void ** state)1154 check_PolicyNV(void **state)
1155 {
1156     TSS2_RC r;
1157     ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1158     enum _ESYS_STATE esys_states[3] = {
1159         _ESYS_STATE_INIT,
1160         _ESYS_STATE_INTERNALERROR
1161     };
1162     for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
1163         esys_context->state = esys_states[i];
1164         r = Esys_PolicyNV_Finish(esys_context);
1165         assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
1166     }
1167 }
1168 
1169 void
check_PolicyCounterTimer(void ** state)1170 check_PolicyCounterTimer(void **state)
1171 {
1172     TSS2_RC r;
1173     ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1174     enum _ESYS_STATE esys_states[3] = {
1175         _ESYS_STATE_INIT,
1176         _ESYS_STATE_INTERNALERROR
1177     };
1178     for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
1179         esys_context->state = esys_states[i];
1180         r = Esys_PolicyCounterTimer_Finish(esys_context);
1181         assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
1182     }
1183 }
1184 
1185 void
check_PolicyCommandCode(void ** state)1186 check_PolicyCommandCode(void **state)
1187 {
1188     TSS2_RC r;
1189     ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1190     enum _ESYS_STATE esys_states[3] = {
1191         _ESYS_STATE_INIT,
1192         _ESYS_STATE_INTERNALERROR
1193     };
1194     for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
1195         esys_context->state = esys_states[i];
1196         r = Esys_PolicyCommandCode_Finish(esys_context);
1197         assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
1198     }
1199 }
1200 
1201 void
check_PolicyPhysicalPresence(void ** state)1202 check_PolicyPhysicalPresence(void **state)
1203 {
1204     TSS2_RC r;
1205     ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1206     enum _ESYS_STATE esys_states[3] = {
1207         _ESYS_STATE_INIT,
1208         _ESYS_STATE_INTERNALERROR
1209     };
1210     for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
1211         esys_context->state = esys_states[i];
1212         r = Esys_PolicyPhysicalPresence_Finish(esys_context);
1213         assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
1214     }
1215 }
1216 
1217 void
check_PolicyCpHash(void ** state)1218 check_PolicyCpHash(void **state)
1219 {
1220     TSS2_RC r;
1221     ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1222     enum _ESYS_STATE esys_states[3] = {
1223         _ESYS_STATE_INIT,
1224         _ESYS_STATE_INTERNALERROR
1225     };
1226     for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
1227         esys_context->state = esys_states[i];
1228         r = Esys_PolicyCpHash_Finish(esys_context);
1229         assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
1230     }
1231 }
1232 
1233 void
check_PolicyNameHash(void ** state)1234 check_PolicyNameHash(void **state)
1235 {
1236     TSS2_RC r;
1237     ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1238     enum _ESYS_STATE esys_states[3] = {
1239         _ESYS_STATE_INIT,
1240         _ESYS_STATE_INTERNALERROR
1241     };
1242     for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
1243         esys_context->state = esys_states[i];
1244         r = Esys_PolicyNameHash_Finish(esys_context);
1245         assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
1246     }
1247 }
1248 
1249 void
check_PolicyDuplicationSelect(void ** state)1250 check_PolicyDuplicationSelect(void **state)
1251 {
1252     TSS2_RC r;
1253     ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1254     enum _ESYS_STATE esys_states[3] = {
1255         _ESYS_STATE_INIT,
1256         _ESYS_STATE_INTERNALERROR
1257     };
1258     for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
1259         esys_context->state = esys_states[i];
1260         r = Esys_PolicyDuplicationSelect_Finish(esys_context);
1261         assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
1262     }
1263 }
1264 
1265 void
check_PolicyAuthorize(void ** state)1266 check_PolicyAuthorize(void **state)
1267 {
1268     TSS2_RC r;
1269     ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1270     enum _ESYS_STATE esys_states[3] = {
1271         _ESYS_STATE_INIT,
1272         _ESYS_STATE_INTERNALERROR
1273     };
1274     for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
1275         esys_context->state = esys_states[i];
1276         r = Esys_PolicyAuthorize_Finish(esys_context);
1277         assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
1278     }
1279 }
1280 
1281 void
check_PolicyAuthValue(void ** state)1282 check_PolicyAuthValue(void **state)
1283 {
1284     TSS2_RC r;
1285     ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1286     enum _ESYS_STATE esys_states[3] = {
1287         _ESYS_STATE_INIT,
1288         _ESYS_STATE_INTERNALERROR
1289     };
1290     for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
1291         esys_context->state = esys_states[i];
1292         r = Esys_PolicyAuthValue_Finish(esys_context);
1293         assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
1294     }
1295 }
1296 
1297 void
check_PolicyPassword(void ** state)1298 check_PolicyPassword(void **state)
1299 {
1300     TSS2_RC r;
1301     ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1302     enum _ESYS_STATE esys_states[3] = {
1303         _ESYS_STATE_INIT,
1304         _ESYS_STATE_INTERNALERROR
1305     };
1306     for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
1307         esys_context->state = esys_states[i];
1308         r = Esys_PolicyPassword_Finish(esys_context);
1309         assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
1310     }
1311 }
1312 
1313 void
check_PolicyGetDigest(void ** state)1314 check_PolicyGetDigest(void **state)
1315 {
1316     TSS2_RC r;
1317     ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1318     enum _ESYS_STATE esys_states[3] = {
1319         _ESYS_STATE_INIT,
1320         _ESYS_STATE_INTERNALERROR
1321     };
1322     TPM2B_DIGEST *policyDigest;
1323     for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
1324         esys_context->state = esys_states[i];
1325         r = Esys_PolicyGetDigest_Finish(esys_context, &policyDigest);
1326         assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
1327     }
1328 }
1329 
1330 void
check_PolicyNvWritten(void ** state)1331 check_PolicyNvWritten(void **state)
1332 {
1333     TSS2_RC r;
1334     ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1335     enum _ESYS_STATE esys_states[3] = {
1336         _ESYS_STATE_INIT,
1337         _ESYS_STATE_INTERNALERROR
1338     };
1339     for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
1340         esys_context->state = esys_states[i];
1341         r = Esys_PolicyNvWritten_Finish(esys_context);
1342         assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
1343     }
1344 }
1345 
1346 void
check_PolicyTemplate(void ** state)1347 check_PolicyTemplate(void **state)
1348 {
1349     TSS2_RC r;
1350     ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1351     enum _ESYS_STATE esys_states[3] = {
1352         _ESYS_STATE_INIT,
1353         _ESYS_STATE_INTERNALERROR
1354     };
1355     for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
1356         esys_context->state = esys_states[i];
1357         r = Esys_PolicyTemplate_Finish(esys_context);
1358         assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
1359     }
1360 }
1361 
1362 void
check_PolicyAuthorizeNV(void ** state)1363 check_PolicyAuthorizeNV(void **state)
1364 {
1365     TSS2_RC r;
1366     ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1367     enum _ESYS_STATE esys_states[3] = {
1368         _ESYS_STATE_INIT,
1369         _ESYS_STATE_INTERNALERROR
1370     };
1371     for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
1372         esys_context->state = esys_states[i];
1373         r = Esys_PolicyAuthorizeNV_Finish(esys_context);
1374         assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
1375     }
1376 }
1377 
1378 void
check_CreatePrimary(void ** state)1379 check_CreatePrimary(void **state)
1380 {
1381     TSS2_RC r;
1382     ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1383     enum _ESYS_STATE esys_states[3] = {
1384         _ESYS_STATE_INIT,
1385         _ESYS_STATE_INTERNALERROR
1386     };
1387     ESYS_TR objectHandle_handle;
1388     TPM2B_PUBLIC *outPublic;
1389     TPM2B_CREATION_DATA *creationData;
1390     TPM2B_DIGEST *creationHash;
1391     TPMT_TK_CREATION *creationTicket;
1392     for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
1393         esys_context->state = esys_states[i];
1394         r = Esys_CreatePrimary_Finish(esys_context,
1395                                       &objectHandle_handle,
1396                                       &outPublic,
1397                                       &creationData,
1398                                       &creationHash, &creationTicket);
1399         assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
1400     }
1401 }
1402 
1403 void
check_HierarchyControl(void ** state)1404 check_HierarchyControl(void **state)
1405 {
1406     TSS2_RC r;
1407     ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1408     enum _ESYS_STATE esys_states[3] = {
1409         _ESYS_STATE_INIT,
1410         _ESYS_STATE_INTERNALERROR
1411     };
1412     for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
1413         esys_context->state = esys_states[i];
1414         r = Esys_HierarchyControl_Finish(esys_context);
1415         assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
1416     }
1417 }
1418 
1419 void
check_SetPrimaryPolicy(void ** state)1420 check_SetPrimaryPolicy(void **state)
1421 {
1422     TSS2_RC r;
1423     ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1424     enum _ESYS_STATE esys_states[3] = {
1425         _ESYS_STATE_INIT,
1426         _ESYS_STATE_INTERNALERROR
1427     };
1428     for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
1429         esys_context->state = esys_states[i];
1430         r = Esys_SetPrimaryPolicy_Finish(esys_context);
1431         assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
1432     }
1433 }
1434 
1435 void
check_ChangePPS(void ** state)1436 check_ChangePPS(void **state)
1437 {
1438     TSS2_RC r;
1439     ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1440     enum _ESYS_STATE esys_states[3] = {
1441         _ESYS_STATE_INIT,
1442         _ESYS_STATE_INTERNALERROR
1443     };
1444     for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
1445         esys_context->state = esys_states[i];
1446         r = Esys_ChangePPS_Finish(esys_context);
1447         assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
1448     }
1449 }
1450 
1451 void
check_ChangeEPS(void ** state)1452 check_ChangeEPS(void **state)
1453 {
1454     TSS2_RC r;
1455     ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1456     enum _ESYS_STATE esys_states[3] = {
1457         _ESYS_STATE_INIT,
1458         _ESYS_STATE_INTERNALERROR
1459     };
1460     for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
1461         esys_context->state = esys_states[i];
1462         r = Esys_ChangeEPS_Finish(esys_context);
1463         assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
1464     }
1465 }
1466 
1467 void
check_Clear(void ** state)1468 check_Clear(void **state)
1469 {
1470     TSS2_RC r;
1471     ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1472     enum _ESYS_STATE esys_states[3] = {
1473         _ESYS_STATE_INIT,
1474         _ESYS_STATE_INTERNALERROR
1475     };
1476     for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
1477         esys_context->state = esys_states[i];
1478         r = Esys_Clear_Finish(esys_context);
1479         assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
1480     }
1481 }
1482 
1483 void
check_ClearControl(void ** state)1484 check_ClearControl(void **state)
1485 {
1486     TSS2_RC r;
1487     ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1488     enum _ESYS_STATE esys_states[3] = {
1489         _ESYS_STATE_INIT,
1490         _ESYS_STATE_INTERNALERROR
1491     };
1492     for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
1493         esys_context->state = esys_states[i];
1494         r = Esys_ClearControl_Finish(esys_context);
1495         assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
1496     }
1497 }
1498 
1499 void
check_HierarchyChangeAuth(void ** state)1500 check_HierarchyChangeAuth(void **state)
1501 {
1502     TSS2_RC r;
1503     ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1504     enum _ESYS_STATE esys_states[3] = {
1505         _ESYS_STATE_INIT,
1506         _ESYS_STATE_INTERNALERROR
1507     };
1508     for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
1509         esys_context->state = esys_states[i];
1510         r = Esys_HierarchyChangeAuth_Finish(esys_context);
1511         assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
1512     }
1513 }
1514 
1515 void
check_DictionaryAttackLockReset(void ** state)1516 check_DictionaryAttackLockReset(void **state)
1517 {
1518     TSS2_RC r;
1519     ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1520     enum _ESYS_STATE esys_states[3] = {
1521         _ESYS_STATE_INIT,
1522         _ESYS_STATE_INTERNALERROR
1523     };
1524     for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
1525         esys_context->state = esys_states[i];
1526         r = Esys_DictionaryAttackLockReset_Finish(esys_context);
1527         assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
1528     }
1529 }
1530 
1531 void
check_DictionaryAttackParameters(void ** state)1532 check_DictionaryAttackParameters(void **state)
1533 {
1534     TSS2_RC r;
1535     ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1536     enum _ESYS_STATE esys_states[3] = {
1537         _ESYS_STATE_INIT,
1538         _ESYS_STATE_INTERNALERROR
1539     };
1540     for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
1541         esys_context->state = esys_states[i];
1542         r = Esys_DictionaryAttackParameters_Finish(esys_context);
1543         assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
1544     }
1545 }
1546 
1547 void
check_PP_Commands(void ** state)1548 check_PP_Commands(void **state)
1549 {
1550     TSS2_RC r;
1551     ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1552     enum _ESYS_STATE esys_states[3] = {
1553         _ESYS_STATE_INIT,
1554         _ESYS_STATE_INTERNALERROR
1555     };
1556     for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
1557         esys_context->state = esys_states[i];
1558         r = Esys_PP_Commands_Finish(esys_context);
1559         assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
1560     }
1561 }
1562 
1563 void
check_SetAlgorithmSet(void ** state)1564 check_SetAlgorithmSet(void **state)
1565 {
1566     TSS2_RC r;
1567     ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1568     enum _ESYS_STATE esys_states[3] = {
1569         _ESYS_STATE_INIT,
1570         _ESYS_STATE_INTERNALERROR
1571     };
1572     for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
1573         esys_context->state = esys_states[i];
1574         r = Esys_SetAlgorithmSet_Finish(esys_context);
1575         assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
1576     }
1577 }
1578 
1579 void
check_FieldUpgradeStart(void ** state)1580 check_FieldUpgradeStart(void **state)
1581 {
1582     TSS2_RC r;
1583     ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1584     enum _ESYS_STATE esys_states[3] = {
1585         _ESYS_STATE_INIT,
1586         _ESYS_STATE_INTERNALERROR
1587     };
1588     for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
1589         esys_context->state = esys_states[i];
1590         r = Esys_FieldUpgradeStart_Finish(esys_context);
1591         assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
1592     }
1593 }
1594 
1595 void
check_FieldUpgradeData(void ** state)1596 check_FieldUpgradeData(void **state)
1597 {
1598     TSS2_RC r;
1599     ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1600     enum _ESYS_STATE esys_states[3] = {
1601         _ESYS_STATE_INIT,
1602         _ESYS_STATE_INTERNALERROR
1603     };
1604     TPMT_HA *nextDigest;
1605     TPMT_HA *firstDigest;
1606     for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
1607         esys_context->state = esys_states[i];
1608         r = Esys_FieldUpgradeData_Finish(esys_context,
1609                                          &nextDigest, &firstDigest);
1610         assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
1611     }
1612 }
1613 
1614 void
check_FirmwareRead(void ** state)1615 check_FirmwareRead(void **state)
1616 {
1617     TSS2_RC r;
1618     ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1619     enum _ESYS_STATE esys_states[3] = {
1620         _ESYS_STATE_INIT,
1621         _ESYS_STATE_INTERNALERROR
1622     };
1623     TPM2B_MAX_BUFFER *fuData;
1624     for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
1625         esys_context->state = esys_states[i];
1626         r = Esys_FirmwareRead_Finish(esys_context, &fuData);
1627         assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
1628     }
1629 }
1630 
1631 void
check_ContextSave(void ** state)1632 check_ContextSave(void **state)
1633 {
1634     TSS2_RC r;
1635     ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1636     enum _ESYS_STATE esys_states[3] = {
1637         _ESYS_STATE_INIT,
1638         _ESYS_STATE_INTERNALERROR
1639     };
1640     TPMS_CONTEXT *context;
1641     for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
1642         esys_context->state = esys_states[i];
1643         r = Esys_ContextSave_Finish(esys_context, &context);
1644         assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
1645     }
1646 }
1647 
1648 void
check_ContextLoad(void ** state)1649 check_ContextLoad(void **state)
1650 {
1651     TSS2_RC r;
1652     ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1653     enum _ESYS_STATE esys_states[3] = {
1654         _ESYS_STATE_INIT,
1655         _ESYS_STATE_INTERNALERROR
1656     };
1657     ESYS_TR loadedHandle_handle;
1658     for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
1659         esys_context->state = esys_states[i];
1660         r = Esys_ContextLoad_Finish(esys_context, &loadedHandle_handle);
1661         assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
1662     }
1663 }
1664 
1665 void
check_FlushContext(void ** state)1666 check_FlushContext(void **state)
1667 {
1668     TSS2_RC r;
1669     ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1670     enum _ESYS_STATE esys_states[3] = {
1671         _ESYS_STATE_INIT,
1672         _ESYS_STATE_INTERNALERROR
1673     };
1674     for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
1675         esys_context->state = esys_states[i];
1676         r = Esys_FlushContext_Finish(esys_context);
1677         assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
1678     }
1679 }
1680 
1681 void
check_EvictControl(void ** state)1682 check_EvictControl(void **state)
1683 {
1684     TSS2_RC r;
1685     ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1686     enum _ESYS_STATE esys_states[3] = {
1687         _ESYS_STATE_INIT,
1688         _ESYS_STATE_INTERNALERROR
1689     };
1690     ESYS_TR newObjectHandle_handle;
1691     for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
1692         esys_context->state = esys_states[i];
1693         r = Esys_EvictControl_Finish(esys_context, &newObjectHandle_handle);
1694         assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
1695     }
1696 }
1697 
1698 void
check_ReadClock(void ** state)1699 check_ReadClock(void **state)
1700 {
1701     TSS2_RC r;
1702     ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1703     enum _ESYS_STATE esys_states[3] = {
1704         _ESYS_STATE_INIT,
1705         _ESYS_STATE_INTERNALERROR
1706     };
1707     TPMS_TIME_INFO *currentTime;
1708     for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
1709         esys_context->state = esys_states[i];
1710         r = Esys_ReadClock_Finish(esys_context, &currentTime);
1711         assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
1712     }
1713 }
1714 
1715 void
check_ClockSet(void ** state)1716 check_ClockSet(void **state)
1717 {
1718     TSS2_RC r;
1719     ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1720     enum _ESYS_STATE esys_states[3] = {
1721         _ESYS_STATE_INIT,
1722         _ESYS_STATE_INTERNALERROR
1723     };
1724     for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
1725         esys_context->state = esys_states[i];
1726         r = Esys_ClockSet_Finish(esys_context);
1727         assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
1728     }
1729 }
1730 
1731 void
check_ClockRateAdjust(void ** state)1732 check_ClockRateAdjust(void **state)
1733 {
1734     TSS2_RC r;
1735     ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1736     enum _ESYS_STATE esys_states[3] = {
1737         _ESYS_STATE_INIT,
1738         _ESYS_STATE_INTERNALERROR
1739     };
1740     for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
1741         esys_context->state = esys_states[i];
1742         r = Esys_ClockRateAdjust_Finish(esys_context);
1743         assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
1744     }
1745 }
1746 
1747 void
check_GetCapability(void ** state)1748 check_GetCapability(void **state)
1749 {
1750     TSS2_RC r;
1751     ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1752     enum _ESYS_STATE esys_states[3] = {
1753         _ESYS_STATE_INIT,
1754         _ESYS_STATE_INTERNALERROR
1755     };
1756     TPMS_CAPABILITY_DATA *capabilityData;
1757     TPMI_YES_NO moreData;
1758     for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
1759         esys_context->state = esys_states[i];
1760         r = Esys_GetCapability_Finish(esys_context, &moreData, &capabilityData);
1761         assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
1762     }
1763 }
1764 
1765 void
check_TestParms(void ** state)1766 check_TestParms(void **state)
1767 {
1768     TSS2_RC r;
1769     ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1770     enum _ESYS_STATE esys_states[3] = {
1771         _ESYS_STATE_INIT,
1772         _ESYS_STATE_INTERNALERROR
1773     };
1774     for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
1775         esys_context->state = esys_states[i];
1776         r = Esys_TestParms_Finish(esys_context);
1777         assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
1778     }
1779 }
1780 
1781 void
check_NV_DefineSpace(void ** state)1782 check_NV_DefineSpace(void **state)
1783 {
1784     TSS2_RC r;
1785     ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1786     enum _ESYS_STATE esys_states[3] = {
1787         _ESYS_STATE_INIT,
1788         _ESYS_STATE_INTERNALERROR
1789     };
1790     ESYS_TR nvHandle_handle;
1791     for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
1792         esys_context->state = esys_states[i];
1793         r = Esys_NV_DefineSpace_Finish(esys_context, &nvHandle_handle);
1794         assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
1795     }
1796 }
1797 
1798 void
check_NV_UndefineSpace(void ** state)1799 check_NV_UndefineSpace(void **state)
1800 {
1801     TSS2_RC r;
1802     ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1803     enum _ESYS_STATE esys_states[3] = {
1804         _ESYS_STATE_INIT,
1805         _ESYS_STATE_INTERNALERROR
1806     };
1807     for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
1808         esys_context->state = esys_states[i];
1809         r = Esys_NV_UndefineSpace_Finish(esys_context);
1810         assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
1811     }
1812 }
1813 
1814 void
check_NV_UndefineSpaceSpecial(void ** state)1815 check_NV_UndefineSpaceSpecial(void **state)
1816 {
1817     TSS2_RC r;
1818     ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1819     enum _ESYS_STATE esys_states[3] = {
1820         _ESYS_STATE_INIT,
1821         _ESYS_STATE_INTERNALERROR
1822     };
1823     for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
1824         esys_context->state = esys_states[i];
1825         r = Esys_NV_UndefineSpaceSpecial_Finish(esys_context);
1826         assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
1827     }
1828 }
1829 
1830 void
check_NV_ReadPublic(void ** state)1831 check_NV_ReadPublic(void **state)
1832 {
1833     TSS2_RC r;
1834     ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1835     enum _ESYS_STATE esys_states[3] = {
1836         _ESYS_STATE_INIT,
1837         _ESYS_STATE_INTERNALERROR
1838     };
1839     TPM2B_NV_PUBLIC *nvPublic;
1840     TPM2B_NAME *nvName;
1841     for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
1842         esys_context->state = esys_states[i];
1843         r = Esys_NV_ReadPublic_Finish(esys_context, &nvPublic, &nvName);
1844         assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
1845     }
1846 }
1847 
1848 void
check_NV_Write(void ** state)1849 check_NV_Write(void **state)
1850 {
1851     TSS2_RC r;
1852     ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1853     enum _ESYS_STATE esys_states[3] = {
1854         _ESYS_STATE_INIT,
1855         _ESYS_STATE_INTERNALERROR
1856     };
1857     for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
1858         esys_context->state = esys_states[i];
1859         r = Esys_NV_Write_Finish(esys_context);
1860         assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
1861     }
1862 }
1863 
1864 void
check_NV_Increment(void ** state)1865 check_NV_Increment(void **state)
1866 {
1867     TSS2_RC r;
1868     ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1869     enum _ESYS_STATE esys_states[3] = {
1870         _ESYS_STATE_INIT,
1871         _ESYS_STATE_INTERNALERROR
1872     };
1873     for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
1874         esys_context->state = esys_states[i];
1875         r = Esys_NV_Increment_Finish(esys_context);
1876         assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
1877     }
1878 }
1879 
1880 void
check_NV_Extend(void ** state)1881 check_NV_Extend(void **state)
1882 {
1883     TSS2_RC r;
1884     ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1885     enum _ESYS_STATE esys_states[3] = {
1886         _ESYS_STATE_INIT,
1887         _ESYS_STATE_INTERNALERROR
1888     };
1889     for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
1890         esys_context->state = esys_states[i];
1891         r = Esys_NV_Extend_Finish(esys_context);
1892         assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
1893     }
1894 }
1895 
1896 void
check_NV_SetBits(void ** state)1897 check_NV_SetBits(void **state)
1898 {
1899     TSS2_RC r;
1900     ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1901     enum _ESYS_STATE esys_states[3] = {
1902         _ESYS_STATE_INIT,
1903         _ESYS_STATE_INTERNALERROR
1904     };
1905     for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
1906         esys_context->state = esys_states[i];
1907         r = Esys_NV_SetBits_Finish(esys_context);
1908         assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
1909     }
1910 }
1911 
1912 void
check_NV_WriteLock(void ** state)1913 check_NV_WriteLock(void **state)
1914 {
1915     TSS2_RC r;
1916     ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1917     enum _ESYS_STATE esys_states[3] = {
1918         _ESYS_STATE_INIT,
1919         _ESYS_STATE_INTERNALERROR
1920     };
1921     for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
1922         esys_context->state = esys_states[i];
1923         r = Esys_NV_WriteLock_Finish(esys_context);
1924         assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
1925     }
1926 }
1927 
1928 void
check_NV_GlobalWriteLock(void ** state)1929 check_NV_GlobalWriteLock(void **state)
1930 {
1931     TSS2_RC r;
1932     ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1933     enum _ESYS_STATE esys_states[3] = {
1934         _ESYS_STATE_INIT,
1935         _ESYS_STATE_INTERNALERROR
1936     };
1937     for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
1938         esys_context->state = esys_states[i];
1939         r = Esys_NV_GlobalWriteLock_Finish(esys_context);
1940         assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
1941     }
1942 }
1943 
1944 void
check_NV_Read(void ** state)1945 check_NV_Read(void **state)
1946 {
1947     TSS2_RC r;
1948     ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1949     enum _ESYS_STATE esys_states[3] = {
1950         _ESYS_STATE_INIT,
1951         _ESYS_STATE_INTERNALERROR
1952     };
1953     TPM2B_MAX_NV_BUFFER *data;
1954     for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
1955         esys_context->state = esys_states[i];
1956         r = Esys_NV_Read_Finish(esys_context, &data);
1957         assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
1958     }
1959 }
1960 
1961 void
check_NV_ReadLock(void ** state)1962 check_NV_ReadLock(void **state)
1963 {
1964     TSS2_RC r;
1965     ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1966     enum _ESYS_STATE esys_states[3] = {
1967         _ESYS_STATE_INIT,
1968         _ESYS_STATE_INTERNALERROR
1969     };
1970     for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
1971         esys_context->state = esys_states[i];
1972         r = Esys_NV_ReadLock_Finish(esys_context);
1973         assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
1974     }
1975 }
1976 
1977 void
check_NV_ChangeAuth(void ** state)1978 check_NV_ChangeAuth(void **state)
1979 {
1980     TSS2_RC r;
1981     ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1982     enum _ESYS_STATE esys_states[3] = {
1983         _ESYS_STATE_INIT,
1984         _ESYS_STATE_INTERNALERROR
1985     };
1986     for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
1987         esys_context->state = esys_states[i];
1988         r = Esys_NV_ChangeAuth_Finish(esys_context);
1989         assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
1990     }
1991 }
1992 
1993 void
check_NV_Certify(void ** state)1994 check_NV_Certify(void **state)
1995 {
1996     TSS2_RC r;
1997     ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
1998     enum _ESYS_STATE esys_states[3] = {
1999         _ESYS_STATE_INIT,
2000         _ESYS_STATE_INTERNALERROR
2001     };
2002     TPM2B_ATTEST *certifyInfo;
2003     TPMT_SIGNATURE *signature;
2004     for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
2005         esys_context->state = esys_states[i];
2006         r = Esys_NV_Certify_Finish(esys_context, &certifyInfo, &signature);
2007         assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
2008     }
2009 }
2010 
2011 void
check_Vendor_TCG_Test(void ** state)2012 check_Vendor_TCG_Test(void **state)
2013 {
2014     TSS2_RC r;
2015     ESYS_CONTEXT *esys_context = (ESYS_CONTEXT *) * state;
2016     enum _ESYS_STATE esys_states[3] = {
2017         _ESYS_STATE_INIT,
2018         _ESYS_STATE_INTERNALERROR
2019     };
2020     TPM2B_DATA *outputData;
2021     for (size_t i = 0; i < sizeof(esys_states) / sizeof(esys_states[0]); i++) {
2022         esys_context->state = esys_states[i];
2023         r = Esys_Vendor_TCG_Test_Finish(esys_context, &outputData);
2024         assert_int_equal(r, TSS2_ESYS_RC_BAD_SEQUENCE);
2025     }
2026 }
2027 
2028 int
main(void)2029 main(void)
2030 {
2031     const struct CMUnitTest tests[] = {
2032         cmocka_unit_test_setup_teardown(check_Startup, esys_unit_setup,
2033                                         esys_unit_teardown),
2034         cmocka_unit_test_setup_teardown(check_Shutdown, esys_unit_setup,
2035                                         esys_unit_teardown),
2036         cmocka_unit_test_setup_teardown(check_SelfTest, esys_unit_setup,
2037                                         esys_unit_teardown),
2038         cmocka_unit_test_setup_teardown(check_IncrementalSelfTest,
2039                                         esys_unit_setup, esys_unit_teardown),
2040         cmocka_unit_test_setup_teardown(check_GetTestResult, esys_unit_setup,
2041                                         esys_unit_teardown),
2042         cmocka_unit_test_setup_teardown(check_StartAuthSession, esys_unit_setup,
2043                                         esys_unit_teardown),
2044         cmocka_unit_test_setup_teardown(check_PolicyRestart, esys_unit_setup,
2045                                         esys_unit_teardown),
2046         cmocka_unit_test_setup_teardown(check_Create, esys_unit_setup,
2047                                         esys_unit_teardown),
2048         cmocka_unit_test_setup_teardown(check_Load, esys_unit_setup,
2049                                         esys_unit_teardown),
2050         cmocka_unit_test_setup_teardown(check_LoadExternal, esys_unit_setup,
2051                                         esys_unit_teardown),
2052         cmocka_unit_test_setup_teardown(check_ReadPublic, esys_unit_setup,
2053                                         esys_unit_teardown),
2054         cmocka_unit_test_setup_teardown(check_ActivateCredential,
2055                                         esys_unit_setup, esys_unit_teardown),
2056         cmocka_unit_test_setup_teardown(check_MakeCredential, esys_unit_setup,
2057                                         esys_unit_teardown),
2058         cmocka_unit_test_setup_teardown(check_Unseal, esys_unit_setup,
2059                                         esys_unit_teardown),
2060         cmocka_unit_test_setup_teardown(check_ObjectChangeAuth, esys_unit_setup,
2061                                         esys_unit_teardown),
2062         cmocka_unit_test_setup_teardown(check_CreateLoaded, esys_unit_setup,
2063                                         esys_unit_teardown),
2064         cmocka_unit_test_setup_teardown(check_Duplicate, esys_unit_setup,
2065                                         esys_unit_teardown),
2066         cmocka_unit_test_setup_teardown(check_Rewrap, esys_unit_setup,
2067                                         esys_unit_teardown),
2068         cmocka_unit_test_setup_teardown(check_Import, esys_unit_setup,
2069                                         esys_unit_teardown),
2070         cmocka_unit_test_setup_teardown(check_RSA_Encrypt, esys_unit_setup,
2071                                         esys_unit_teardown),
2072         cmocka_unit_test_setup_teardown(check_RSA_Decrypt, esys_unit_setup,
2073                                         esys_unit_teardown),
2074         cmocka_unit_test_setup_teardown(check_ECDH_KeyGen, esys_unit_setup,
2075                                         esys_unit_teardown),
2076         cmocka_unit_test_setup_teardown(check_ECDH_ZGen, esys_unit_setup,
2077                                         esys_unit_teardown),
2078         cmocka_unit_test_setup_teardown(check_ECC_Parameters, esys_unit_setup,
2079                                         esys_unit_teardown),
2080         cmocka_unit_test_setup_teardown(check_ZGen_2Phase, esys_unit_setup,
2081                                         esys_unit_teardown),
2082         cmocka_unit_test_setup_teardown(check_EncryptDecrypt, esys_unit_setup,
2083                                         esys_unit_teardown),
2084         cmocka_unit_test_setup_teardown(check_EncryptDecrypt2, esys_unit_setup,
2085                                         esys_unit_teardown),
2086         cmocka_unit_test_setup_teardown(check_Hash, esys_unit_setup,
2087                                         esys_unit_teardown),
2088         cmocka_unit_test_setup_teardown(check_HMAC, esys_unit_setup,
2089                                         esys_unit_teardown),
2090         cmocka_unit_test_setup_teardown(check_GetRandom, esys_unit_setup,
2091                                         esys_unit_teardown),
2092         cmocka_unit_test_setup_teardown(check_StirRandom, esys_unit_setup,
2093                                         esys_unit_teardown),
2094         cmocka_unit_test_setup_teardown(check_HMAC_Start, esys_unit_setup,
2095                                         esys_unit_teardown),
2096         cmocka_unit_test_setup_teardown(check_HashSequenceStart,
2097                                         esys_unit_setup, esys_unit_teardown),
2098         cmocka_unit_test_setup_teardown(check_SequenceUpdate, esys_unit_setup,
2099                                         esys_unit_teardown),
2100         cmocka_unit_test_setup_teardown(check_SequenceComplete, esys_unit_setup,
2101                                         esys_unit_teardown),
2102         cmocka_unit_test_setup_teardown(check_EventSequenceComplete,
2103                                         esys_unit_setup, esys_unit_teardown),
2104         cmocka_unit_test_setup_teardown(check_Certify, esys_unit_setup,
2105                                         esys_unit_teardown),
2106         cmocka_unit_test_setup_teardown(check_CertifyCreation, esys_unit_setup,
2107                                         esys_unit_teardown),
2108         cmocka_unit_test_setup_teardown(check_Quote, esys_unit_setup,
2109                                         esys_unit_teardown),
2110         cmocka_unit_test_setup_teardown(check_GetSessionAuditDigest,
2111                                         esys_unit_setup, esys_unit_teardown),
2112         cmocka_unit_test_setup_teardown(check_GetCommandAuditDigest,
2113                                         esys_unit_setup, esys_unit_teardown),
2114         cmocka_unit_test_setup_teardown(check_GetTime, esys_unit_setup,
2115                                         esys_unit_teardown),
2116         cmocka_unit_test_setup_teardown(check_Commit, esys_unit_setup,
2117                                         esys_unit_teardown),
2118         cmocka_unit_test_setup_teardown(check_EC_Ephemeral, esys_unit_setup,
2119                                         esys_unit_teardown),
2120         cmocka_unit_test_setup_teardown(check_VerifySignature, esys_unit_setup,
2121                                         esys_unit_teardown),
2122         cmocka_unit_test_setup_teardown(check_Sign, esys_unit_setup,
2123                                         esys_unit_teardown),
2124         cmocka_unit_test_setup_teardown(check_SetCommandCodeAuditStatus,
2125                                         esys_unit_setup, esys_unit_teardown),
2126         cmocka_unit_test_setup_teardown(check_PCR_Extend, esys_unit_setup,
2127                                         esys_unit_teardown),
2128         cmocka_unit_test_setup_teardown(check_PCR_Event, esys_unit_setup,
2129                                         esys_unit_teardown),
2130         cmocka_unit_test_setup_teardown(check_PCR_Read, esys_unit_setup,
2131                                         esys_unit_teardown),
2132         cmocka_unit_test_setup_teardown(check_PCR_Allocate, esys_unit_setup,
2133                                         esys_unit_teardown),
2134         cmocka_unit_test_setup_teardown(check_PCR_SetAuthPolicy,
2135                                         esys_unit_setup, esys_unit_teardown),
2136         cmocka_unit_test_setup_teardown(check_PCR_SetAuthValue, esys_unit_setup,
2137                                         esys_unit_teardown),
2138         cmocka_unit_test_setup_teardown(check_PCR_Reset, esys_unit_setup,
2139                                         esys_unit_teardown),
2140         cmocka_unit_test_setup_teardown(check_PolicySigned, esys_unit_setup,
2141                                         esys_unit_teardown),
2142         cmocka_unit_test_setup_teardown(check_PolicySecret, esys_unit_setup,
2143                                         esys_unit_teardown),
2144         cmocka_unit_test_setup_teardown(check_PolicyTicket, esys_unit_setup,
2145                                         esys_unit_teardown),
2146         cmocka_unit_test_setup_teardown(check_PolicyOR, esys_unit_setup,
2147                                         esys_unit_teardown),
2148         cmocka_unit_test_setup_teardown(check_PolicyPCR, esys_unit_setup,
2149                                         esys_unit_teardown),
2150         cmocka_unit_test_setup_teardown(check_PolicyLocality, esys_unit_setup,
2151                                         esys_unit_teardown),
2152         cmocka_unit_test_setup_teardown(check_PolicyNV, esys_unit_setup,
2153                                         esys_unit_teardown),
2154         cmocka_unit_test_setup_teardown(check_PolicyCounterTimer,
2155                                         esys_unit_setup, esys_unit_teardown),
2156         cmocka_unit_test_setup_teardown(check_PolicyCommandCode,
2157                                         esys_unit_setup, esys_unit_teardown),
2158         cmocka_unit_test_setup_teardown(check_PolicyPhysicalPresence,
2159                                         esys_unit_setup, esys_unit_teardown),
2160         cmocka_unit_test_setup_teardown(check_PolicyCpHash, esys_unit_setup,
2161                                         esys_unit_teardown),
2162         cmocka_unit_test_setup_teardown(check_PolicyNameHash, esys_unit_setup,
2163                                         esys_unit_teardown),
2164         cmocka_unit_test_setup_teardown(check_PolicyDuplicationSelect,
2165                                         esys_unit_setup, esys_unit_teardown),
2166         cmocka_unit_test_setup_teardown(check_PolicyAuthorize, esys_unit_setup,
2167                                         esys_unit_teardown),
2168         cmocka_unit_test_setup_teardown(check_PolicyAuthValue, esys_unit_setup,
2169                                         esys_unit_teardown),
2170         cmocka_unit_test_setup_teardown(check_PolicyPassword, esys_unit_setup,
2171                                         esys_unit_teardown),
2172         cmocka_unit_test_setup_teardown(check_PolicyGetDigest, esys_unit_setup,
2173                                         esys_unit_teardown),
2174         cmocka_unit_test_setup_teardown(check_PolicyNvWritten, esys_unit_setup,
2175                                         esys_unit_teardown),
2176         cmocka_unit_test_setup_teardown(check_PolicyTemplate, esys_unit_setup,
2177                                         esys_unit_teardown),
2178         cmocka_unit_test_setup_teardown(check_PolicyAuthorizeNV,
2179                                         esys_unit_setup, esys_unit_teardown),
2180         cmocka_unit_test_setup_teardown(check_CreatePrimary, esys_unit_setup,
2181                                         esys_unit_teardown),
2182         cmocka_unit_test_setup_teardown(check_HierarchyControl, esys_unit_setup,
2183                                         esys_unit_teardown),
2184         cmocka_unit_test_setup_teardown(check_SetPrimaryPolicy, esys_unit_setup,
2185                                         esys_unit_teardown),
2186         cmocka_unit_test_setup_teardown(check_ChangePPS, esys_unit_setup,
2187                                         esys_unit_teardown),
2188         cmocka_unit_test_setup_teardown(check_ChangeEPS, esys_unit_setup,
2189                                         esys_unit_teardown),
2190         cmocka_unit_test_setup_teardown(check_Clear, esys_unit_setup,
2191                                         esys_unit_teardown),
2192         cmocka_unit_test_setup_teardown(check_ClearControl, esys_unit_setup,
2193                                         esys_unit_teardown),
2194         cmocka_unit_test_setup_teardown(check_HierarchyChangeAuth,
2195                                         esys_unit_setup, esys_unit_teardown),
2196         cmocka_unit_test_setup_teardown(check_DictionaryAttackLockReset,
2197                                         esys_unit_setup, esys_unit_teardown),
2198         cmocka_unit_test_setup_teardown(check_DictionaryAttackParameters,
2199                                         esys_unit_setup, esys_unit_teardown),
2200         cmocka_unit_test_setup_teardown(check_PP_Commands, esys_unit_setup,
2201                                         esys_unit_teardown),
2202         cmocka_unit_test_setup_teardown(check_SetAlgorithmSet, esys_unit_setup,
2203                                         esys_unit_teardown),
2204         cmocka_unit_test_setup_teardown(check_FieldUpgradeStart,
2205                                         esys_unit_setup, esys_unit_teardown),
2206         cmocka_unit_test_setup_teardown(check_FieldUpgradeData, esys_unit_setup,
2207                                         esys_unit_teardown),
2208         cmocka_unit_test_setup_teardown(check_FirmwareRead, esys_unit_setup,
2209                                         esys_unit_teardown),
2210         cmocka_unit_test_setup_teardown(check_ContextSave, esys_unit_setup,
2211                                         esys_unit_teardown),
2212         cmocka_unit_test_setup_teardown(check_ContextLoad, esys_unit_setup,
2213                                         esys_unit_teardown),
2214         cmocka_unit_test_setup_teardown(check_FlushContext, esys_unit_setup,
2215                                         esys_unit_teardown),
2216         cmocka_unit_test_setup_teardown(check_EvictControl, esys_unit_setup,
2217                                         esys_unit_teardown),
2218         cmocka_unit_test_setup_teardown(check_ReadClock, esys_unit_setup,
2219                                         esys_unit_teardown),
2220         cmocka_unit_test_setup_teardown(check_ClockSet, esys_unit_setup,
2221                                         esys_unit_teardown),
2222         cmocka_unit_test_setup_teardown(check_ClockRateAdjust, esys_unit_setup,
2223                                         esys_unit_teardown),
2224         cmocka_unit_test_setup_teardown(check_GetCapability, esys_unit_setup,
2225                                         esys_unit_teardown),
2226         cmocka_unit_test_setup_teardown(check_TestParms, esys_unit_setup,
2227                                         esys_unit_teardown),
2228         cmocka_unit_test_setup_teardown(check_NV_DefineSpace, esys_unit_setup,
2229                                         esys_unit_teardown),
2230         cmocka_unit_test_setup_teardown(check_NV_UndefineSpace, esys_unit_setup,
2231                                         esys_unit_teardown),
2232         cmocka_unit_test_setup_teardown(check_NV_UndefineSpaceSpecial,
2233                                         esys_unit_setup, esys_unit_teardown),
2234         cmocka_unit_test_setup_teardown(check_NV_ReadPublic, esys_unit_setup,
2235                                         esys_unit_teardown),
2236         cmocka_unit_test_setup_teardown(check_NV_Write, esys_unit_setup,
2237                                         esys_unit_teardown),
2238         cmocka_unit_test_setup_teardown(check_NV_Increment, esys_unit_setup,
2239                                         esys_unit_teardown),
2240         cmocka_unit_test_setup_teardown(check_NV_Extend, esys_unit_setup,
2241                                         esys_unit_teardown),
2242         cmocka_unit_test_setup_teardown(check_NV_SetBits, esys_unit_setup,
2243                                         esys_unit_teardown),
2244         cmocka_unit_test_setup_teardown(check_NV_WriteLock, esys_unit_setup,
2245                                         esys_unit_teardown),
2246         cmocka_unit_test_setup_teardown(check_NV_GlobalWriteLock,
2247                                         esys_unit_setup, esys_unit_teardown),
2248         cmocka_unit_test_setup_teardown(check_NV_Read, esys_unit_setup,
2249                                         esys_unit_teardown),
2250         cmocka_unit_test_setup_teardown(check_NV_ReadLock, esys_unit_setup,
2251                                         esys_unit_teardown),
2252         cmocka_unit_test_setup_teardown(check_NV_ChangeAuth, esys_unit_setup,
2253                                         esys_unit_teardown),
2254         cmocka_unit_test_setup_teardown(check_NV_Certify, esys_unit_setup,
2255                                         esys_unit_teardown),
2256         cmocka_unit_test_setup_teardown(check_Vendor_TCG_Test, esys_unit_setup,
2257                                         esys_unit_teardown),
2258     };
2259     return cmocka_run_group_tests(tests, NULL, NULL);
2260 }
2261