// Smoldot

// Copyright (C) 2023  Pierre Krieger

// SPDX-License-Identifier: GPL-3.0-or-later WITH Classpath-exception-2.0

// This program is free software: you can redistribute it and/or modify

// it under the terms of the GNU General Public License as published by

// the Free Software Foundation, either version 3 of the License, or

// (at your option) any later version.

// This program is distributed in the hope that it will be useful,

// but WITHOUT ANY WARRANTY; without even the implied warranty of

// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

// GNU General Public License for more details.

// You should have received a copy of the GNU General Public License

// along with this program.  If not, see <http://www.gnu.org/licenses/>.

#![cfg(test)]

use super::{prefix_scan, Config, ResumeOutcome};

// TODO: more tests

#[test]

fn regression_test_174() {

    let test_data = serde_json::from_str::<TestData>(include_str!("./test.json")).unwrap();

    let mut prefix_scan = prefix_scan(Config {

        prefix: &test_data.prefix.0,

        trie_root_hash: <[u8; 32]>::try_from(&test_data.trie_root_hash.0[..]).unwrap(),

        full_storage_values_required: true,

    });

    for proof in test_data.proofs {

        match prefix_scan.resume_all_keys(&proof.0) {

            Ok(ResumeOutcome::InProgress(scan)) => {

                prefix_scan = scan;

                continue;

            }

            Ok(ResumeOutcome::Success { mut entries, .. }) => {

                let mut expected = test_data

                    .expected_entries

                    .into_iter()

                    .map(|e| e.0)

                    .collect::<Vec<_>>();

                expected.sort();

                entries.sort_by(|(key1, _), (key2, _)| key1.cmp(&key2));

                assert_eq!(

                    entries.into_iter().map(|(key, _)| key).collect::<Vec<_>>(),

                    expected

                );

                return;

            }

            Err((_, err)) => panic!("{err:?}"),

        }

    }

}

#[derive(serde::Serialize, 
s5
erde::Deserialize)]

_RINvXs_NvXNvNtNtNtCsN16ciHI6Qf_7smoldot4trie12prefix_proof5testss_1__NtBa_8TestDataNtNtCsf0yC2YK6bpM_5serde2de11Deserialize11deserializeNtB5_7___FieldB1j_11deserializeINtNtCscu7pqq74Vb8_10serde_json2de6MapKeyNtNtB2K_4read7StrReadEEBg_

Line

Count

Source

59

4

#[derive(serde::Serialize, serde::Deserialize)]

Unexecuted instantiation: _RINvXs0_NvXNvNtNtNtCsN16ciHI6Qf_7smoldot4trie12prefix_proof5testss_1__NtBb_8TestDataNtNtCsf0yC2YK6bpM_5serde2de11Deserialize11deserializeNtB6_9___VisitorNtB1m_7Visitor9visit_seqINtNtCscu7pqq74Vb8_10serde_json2de9SeqAccessNtNtB2U_4read7StrReadEEBh_

_RINvXs0_NvXNvNtNtNtCsN16ciHI6Qf_7smoldot4trie12prefix_proof5testss_1__NtBb_8TestDataNtNtCsf0yC2YK6bpM_5serde2de11Deserialize11deserializeNtB6_9___VisitorNtB1m_7Visitor9visit_mapINtNtCscu7pqq74Vb8_10serde_json2de9MapAccessNtNtB2U_4read7StrReadEEBh_

Line

Count

Source

59

5

#[derive(serde::Serialize, 
s1
erde::Deserialize)]

_RINvXNvXNvNtNtNtCsN16ciHI6Qf_7smoldot4trie12prefix_proof5testss_1__NtB8_8TestDataNtNtCsf0yC2YK6bpM_5serde2de11Deserialize11deserializeNtB3_14___FieldVisitorNtB1j_7Visitor9visit_strNtNtCscu7pqq74Vb8_10serde_json5error5ErrorEBe_

Line

Count

Source

59

4

#[derive(serde::Serialize, serde::Deserialize)]

