This is an archive of the discontinued Mercurial Phabricator instance.

Differential D7788

rust-node: binary Node ID and conversion utilities
ClosedPublic

Authored by gracinet on Jan 6 2020, 2:25 PM.

Details

Reviewers
kevincox
martinvonz
Group Reviewers
hg-reviewers
Commits
rHG7f86426fdd2c: rust-node: binary Node ID and conversion utilities
Summary

The choice of type makes sure that a Node has the exact
wanted size. We'll use a different type for prefixes.

Added dependency: hexadecimal conversion relies on the
hex crate.

The fact that sooner or later Mercurial is going to need
to change its hash sizes has been taken strongly in
consideration:

  • the hash length is a constant, but that is not directly exposed to callers. Changing the value of that constant is the only thing to do to change the hash length (even in unit tests)
  • the code could be adapted to support several sizes of hashes, if that turned out to be useful. To that effect, only the size of a given Node is exposed in the public API.
  • callers not involved in initial computation, I/O and FFI are able to operate without a priori assumptions on the hash size. The traits FromHex and ToHex have not been directly implemented, so that the doc-comments explaining these restrictions would stay really visible in cargo doc

Diff Detail

Repository
rHG Mercurial
Branch
default
Lint
No Linters Available
Unit
No Unit Test Coverage

Event Timeline

gracinet created this revision.Jan 6 2020, 2:25 PM
gracinet updated this revision to Diff 19323.Jan 15 2020, 6:47 PM
kevincox accepted this revision.Jan 16 2020, 5:50 AM
kevincox added inline comments.
rust/hg-core/src/revlog/node.rs
15

I would recommend making this a proper type because almost no one should be poking at the bytes of the hash.

struct Node([u8; 20]);

You can make the field pub if necessary.

32

I find progressing through the string easier to understand than this slicing. WDYT.

for byte in node.iter_mut() {
    *byte = u8::from_str_radix(&hex[..2], 16)?;
    hex = &hex[2..];
}
40

If we want to avoid a number of allocations we can do:

pub fn node_to_hex(n: &Node) -> String {
    let mut r = String::with_capacity(n.len() * 2);
    for byte in n {
        write!(r, "{:02x}", byte).unwrap();
    }
    debug_assert_eq!(r.len(), n.len() * 2);
    r
}

The generated code for write!() doesn't look great but if hex printing shows up in benchmarks it would be trivial to write a custom hex-formatter.

