Fixes some causes for type ambiguity in tests.

- Many of tests uses macro to create the test code and in this
  test code it is common practice to use ```into``` or
  ```try_into``` conversions. But this can cause ambiguities later
  on if new types introduced implements traits that previously only
  was implemented by one type. So in order to avoid this kind of
  ambiguity some of the conversions have been changed. This only
  a first step of changes that probably needs to be done. This fixes
  the errors that occurs if one tries to add ```serde_json``` to the
  ```cargo.yaml``` which is probably needed in order to be able to
  write tests for #466.

Signed-off-by: Jesper Brynolf <jesper.brynolf@gmail.com>

Author: Superhepper

tss-esapi/src/lib.rs

@@ -9,7 +9,8 @@
     overflowing_literals,
     path_statements,
     patterns_in_fns_without_body,
-    private_in_public,
+    private_bounds,
+    private_interfaces,
     unconditional_recursion,
     unused,
     unused_allocation,

tss-esapi/tests/integration_tests/attributes_tests/command_code_attributes_tests.rs

@@ -92,7 +92,7 @@ fn test_conversions_non_vendor_specific() {
 
     assert_eq!(
         expected.0,
-        command_code_attributes.into(),
+        TPMA_CC::from(command_code_attributes),
         "CommandCodeAttributes did not convert into the expected TPMA_CC value"
     );
 }
@@ -162,7 +162,7 @@ fn test_conversions_vendor_specific() {
 
     assert_eq!(
         expected.0,
-        command_code_attributes.into(),
+        TPMA_CC::from(command_code_attributes),
         "CommandCodeAttributes did not convert into the expected TPMA_CC value"
     );
 }
@@ -307,7 +307,7 @@ fn test_builder() {
 
     assert_eq!(
             expected.0,
-            actual.into(),
+            TPMA_CC::from(actual),
             "CommandCodeAttributes built using the builder did not convert into the expected TPMA_CC value"
     );
 }

tss-esapi/tests/integration_tests/attributes_tests/session_attributes_tests.rs

@@ -1,6 +1,6 @@
 // Copyright 2022 Contributors to the Parsec project.
 // SPDX-License-Identifier: Apache-2.0
-use std::convert::{TryFrom, TryInto};
+use std::convert::TryFrom;
 use tss_esapi::{
     attributes::{SessionAttributes, SessionAttributesBuilder, SessionAttributesMask},
     tss2_esys::TPMA_SESSION,
@@ -18,7 +18,7 @@ macro_rules! test_valid_conversion {
         );
         assert_eq!(
             tpma_session,
-            session_attributes.try_into().expect("Failed to convert SessionAttributes into TPMA_SESSION_ATTRIBUTE."),
+            TPMA_SESSION::try_from(session_attributes).expect("Failed to convert SessionAttributes into TPMA_SESSION_ATTRIBUTE."),
             "Converting session attributes with {} set did not convert into the expected TPMA_SESSION value", std::stringify!($method),
         );
     };
@@ -30,7 +30,7 @@ macro_rules! test_valid_mask_conversion {
         let session_attributes_mask = SessionAttributesMask::try_from(tpma_session).expect("Failed to convert TPMA_SESSION into SessionAttributesMask");
         assert_eq!(
             tpma_session,
-            session_attributes_mask.try_into().expect("Failed to convert SessionAttributesMask into TPMA_SESSION"),
+            TPMA_SESSION::try_from(session_attributes_mask).expect("Failed to convert SessionAttributesMask into TPMA_SESSION"),
             "Converting session attributes mask with {} set did not convert into the expected TPMA_SESSION value", $attribute,
         );
     };

tss-esapi/tests/integration_tests/constants_tests/algorithm_tests.rs

@@ -1,22 +1,29 @@
 // Copyright 2021 Contributors to the Parsec project.
 // SPDX-License-Identifier: Apache-2.0
 use std::convert::TryFrom;
