encode_unsigned_1

native_implemented/otp/src/erlang.rs

@@ -49,6 +49,7 @@ pub mod display_1;
 pub mod div_2;
 pub mod divide_2;
 pub mod element_2;
+pub mod encode_unsigned_1;
 pub mod erase_0;
 pub mod erase_1;
 pub mod error_1;

native_implemented/otp/src/erlang/encode_unsigned_1.rs

@@ -0,0 +1,58 @@
+#[cfg(all(not(target_arch = "wasm32"), test))]
+mod test;
+
+use crate::runtime::context::{term_is_not_integer, term_is_not_non_negative_integer};
+use anyhow::*;
+use liblumen_alloc::erts::exception;
+use liblumen_alloc::erts::process::Process;
+use liblumen_alloc::erts::term::prelude::*;
+use num_bigint::Sign;
+
+/// Returns the smallest possible representation in a binary digit representation for the given big
+/// endian unsigned integer.
+#[native_implemented::function(erlang:encode_unsigned/1)]
+pub fn result(process: &Process, term: Term) -> exception::Result<Term> {
+    match term.decode().unwrap() {
+        TypedTerm::SmallInteger(small_integer) => {
+            let signed: isize = small_integer.into();
+            if signed < 0 {
+                return Err(TryIntoIntegerError::Type)
+                    .context(term_is_not_non_negative_integer("encoded_unsigned", term))
+                    .map_err(From::from);
+            }
+            let mut bytes: Vec<u8> = small_integer
+                .to_le_bytes()
+                .iter()
+                .filter_map(|&b| match b {
+                    0 => None,
+                    b => Some(b),
+                })
+                .collect();
+
+            bytes.reverse();
+
+            Ok(process.binary_from_bytes(&bytes))
+        }
+        TypedTerm::BigInteger(big_integer) => {
+            if Sign::Minus == big_integer.sign() {
+                return Err(TryIntoIntegerError::Type)
+                    .context(term_is_not_non_negative_integer("encoded_unsigned", term))
+                    .map_err(From::from);
+            }
+
+            let bytes: Vec<u8> = big_integer
+                .to_signed_bytes_be()
+                .iter()
+                .filter_map(|&b| match b {
+                    0 => None,
+                    b => Some(b),
+                })
+                .collect();
+
+            Ok(process.binary_from_bytes(&bytes))
+        }
+        _ => Err(TryIntoIntegerError::Type)
+            .context(term_is_not_integer("encoded_unsigned", term))
+            .map_err(From::from),
+    }
+}

native_implemented/otp/src/erlang/encode_unsigned_1/test.rs

@@ -0,0 +1,66 @@
+use crate::erlang::encode_unsigned_1::result;
+use crate::test::with_process;
+use crate::test::*;
+use liblumen_alloc::erts::term::prelude::*;
+use num_bigint::BigInt;
+use proptest::strategy::Just;
+
+// 1> binary:encode_unsigned(11111111).
+// <<169,138,199>>
+#[test]
+fn otp_doctest() {
+    with_process(|process| {
+        assert_eq!(
+            result(process, process.integer(11111111)),
+            Ok(process.binary_from_bytes(&[169, 138, 199]))
+        )
+    });
+}
+
+#[test]
+fn smallest_big_int() {
+    let largest_small_int_as_big_int: BigInt = SmallInteger::MAX_VALUE.into();
+    let smallest_big_int: BigInt = largest_small_int_as_big_int + 1;
+
+    // 1> binary:encode_unsigned(70368744177664).
+    // <<64,0,0,0,0,0>>
+
+    with_process(|process| {
+        assert_eq!(
+            result(process, process.integer(smallest_big_int)),
+            Ok(process.binary_from_bytes(&[64]))
+        )
+    });
+}
+
+#[test]
+fn negative_integer() {
+    run!(
+        |arc_process| {
+            (
+                Just(arc_process.clone()),
+                strategy::term::integer::negative(arc_process.clone()),
+            )
+        },
+        |(arc_process, non_int)| {
+            prop_assert_badarg!(result(&arc_process, non_int), "invalid integer conversion");
+            Ok(())
+        },
+    );
+}
+
+#[test]
+fn not_integer() {
+    run!(
+        |arc_process| {
+            (
+                Just(arc_process.clone()),
+                strategy::term::is_not_integer(arc_process.clone()),
+            )
+        },
+        |(arc_process, non_int)| {
+            prop_assert_badarg!(result(&arc_process, non_int), "invalid integer conversion");
+            Ok(())
+        },
+    );
+}