martinvonz requested changes to this revision.Jan 17 2020, 8:24 PM
martinvonz added a subscriber: martinvonz.
martinvonz added inline comments.
rust/hg-core/src/dirstate/dirs_multiset.rs
111 ↗(On Diff #19323)

please revert unrelated change

rust/hg-core/src/revlog/node.rs
32

Or even use hex::decode() from the hex crate? Can also use hex::encode() in node_to_hex if we're okay with that.

42–52

This feels like something that will only be used in nodemap.rs, so put it there instead? Or do you think (or know) that it will be used elsewhere soon?

This revision now requires changes to proceed.Jan 17 2020, 8:24 PM
martinvonz added inline comments.Jan 18 2020, 5:57 PM
rust/hg-core/src/revlog/node.rs
15

Oh, I think @durin42 and others were trying to remove the assumption that nodeids are 20 bytes (so we can use other hashes and hash lengths).

durin42 added a comment.Jan 18 2020, 6:18 PM

Yes, I'd appreciate not adding any assumptions that nodes are 20 bytes.

gracinet added a comment.Jan 20 2020, 8:17 AM

@durin42 @martinvonz we might have a nice path forward with this, with the suggestion of @kevincox to make Node a truly defined type, not just an alias, with a private member for the bytes.

Indeed I find it important to know if a node information is complete or merely a prefix. With a truly defined type, the assumption that it's 20 bytes long would be completely encapsulated in the Node type. It would then be very easy (much easier than with Python code) to change it to something else, whether that'd be a longer bag of bytes, or a struct with two values, an enum with alternatives for sha-1 or sha-2 etc.

martinvonz added a comment.Jan 21 2020, 1:54 PM
In D7788#116756, @gracinet wrote:

@durin42 @martinvonz we might have a nice path forward with this, with the suggestion of @kevincox to make Node a truly defined type, not just an alias, with a private member for the bytes.

Sounds good. I think I would have preferred that anyway.

gracinet retitled this revision from rust-node: binary Node and conversion utilities to rust-node: binary Node ID and conversion utilities.Jan 22 2020, 3:11 PM
gracinet edited the summary of this revision. (Show Details)
gracinet updated this revision to Diff 19521.
gracinet marked 6 inline comments as done.Jan 22 2020, 3:27 PM

As the new commit description explains, I've done all I could to make the change of hash format easier

I should add that my other colleagues at Octobus seem also to be involved in the improvement of hashing, there's no risk we would forget this one.

rust/hg-core/src/dirstate/dirs_multiset.rs
111 ↗(On Diff #19323)

ah yes, sorry must have been a rebase artifact

rust/hg-core/src/revlog/node.rs
32

Yes, hex is nice, it's able to produce arrays without further copies and does length checks. Its error type does not repeat the input string, though, which in my experience is really very useful to understand problems when they occur.

hex does not support hexadecimal string representations with odd numbers of
digits, which will be easy to work around in the next patch.

40

Finally used the hex crate here too.

42–52

Well it's become a public method in the new Node struct.
NodePrefix will be another user.

I tend to prefer encapsulation over where it's used for these choices. This way, there's no tempation for nodemap.rs to play with the binary data directly.

gracinet marked 3 inline comments as done.Jan 22 2020, 3:52 PM
gracinet added a commit: rHG7f86426fdd2c: rust-node: binary Node ID and conversion utilities.
This revision was not accepted when it landed; it landed in state Needs Review.
Closed by commit rHG7f86426fdd2c: rust-node: binary Node ID and conversion utilities (authored by gracinet). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 19521

rust/Cargo.lock

source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [ dependencies = [
"cfg-if 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)", "cfg-if 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
"libc 0.2.64 (registry+https://github.com/rust-lang/crates.io-index)", "libc 0.2.64 (registry+https://github.com/rust-lang/crates.io-index)",
"wasi 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)", "wasi 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
] ]
[[package]] [[package]]
name = "hex"
version = "0.4.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
[[package]]
name = "hg-core" name = "hg-core"
version = "0.1.0" version = "0.1.0"
dependencies = [ dependencies = [
"byteorder 1.3.2 (registry+https://github.com/rust-lang/crates.io-index)", "byteorder 1.3.2 (registry+https://github.com/rust-lang/crates.io-index)",
"hex 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
"lazy_static 1.4.0 (registry+https://github.com/rust-lang/crates.io-index)", "lazy_static 1.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
"memchr 2.2.1 (registry+https://github.com/rust-lang/crates.io-index)", "memchr 2.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
"rand 0.6.5 (registry+https://github.com/rust-lang/crates.io-index)", "rand 0.6.5 (registry+https://github.com/rust-lang/crates.io-index)",
"rand_pcg 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)", "rand_pcg 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
"rayon 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)", "rayon 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
"regex 1.3.1 (registry+https://github.com/rust-lang/crates.io-index)", "regex 1.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
"twox-hash 1.5.0 (registry+https://github.com/rust-lang/crates.io-index)", "twox-hash 1.5.0 (registry+https://github.com/rust-lang/crates.io-index)",
] ]
"checksum cpython 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)" = "85532c648315aeb0829ad216a6a29aa3212cf9319bc7f6daf1404aa0bdd1485f" "checksum cpython 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)" = "85532c648315aeb0829ad216a6a29aa3212cf9319bc7f6daf1404aa0bdd1485f"
"checksum crossbeam-deque 0.7.1 (registry+https://github.com/rust-lang/crates.io-index)" = "b18cd2e169ad86297e6bc0ad9aa679aee9daa4f19e8163860faf7c164e4f5a71" "checksum crossbeam-deque 0.7.1 (registry+https://github.com/rust-lang/crates.io-index)" = "b18cd2e169ad86297e6bc0ad9aa679aee9daa4f19e8163860faf7c164e4f5a71"
"checksum crossbeam-epoch 0.7.2 (registry+https://github.com/rust-lang/crates.io-index)" = "fedcd6772e37f3da2a9af9bf12ebe046c0dfe657992377b4df982a2b54cd37a9" "checksum crossbeam-epoch 0.7.2 (registry+https://github.com/rust-lang/crates.io-index)" = "fedcd6772e37f3da2a9af9bf12ebe046c0dfe657992377b4df982a2b54cd37a9"
"checksum crossbeam-queue 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "7c979cd6cfe72335896575c6b5688da489e420d36a27a0b9eb0c73db574b4a4b" "checksum crossbeam-queue 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "7c979cd6cfe72335896575c6b5688da489e420d36a27a0b9eb0c73db574b4a4b"
"checksum crossbeam-utils 0.6.6 (registry+https://github.com/rust-lang/crates.io-index)" = "04973fa96e96579258a5091af6003abde64af786b860f18622b82e026cca60e6" "checksum crossbeam-utils 0.6.6 (registry+https://github.com/rust-lang/crates.io-index)" = "04973fa96e96579258a5091af6003abde64af786b860f18622b82e026cca60e6"
"checksum either 1.5.3 (registry+https://github.com/rust-lang/crates.io-index)" = "bb1f6b1ce1c140482ea30ddd3335fc0024ac7ee112895426e0a629a6c20adfe3" "checksum either 1.5.3 (registry+https://github.com/rust-lang/crates.io-index)" = "bb1f6b1ce1c140482ea30ddd3335fc0024ac7ee112895426e0a629a6c20adfe3"
"checksum fuchsia-cprng 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "a06f77d526c1a601b7c4cdd98f54b5eaabffc14d5f2f0296febdc7f357c6d3ba" "checksum fuchsia-cprng 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "a06f77d526c1a601b7c4cdd98f54b5eaabffc14d5f2f0296febdc7f357c6d3ba"
"checksum getrandom 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)" = "473a1265acc8ff1e808cd0a1af8cee3c2ee5200916058a2ca113c29f2d903571" "checksum getrandom 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)" = "473a1265acc8ff1e808cd0a1af8cee3c2ee5200916058a2ca113c29f2d903571"
"checksum hex 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "023b39be39e3a2da62a94feb433e91e8bcd37676fbc8bea371daf52b7a769a3e"
"checksum lazy_static 1.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646" "checksum lazy_static 1.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"
"checksum libc 0.2.64 (registry+https://github.com/rust-lang/crates.io-index)" = "74dfca3d9957906e8d1e6a0b641dc9a59848e793f1da2165889fd4f62d10d79c" "checksum libc 0.2.64 (registry+https://github.com/rust-lang/crates.io-index)" = "74dfca3d9957906e8d1e6a0b641dc9a59848e793f1da2165889fd4f62d10d79c"
"checksum memchr 2.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "88579771288728879b57485cc7d6b07d648c9f0141eb955f8ab7f9d45394468e" "checksum memchr 2.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "88579771288728879b57485cc7d6b07d648c9f0141eb955f8ab7f9d45394468e"
"checksum memoffset 0.5.1 (registry+https://github.com/rust-lang/crates.io-index)" = "ce6075db033bbbb7ee5a0bbd3a3186bbae616f57fb001c485c7ff77955f8177f" "checksum memoffset 0.5.1 (registry+https://github.com/rust-lang/crates.io-index)" = "ce6075db033bbbb7ee5a0bbd3a3186bbae616f57fb001c485c7ff77955f8177f"
"checksum nodrop 0.1.14 (registry+https://github.com/rust-lang/crates.io-index)" = "72ef4a56884ca558e5ddb05a1d1e7e1bfd9a68d9ed024c21704cc98872dae1bb" "checksum nodrop 0.1.14 (registry+https://github.com/rust-lang/crates.io-index)" = "72ef4a56884ca558e5ddb05a1d1e7e1bfd9a68d9ed024c21704cc98872dae1bb"
"checksum num-traits 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)" = "6ba9a427cfca2be13aa6f6403b0b7e7368fe982bfa16fccc450ce74c46cd9b32" "checksum num-traits 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)" = "6ba9a427cfca2be13aa6f6403b0b7e7368fe982bfa16fccc450ce74c46cd9b32"
"checksum num_cpus 1.10.1 (registry+https://github.com/rust-lang/crates.io-index)" = "bcef43580c035376c0705c42792c294b66974abbfd2789b511784023f71f3273" "checksum num_cpus 1.10.1 (registry+https://github.com/rust-lang/crates.io-index)" = "bcef43580c035376c0705c42792c294b66974abbfd2789b511784023f71f3273"
"checksum ppv-lite86 0.2.5 (registry+https://github.com/rust-lang/crates.io-index)" = "e3cbf9f658cdb5000fcf6f362b8ea2ba154b9f146a61c7a20d647034c6b6561b" "checksum ppv-lite86 0.2.5 (registry+https://github.com/rust-lang/crates.io-index)" = "e3cbf9f658cdb5000fcf6f362b8ea2ba154b9f146a61c7a20d647034c6b6561b"

rust/hg-core/Cargo.toml

[package] [package]
name = "hg-core" name = "hg-core"
version = "0.1.0" version = "0.1.0"
authors = ["Georges Racinet <gracinet@anybox.fr>"] authors = ["Georges Racinet <gracinet@anybox.fr>"]
description = "Mercurial pure Rust core library, with no assumption on Python bindings (FFI)" description = "Mercurial pure Rust core library, with no assumption on Python bindings (FFI)"
edition = "2018" edition = "2018"
[lib] [lib]
name = "hg" name = "hg"
[dependencies] [dependencies]
byteorder = "1.3.1" byteorder = "1.3.1"
hex = "0.4.0"
lazy_static = "1.3.0" lazy_static = "1.3.0"
memchr = "2.2.0" memchr = "2.2.0"
rand = "0.6.5" rand = "0.6.5"
rand_pcg = "0.1.1" rand_pcg = "0.1.1"
rayon = "1.2.0" rayon = "1.2.0"
regex = "1.1.0" regex = "1.1.0"
twox-hash = "1.5.0" twox-hash = "1.5.0"

rust/hg-core/src/revlog.rs

// Copyright 2018-2020 Georges Racinet <georges.racinet@octobus.net> // Copyright 2018-2020 Georges Racinet <georges.racinet@octobus.net>
// and Mercurial contributors // and Mercurial contributors
// //
// This software may be used and distributed according to the terms of the // This software may be used and distributed according to the terms of the
// GNU General Public License version 2 or any later version. // GNU General Public License version 2 or any later version.
//! Mercurial concepts for handling revision history //! Mercurial concepts for handling revision history
pub mod node;
pub mod nodemap; pub mod nodemap;
pub use node::{Node, NodeError};
/// Mercurial revision numbers /// Mercurial revision numbers
/// ///
/// As noted in revlog.c, revision numbers are actually encoded in /// As noted in revlog.c, revision numbers are actually encoded in
/// 4 bytes, and are liberally converted to ints, whence the i32 /// 4 bytes, and are liberally converted to ints, whence the i32
pub type Revision = i32; pub type Revision = i32;
/// Marker expressing the absence of a parent /// Marker expressing the absence of a parent

rust/hg-core/src/revlog/node.rs

  • This file was added.
// Copyright 2019-2020 Georges Racinet <georges.racinet@octobus.net>
//
// This software may be used and distributed according to the terms of the
// GNU General Public License version 2 or any later version.
//! Definitions and utilities for Revision nodes
//!
//! In Mercurial code base, it is customary to call "a node" the binary SHA
//! of a revision.
use hex::{self, FromHex, FromHexError};
/// The length in bytes of a `Node`
///
/// This constant is meant to ease refactors of this module, and
kevincoxUnsubmitted
Done

I would recommend making this a proper type because almost no one should be poking at the bytes of the hash.

struct Node([u8; 20]);

You can make the field pub if necessary.

kevincox: I would recommend making this a proper type because almost no one should be poking at the bytes…
martinvonzUnsubmitted
Done

Oh, I think @durin42 and others were trying to remove the assumption that nodeids are 20 bytes (so we can use other hashes and hash lengths).

martinvonz: Oh, I think @durin42 and others were trying to remove the assumption that nodeids are 20 bytes…
/// are private so that calling code does not expect all nodes have
/// the same size, should we support several formats concurrently in
/// the future.
const NODE_BYTES_LENGTH: usize = 20;
/// The length in bytes of a `Node`
///
/// see also `NODES_BYTES_LENGTH` about it being private.
const NODE_NYBBLES_LENGTH: usize = 2 * NODE_BYTES_LENGTH;
/// Private alias for readability and to ease future change
type NodeData = [u8; NODE_BYTES_LENGTH];
/// Binary revision SHA
///
/// ## Future changes of hash size
///
kevincoxUnsubmitted
Done

I find progressing through the string easier to understand than this slicing. WDYT.

for byte in node.iter_mut() {
    *byte = u8::from_str_radix(&hex[..2], 16)?;
    hex = &hex[2..];
}
kevincox: I find progressing through the string easier to understand than this slicing. WDYT. ```…
martinvonzUnsubmitted
Done

Or even use hex::decode() from the hex crate? Can also use hex::encode() in node_to_hex if we're okay with that.

martinvonz: Or even use `hex::decode()` from the `hex` crate? Can also use `hex::encode()` in `node_to_hex`…
gracinetAuthorUnsubmitted
Done

Yes, hex is nice, it's able to produce arrays without further copies and does length checks. Its error type does not repeat the input string, though, which in my experience is really very useful to understand problems when they occur.

hex does not support hexadecimal string representations with odd numbers of
digits, which will be easy to work around in the next patch.

gracinet: Yes, `hex` is nice, it's able to produce arrays without further copies and does length checks.
/// To accomodate future changes of hash size, Rust callers
/// should use the conversion methods at the boundaries (FFI, actual
/// computation of hashes and I/O) only, and only if required.
///
/// All other callers outside of unit tests should just handle `Node` values
/// and never make any assumption on the actual length, using [`nybbles_len`]
/// if they need a loop boundary.
///
kevincoxUnsubmitted
Done

If we want to avoid a number of allocations we can do:

pub fn node_to_hex(n: &Node) -> String {
    let mut r = String::with_capacity(n.len() * 2);
    for byte in n {
        write!(r, "{:02x}", byte).unwrap();
    }
    debug_assert_eq!(r.len(), n.len() * 2);
    r
}

The generated code for write!() doesn't look great but if hex printing shows up in benchmarks it would be trivial to write a custom hex-formatter.

kevincox: If we want to avoid a number of allocations we can do: ``` pub fn node_to_hex(n: &Node) ->…
gracinetAuthorUnsubmitted
Done

Finally used the hex crate here too.

gracinet: Finally used the `hex` crate here too.
/// All methods that create a `Node` either take a type that enforces
/// the size or fail immediately at runtime with [`ExactLengthRequired`].
///
/// [`nybbles_len`]: #method.nybbles_len
/// [`ExactLengthRequired`]: struct.NodeError#variant.ExactLengthRequired
#[derive(Clone, Debug, PartialEq)]
pub struct Node {
data: NodeData,
}
/// The node value for NULL_REVISION
pub const NULL_NODE: Node = Node {
martinvonzUnsubmitted
Not Done

This feels like something that will only be used in nodemap.rs, so put it there instead? Or do you think (or know) that it will be used elsewhere soon?

martinvonz: This feels like something that will only be used in nodemap.rs, so put it there instead? Or do…
gracinetAuthorUnsubmitted
Done

Well it's become a public method in the new Node struct.
NodePrefix will be another user.

I tend to prefer encapsulation over where it's used for these choices. This way, there's no tempation for nodemap.rs to play with the binary data directly.

gracinet: Well it's become a public method in the new `Node` struct. `NodePrefix` will be another user.
data: [0; NODE_BYTES_LENGTH],
};
impl From<NodeData> for Node {
fn from(data: NodeData) -> Node {
Node { data }
}
}
#[derive(Debug, PartialEq)]
pub enum NodeError {
ExactLengthRequired(usize, String),
HexError(FromHexError, String),
}
/// Low level utility function, also for prefixes
fn get_nybble(s: &[u8], i: usize) -> u8 {
if i % 2 == 0 {
s[i / 2] >> 4
} else {
s[i / 2] & 0x0f
}
}
impl Node {
/// Retrieve the `i`th half-byte of the binary data.
///
/// This is also the `i`th hexadecimal digit in numeric form,
/// also called a [nybble](https://en.wikipedia.org/wiki/Nibble).
pub fn get_nybble(&self, i: usize) -> u8 {
get_nybble(&self.data, i)
}
/// Length of the data, in nybbles
pub fn nybbles_len(&self) -> usize {
// public exposure as an instance method only, so that we can
// easily support several sizes of hashes if needed in the future.
NODE_NYBBLES_LENGTH
}
/// Convert from hexadecimal string representation
///
/// Exact length is required.
///
/// To be used in FFI and I/O only, in order to facilitate future
/// changes of hash format.
pub fn from_hex(hex: &str) -> Result<Node, NodeError> {
Ok(NodeData::from_hex(hex)
.map_err(|e| NodeError::from((e, hex)))?
.into())
}
/// Convert to hexadecimal string representation
///
/// To be used in FFI and I/O only, in order to facilitate future
/// changes of hash format.
pub fn encode_hex(&self) -> String {
hex::encode(self.data)
}
/// Provide access to binary data
///
/// This is needed by FFI layers, for instance to return expected
/// binary values to Python.
pub fn as_bytes(&self) -> &[u8] {
&self.data
}
}
impl From<(FromHexError, &str)> for NodeError {
fn from(err_offender: (FromHexError, &str)) -> Self {
let (err, offender) = err_offender;
match err {
FromHexError::InvalidStringLength => {
NodeError::ExactLengthRequired(
NODE_NYBBLES_LENGTH,
offender.to_string(),
)
}
_ => NodeError::HexError(err, offender.to_string()),
}
}
}
#[cfg(test)]
mod tests {
use super::*;
fn sample_node() -> Node {
let mut data = [0; NODE_BYTES_LENGTH];
data.copy_from_slice(&[
0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef, 0xfe, 0xdc, 0xba,
0x98, 0x76, 0x54, 0x32, 0x10, 0xde, 0xad, 0xbe, 0xef,
]);
data.into()
}
/// Pad an hexadecimal string to reach `NODE_NYBBLES_LENGTH`
///
/// The padding is made with zeros
fn hex_pad_right(hex: &str) -> String {
let mut res = hex.to_string();
while res.len() < NODE_NYBBLES_LENGTH {
res.push('0');
}
res
}
fn sample_node_hex() -> String {
hex_pad_right("0123456789abcdeffedcba9876543210deadbeef")
}
#[test]
fn test_node_from_hex() {
assert_eq!(Node::from_hex(&sample_node_hex()), Ok(sample_node()));
let mut short = hex_pad_right("0123");
short.pop();
short.pop();
assert_eq!(
Node::from_hex(&short),
Err(NodeError::ExactLengthRequired(NODE_NYBBLES_LENGTH, short)),
);
let not_hex = hex_pad_right("012... oops");
assert_eq!(
Node::from_hex(&not_hex),
Err(NodeError::HexError(
FromHexError::InvalidHexCharacter { c: '.', index: 3 },
not_hex,
)),
);
}
#[test]
fn test_node_encode_hex() {
assert_eq!(sample_node().encode_hex(), sample_node_hex());
}
}