Merge pull request #474 from Superhepper/type-ambiguity-in-tests

Fixes some causes for type ambiguity in tests.

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);

tss-esapi/tests/integration_tests/error_tests/return_code_tests/esapi_tests.rs

@@ -22,6 +22,7 @@ use tss_esapi::{
     error::{BaseReturnCode, EsapiReturnCode, ReturnCode},
     interface_types::{algorithm::HashingAlgorithm, resource_handles::Hierarchy},
     structures::{Auth, SymmetricDefinition},
+    tss2_esys::TSS2_RC,
     Error, WrapperErrorKind,
 };
 
@@ -74,7 +75,7 @@ macro_rules! test_valid_conversion {
 
         assert_eq!(
             expected_tss_rc,
-            actual_rc.into(),
+            TSS2_RC::from(actual_rc),
             "EsapiReturnCode with {} did not convert into expected {} TSS2_RC in the ESAPI layer.",
             std::stringify!(BaseError::$base_error),
             std::stringify!($tss_rc_base_error),

tss-esapi/tests/integration_tests/error_tests/return_code_tests/fapi_tests.rs

@@ -24,6 +24,7 @@ use tss_esapi::{
         BaseError,
     },
     error::{BaseReturnCode, FapiReturnCode, ReturnCode},
+    tss2_esys::TSS2_RC,
     Error, WrapperErrorKind,
 };
 
@@ -76,7 +77,7 @@ macro_rules! test_valid_conversion {
 
         assert_eq!(
             expected_tss_rc,
-            actual_rc.into(),
+            TSS2_RC::from(actual_rc),
             "FapiReturnCode with {} did not convert into expected {} TSS2_RC in the FAPI layer.",
             std::stringify!(BaseError::$base_error),
             std::stringify!($tss_rc_base_error),

tss-esapi/tests/integration_tests/error_tests/return_code_tests/muapi_tests.rs

@@ -12,6 +12,7 @@ use tss_esapi::{
         BaseError,
     },
     error::{BaseReturnCode, MuapiReturnCode, ReturnCode},
+    tss2_esys::TSS2_RC,
     Error, WrapperErrorKind,
 };
 
@@ -64,7 +65,7 @@ macro_rules! test_valid_conversion {
 
         assert_eq!(
             expected_tss_rc,
-            actual_rc.into(),
+            TSS2_RC::from(actual_rc),
             "{} did not convert into expected {} in TSS2_RC MUAPI layer.",
             std::stringify!(ReturnCode::Mu(MuapiReturnCode::$muapi_rc_item)),
             std::stringify!($tss_rc_base_error),

tss-esapi/tests/integration_tests/error_tests/return_code_tests/resource_manager_tests.rs

@@ -30,6 +30,7 @@ use tss_esapi::{
     },
     error::{BaseReturnCode, ReturnCode},
     tss2_esys::TSS2_LAYER_IMPLEMENTATION_SPECIFIC_OFFSET,
+    tss2_esys::TSS2_RC,
     Error, WrapperErrorKind,
 };
 
@@ -69,7 +70,7 @@ macro_rules! test_valid_conversion {
 
         assert_eq!(
             expected_tss_rc,
-            actual_rc.into(),
+            TSS2_RC::from(actual_rc),
             "BaseReturnCode with {} did not convert into expected {} TSS2_RC in the RESMGR layer.",
             std::stringify!(BaseError::$base_error),
             std::stringify!($tss_rc_base_error),

tss-esapi/tests/integration_tests/error_tests/return_code_tests/resource_manager_tpm_tests.rs

@@ -4,6 +4,7 @@ use std::convert::TryFrom;
 use tss_esapi::{
     constants::tss::{TPM2_RC_ASYMMETRIC, TPM2_RC_SEQUENCE, TSS2_RESMGR_TPM_RC_LAYER},
     error::{ReturnCode, TpmResponseCode},
+    tss2_esys::TSS2_RC,
 };
 
 #[test]
@@ -23,7 +24,7 @@ fn test_valid_tpm_resmgr_format_zero_response_code() {
 
     assert_eq!(
         expected_tss_rc,
-        actual_rc.into(),
+        TSS2_RC::from(actual_rc),
         "ReturnCode::TpmResourceManager did not convert into the expected TSS2_RC value"
     );
 }
@@ -45,7 +46,7 @@ fn test_valid_tpm_resmgr_format_one_response_code() {
 
     assert_eq!(
         expected_tss_rc,
-        actual_rc.into(),
+        TSS2_RC::from(actual_rc),
         "ReturnCode::TpmResourceManager did not convert into the expected TSS2_RC value"
     );
 }

tss-esapi/tests/integration_tests/error_tests/return_code_tests/sapi_tests.rs

@@ -16,6 +16,7 @@ use tss_esapi::{
         BaseError,
     },
     error::{BaseReturnCode, ReturnCode, SapiReturnCode},
+    tss2_esys::TSS2_RC,
     Error, WrapperErrorKind,
 };
 
@@ -68,7 +69,7 @@ macro_rules! test_valid_conversion {
 
         assert_eq!(
             expected_tss_rc,
-            actual_rc.into(),
+            TSS2_RC::from(actual_rc),
             "SapiReturnCode with {} did not convert into expected {} TSS2_RC in the SAPI layer.",
             std::stringify!(BaseError::$base_error),
             std::stringify!($tss_rc_base_error),

tss-esapi/tests/integration_tests/error_tests/return_code_tests/tcti_tests.rs

@@ -15,6 +15,7 @@ use tss_esapi::{
         BaseError,
     },
     error::{BaseReturnCode, ReturnCode, TctiReturnCode},
+    tss2_esys::TSS2_RC,
     Error, WrapperErrorKind,
 };
 
@@ -67,7 +68,7 @@ macro_rules! test_valid_conversion {
 
         assert_eq!(
             expected_tss_rc,
-            actual_rc.into(),
+            TSS2_RC::from(actual_rc),
             "TctiReturnCode with {} did not convert into expected {} TSS2_RC in the TCTI layer.",
             std::stringify!(BaseError::$base_error),
             std::stringify!($tss_rc_base_error),

tss-esapi/tests/integration_tests/error_tests/return_code_tests/tpm_tests.rs

@@ -8,6 +8,7 @@ use std::{convert::TryFrom, error::Error};
 use tss_esapi::{
     constants::tss::{TPM2_RC_ASYMMETRIC, TPM2_RC_SEQUENCE, TSS2_TPM_RC_LAYER},
     error::{ReturnCode, TpmFormatOneResponseCode, TpmFormatZeroResponseCode, TpmResponseCode},
+    tss2_esys::TSS2_RC,
 };
 
 macro_rules! test_valid_conversions {
@@ -41,7 +42,7 @@ macro_rules! test_valid_conversions {
 
         assert_eq!(
             expected_tss_rc,
-            actual_rc.into(),
+            TSS2_RC::from(actual_rc),
             "ReturnCode::Tpm did not convert into the expected TSS2_RC value."
         );
     };

tss-esapi/tests/integration_tests/error_tests/return_code_tests/tpm_tests/tpm_format_one_error_tests.rs

@@ -18,6 +18,7 @@ use tss_esapi::{
         },
     },
     error::{ArgumentNumber, ReturnCode, TpmFormatOneResponseCode, TpmResponseCode},
+    tss2_esys::TSS2_RC,
 };
 
 macro_rules! test_valid_conversions_with_all_argument_combinations {
@@ -80,7 +81,7 @@ macro_rules! test_valid_conversion {
 
         assert_eq!(
             expected_tss_rc,
-            actual_rc.into(),
+            TSS2_RC::from(actual_rc),
             "TpmFormatOneResponseCode with {} and {} in the TPM layer did not convert into the expected TSS2_RC",
             std::stringify!(TpmFormatOneError::$tpm_format_one_error_item),
             std::stringify!(ArgumentNumber::$argument_number_item),

tss-esapi/tests/integration_tests/error_tests/return_code_tests/tpm_tests/tpm_format_zero_tests.rs

@@ -14,6 +14,7 @@ use tss_esapi::{
         ReturnCode, TpmFormatZeroErrorResponseCode, TpmFormatZeroResponseCode,
         TpmFormatZeroWarningResponseCode, TpmResponseCode,
     },
+    tss2_esys::TSS2_RC,
 };
 
 bitfield! {
@@ -39,7 +40,7 @@ fn test_vendor_specific_valid_conversions() {
     {
         assert_eq!(
             expected_tss_rc,
-            actual.into(),
+            TSS2_RC::from(actual),
             "Converting vendor specific return code did not return the original value."
         );
     } else {
@@ -48,7 +49,7 @@ fn test_vendor_specific_valid_conversions() {
 
     assert_eq!(
         expected_tss_rc,
-        actual_rc.into(),
+        TSS2_RC::from(actual_rc),
         "The vendor specific return code did not convert into the expected TSS2_RC in the TPM layer."
     )
 }

tss-esapi/tests/integration_tests/error_tests/return_code_tests/tpm_tests/tpm_format_zero_tests/tpm_format_zero_error_tests.rs

@@ -20,6 +20,7 @@ use tss_esapi::{
     error::{
         ReturnCode, TpmFormatZeroErrorResponseCode, TpmFormatZeroResponseCode, TpmResponseCode,
     },
+    tss2_esys::TSS2_RC,
     Error, WrapperErrorKind,
 };
 
@@ -63,7 +64,7 @@ macro_rules! test_valid_conversion {
 
         assert_eq!(
             expected_tss_rc,
-            actual_rc.into(),
+            TSS2_RC::from(actual_rc),
             "{} with {} did not convert into expected {} TSS2_RC in the TPM layer.",
             std::any::type_name::<TpmFormatZeroResponseCode>(),
             std::stringify!(TpmFormatZeroError::$item),

tss-esapi/tests/integration_tests/error_tests/return_code_tests/tpm_tests/tpm_format_zero_tests/tpm_format_zero_warning_tests.rs

@@ -19,6 +19,7 @@ use tss_esapi::{
     error::{
         ReturnCode, TpmFormatZeroResponseCode, TpmFormatZeroWarningResponseCode, TpmResponseCode,
     },
+    tss2_esys::TSS2_RC,
     Error, WrapperErrorKind,
 };
 
@@ -59,7 +60,7 @@ macro_rules! test_valid_conversion {
 
         assert_eq!(
             expected_tss_rc,
-            actual_rc.into(),
+            TSS2_RC::from(actual_rc),
             "TpmFormatZeroResponseCode with {} did not convert into expected {} TSS2_RC in the TPM layer.",
             std::stringify!(TpmFormatZeroWarning::$item),
             std::stringify!($tpm_rc),