Unexecuted instantiation: _RNvXs0_NvXNvNtNtNtCsN16ciHI6Qf_7smoldot4trie12prefix_proof5testss_1__NtBa_8TestDataNtNtCsf0yC2YK6bpM_5serde2de11Deserialize11deserializeNtB5_9___VisitorNtB1l_7Visitor9expecting

Unexecuted instantiation: _RNvXNvXNvNtNtNtCsN16ciHI6Qf_7smoldot4trie12prefix_proof5testss_1__NtB7_8TestDataNtNtCsf0yC2YK6bpM_5serde2de11Deserialize11deserializeNtB2_14___FieldVisitorNtB1i_7Visitor9expecting

Unexecuted instantiation: _RINvXNvXNvNtNtNtCsN16ciHI6Qf_7smoldot4trie12prefix_proof5testss_1__NtB8_8TestDataNtNtCsf0yC2YK6bpM_5serde2de11Deserialize11deserializeNtB3_14___FieldVisitorNtB1j_7Visitor9visit_u64pEBe_

Unexecuted instantiation: _RINvXNvXNvNtNtNtCsN16ciHI6Qf_7smoldot4trie12prefix_proof5testss_1__NtB8_8TestDataNtNtCsf0yC2YK6bpM_5serde2de11Deserialize11deserializeNtB3_14___FieldVisitorNtB1j_7Visitor11visit_bytespEBe_

struct TestData {

    prefix: HexString,

    trie_root_hash: HexString,

    proofs: Vec<HexString>,

    expected_entries: Vec<HexString>,

}

#[derive(Clone, PartialEq, Eq, Hash)]

struct HexString(Vec<u8>);

impl serde::Serialize for HexString {

    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

    where

        S: serde::Serializer,

    {

        serde::Serialize::serialize(&("0x".to_string() + &hex::encode(&self.0)), serializer)

    }

}

impl<'a> serde::Deserialize<'a> for HexString {

    fn deserialize<D>(deserializer: D) -> Result<HexString, D::Error>

    where

        D: serde::Deserializer<'a>,

    {

        let string = String::deserialize(deserializer)
?0
;

        if string.is_empty() {

            return Ok(HexString(Vec::new()));

        }

        if !string.starts_with("0x") {

            return Err(serde::de::Error::custom(

                "hexadecimal string doesn't start with 0x",

            ));

        }

        let bytes = hex::decode(&string[2..]).map_err(serde::de::Error::custom)
?0
;

        Ok(HexString(bytes))

    }

Unexecuted instantiation: _RINvXs_NtNtNtCsN16ciHI6Qf_7smoldot4trie12prefix_proof5testsNtB5_9HexStringNtNtCsf0yC2YK6bpM_5serde2de11Deserialize11deserializeINtNvNtNtB1e_9___private2de13missing_field24MissingFieldDeserializerNtNtCscu7pqq74Vb8_10serde_json5error5ErrorEEBb_

_RINvXs_NtNtNtCsN16ciHI6Qf_7smoldot4trie12prefix_proof5testsNtB5_9HexStringNtNtCsf0yC2YK6bpM_5serde2de11Deserialize11deserializeQINtNtCscu7pqq74Vb8_10serde_json2de12DeserializerNtNtB27_4read7StrReadEEBb_

Line

Count

Source

80

930

    fn deserialize<D>(deserializer: D) -> Result<HexString, D::Error>

81

930

    where

82

930

        D: serde::Deserializer<'a>,

83

930

    {

84

930

        let string = String::deserialize(deserializer)
?0
;

85

86

930

        if string.is_empty() {

87

0

            return Ok(HexString(Vec::new()));

88

930

        }

89

930

90

930

        if !string.starts_with("0x") {

91

0

            return Err(serde::de::Error::custom(

92

0

                "hexadecimal string doesn't start with 0x",

93

0

            ));

94

930

        }

95

96

930

        let bytes = hex::decode(&string[2..]).map_err(serde::de::Error::custom)
?0
;

97

930

        Ok(HexString(bytes))

98

930

    }

}