-use tss_esapi::constants::{
-    tss::{
-        TPM2_ALG_AES, TPM2_ALG_CAMELLIA, TPM2_ALG_CBC, TPM2_ALG_CFB, TPM2_ALG_CMAC, TPM2_ALG_CTR,
-        TPM2_ALG_ECB, TPM2_ALG_ECC, TPM2_ALG_ECDAA, TPM2_ALG_ECDH, TPM2_ALG_ECDSA, TPM2_ALG_ECMQV,
-        TPM2_ALG_ECSCHNORR, TPM2_ALG_ERROR, TPM2_ALG_HMAC, TPM2_ALG_KDF1_SP800_108,
-        TPM2_ALG_KDF1_SP800_56A, TPM2_ALG_KDF2, TPM2_ALG_KEYEDHASH, TPM2_ALG_MGF1, TPM2_ALG_NULL,
-        TPM2_ALG_OAEP, TPM2_ALG_OFB, TPM2_ALG_RSA, TPM2_ALG_RSAES, TPM2_ALG_RSAPSS,
-        TPM2_ALG_RSASSA, TPM2_ALG_SHA1, TPM2_ALG_SHA256, TPM2_ALG_SHA384, TPM2_ALG_SHA3_256,
-        TPM2_ALG_SHA3_384, TPM2_ALG_SHA3_512, TPM2_ALG_SHA512, TPM2_ALG_SM2, TPM2_ALG_SM3_256,
-        TPM2_ALG_SM4, TPM2_ALG_SYMCIPHER, TPM2_ALG_TDES, TPM2_ALG_XOR,
+use tss_esapi::{
+    constants::{
+        tss::{
+            TPM2_ALG_AES, TPM2_ALG_CAMELLIA, TPM2_ALG_CBC, TPM2_ALG_CFB, TPM2_ALG_CMAC,
+            TPM2_ALG_CTR, TPM2_ALG_ECB, TPM2_ALG_ECC, TPM2_ALG_ECDAA, TPM2_ALG_ECDH,
+            TPM2_ALG_ECDSA, TPM2_ALG_ECMQV, TPM2_ALG_ECSCHNORR, TPM2_ALG_ERROR, TPM2_ALG_HMAC,
+            TPM2_ALG_KDF1_SP800_108, TPM2_ALG_KDF1_SP800_56A, TPM2_ALG_KDF2, TPM2_ALG_KEYEDHASH,
+            TPM2_ALG_MGF1, TPM2_ALG_NULL, TPM2_ALG_OAEP, TPM2_ALG_OFB, TPM2_ALG_RSA,
+            TPM2_ALG_RSAES, TPM2_ALG_RSAPSS, TPM2_ALG_RSASSA, TPM2_ALG_SHA1, TPM2_ALG_SHA256,
+            TPM2_ALG_SHA384, TPM2_ALG_SHA3_256, TPM2_ALG_SHA3_384, TPM2_ALG_SHA3_512,
+            TPM2_ALG_SHA512, TPM2_ALG_SM2, TPM2_ALG_SM3_256, TPM2_ALG_SM4, TPM2_ALG_SYMCIPHER,
+            TPM2_ALG_TDES, TPM2_ALG_XOR,
+        },
+        AlgorithmIdentifier,
     },
-    AlgorithmIdentifier,
+    tss2_esys::TPM2_ALG_ID,
 };
 macro_rules! test_conversion {
     ($tpm_alg_id:ident, $algorithm:ident) => {
-        assert_eq!($tpm_alg_id, AlgorithmIdentifier::$algorithm.into());
+        assert_eq!(
+            $tpm_alg_id,
+            TPM2_ALG_ID::from(AlgorithmIdentifier::$algorithm)
+        );
         assert_eq!(
             AlgorithmIdentifier::$algorithm,
             AlgorithmIdentifier::try_from($tpm_alg_id).expect(&format!(

tss-esapi/tests/integration_tests/constants_tests/return_code_tests/base_return_code_tests.rs

@@ -35,7 +35,7 @@ macro_rules! test_valid_conversion {
     ($tss_rc_base:ident, $base_error_item:ident) => {
         assert_eq!(
             $tss_rc_base as u16,
-            BaseError::$base_error_item.into(),
+            u16::from(BaseError::$base_error_item),
             "Failed to convert {} into the expected TSS2_RC value {}",
             std::stringify!(BaseError::$base_error_item),
             std::stringify!($tss_rc_base),

tss-esapi/tests/integration_tests/constants_tests/return_code_tests/return_code_layer_tests.rs

@@ -27,7 +27,7 @@ macro_rules! test_valid_conversion {
 
         assert_eq!(
             tss_rc_layer_unshifted,
-            ReturnCodeLayer::$return_code_layer.into(),
+            u8::from(ReturnCodeLayer::$return_code_layer),
             "Conversion of {} into TSS_RC did not result in the expected {}",
             std::stringify!(ReturnCodeLayer::$return_code_layer),
             std::stringify!($tss_rc_layer)

tss-esapi/tests/integration_tests/constants_tests/return_code_tests/tpm_format_one_error_tests.rs

@@ -30,7 +30,7 @@ macro_rules! test_valid_conversion {
         let tpm_rc = TpmFormatOneRc($tpm_fmt1_rc as u16);
         assert_eq!(
             tpm_rc.error_number(),
-            TpmFormatOneError::$item.into(),
+            u8::from(TpmFormatOneError::$item),
             "Conversion of {} into a u16 value without TPM2_RC_FMT1 did not produce the expected value {}",
             std::stringify!(TpmFormatOneError::$item),
             tpm_rc.error_number()

tss-esapi/tests/integration_tests/constants_tests/return_code_tests/tpm_format_zero_error_tests.rs

@@ -31,7 +31,7 @@ macro_rules! test_valid_conversion {
         let tpm_rc = TpmFormatZeroErrorRc($tpm_ver1_rc as u16);
         assert_eq!(
             tpm_rc.error_number(),
-            TpmFormatZeroError::$item.into(),
+            u8::from(TpmFormatZeroError::$item),
             "Conversion of {} into a u16 value without TPM2_RC_VER1 did not produce the expected value {}",
             std::stringify!(TpmFormatZeroError::$item),
             tpm_rc.error_number()

tss-esapi/tests/integration_tests/constants_tests/return_code_tests/tpm_format_zero_warning_tests.rs

@@ -30,7 +30,7 @@ macro_rules! test_valid_conversion {
         let tpm_rc = TpmFormatZeroWarningRc($tpm_warn_rc as u16);
         assert_eq!(
             tpm_rc.error_number(),
-            TpmFormatZeroWarning::$item.into(),
+            u8::from(TpmFormatZeroWarning::$item),
             "Conversion of {} into a u16 value without TPM2_RC_VER1 did not produce the expected value {}",
             std::stringify!(TpmFormatZeroWarning::$item),
             tpm_rc.error_number()

tss-esapi/tests/integration_tests/context_tests/tpm_commands/integrity_collection_pcr_tests.rs

@@ -151,7 +151,7 @@ mod test_pcr_read {
     use tss_esapi::{
         interface_types::algorithm::HashingAlgorithm,
         structures::{PcrSelectionListBuilder, PcrSlot},
-        tss2_esys::{TPM2_SHA256_DIGEST_SIZE, TPML_PCR_SELECTION},
+        tss2_esys::{TPM2_SHA256_DIGEST_SIZE, TPMI_ALG_HASH, TPML_PCR_SELECTION},
     };
 
     #[test]
@@ -167,7 +167,10 @@ mod test_pcr_read {
         assert_eq!(pcr_selection_list.len(), 1);
         assert_eq!(input.count as usize, pcr_selection_list.len());
         assert_eq!(input.pcrSelections[0].sizeofSelect, 3);
-        assert_eq!(input.pcrSelections[0].hash, HashingAlgorithm::Sha256.into());
+        assert_eq!(
+            input.pcrSelections[0].hash,
+            TPMI_ALG_HASH::from(HashingAlgorithm::Sha256)
+        );
         assert_eq!(input.pcrSelections[0].pcrSelect[0], 0b0000_0001);
         assert_eq!(input.pcrSelections[0].pcrSelect[1], 0b0000_0000);
         assert_eq!(input.pcrSelections[0].pcrSelect[2], 0b0000_0000);