Initial Dever 0.0.1

test/rust/performance/bytes/mod.rs

@@ -0,0 +1,170 @@
+fn byte_fault() -> Fault {
+    &FaultInfo {
+        message: "byte conversion failed",
+        source: "reference.dever",
+        line: 1,
+        column: 1,
+    }
+}
+
+fn total_reference(values: &dever_runtime::Bytes) -> Result<i64, Fault> {
+    values.iter().try_fold(0i64, |total, value| {
+        total.checked_add(i64::from(*value)).ok_or_else(byte_fault)
+    })
+}
+
+fn each_reference(values: &dever_runtime::Bytes) -> Result<Vec<i64>, Fault> {
+    values
+        .iter()
+        .map(|value| i64::from(*value).checked_add(1).ok_or_else(byte_fault))
+        .collect()
+}
+
+fn encode_generated(values: &[String]) -> Result<dever_runtime::Bytes, Fault> {
+    GENERATED_ENCODE(values.first().map(String::as_str).unwrap_or(""))
+}
+
+fn encode_reference(values: &[String]) -> Result<dever_runtime::Bytes, Fault> {
+    Ok(values
+        .first()
+        .map(String::as_str)
+        .unwrap_or("")
+        .as_bytes()
+        .to_vec()
+        .into())
+}
+
+fn decode_generated(values: &dever_runtime::Bytes) -> Result<String, Fault> {
+    GENERATED_DECODE(values).map_err(|_| byte_fault())
+}
+
+fn decode_reference(values: &dever_runtime::Bytes) -> Result<String, Fault> {
+    std::str::from_utf8(values)
+        .map(str::to_owned)
+        .map_err(|_| byte_fault())
+}
+
+fn convert_generated(values: &[i64]) -> Result<dever_runtime::Bytes, Fault> {
+    GENERATED_CONVERT(values).map_err(|_| byte_fault())
+}
+
+fn convert_reference(values: &[i64]) -> Result<dever_runtime::Bytes, Fault> {
+    values
+        .iter()
+        .map(|value| u8::try_from(*value).map_err(|_| byte_fault()))
+        .collect::<Result<Vec<_>, _>>()
+        .map(Into::into)
+}
+
+fn slice_generated(values: &dever_runtime::Bytes) -> Result<dever_runtime::Bytes, Fault> {
+    GENERATED_SLICE(values).map_err(|_| byte_fault())
+}
+
+fn slice_reference(values: &dever_runtime::Bytes) -> Result<dever_runtime::Bytes, Fault> {
+    values
+        .get(0..values.len())
+        .map(<[u8]>::to_vec)
+        .map(Into::into)
+        .ok_or_else(byte_fault)
+}
+
+fn join_reference(values: &dever_runtime::Bytes) -> Result<dever_runtime::Bytes, Fault> {
+    let mut result = Vec::with_capacity(values.len() + values.len());
+    result.extend_from_slice(values);
+    result.extend_from_slice(values);
+    Ok(result.into())
+}
+
+fn roundtrip_generated(values: &[String]) -> Result<String, Fault> {
+    GENERATED_ROUNDTRIP(values.first().map(String::as_str).unwrap_or("")).map_err(|_| byte_fault())
+}
+
+fn roundtrip_reference(values: &[String]) -> Result<String, Fault> {
+    let bytes = values
+        .first()
+        .map(String::as_str)
+        .unwrap_or("")
+        .as_bytes()
+        .to_vec();
+    String::from_utf8(bytes).map_err(|_| byte_fault())
+}
+
+fn main() {
+    let text = "hello 雪🙂 ".repeat(256);
+    let texts = [text];
+    let bytes = dever_runtime::Bytes::copy_from_slice(texts[0].as_bytes());
+    let integers: Vec<i64> = (0..1024).map(|value| value % 256).collect();
+    let invalid = dever_runtime::Bytes::from_static(&[255]);
+    assert!(decode_generated(&invalid).is_err());
+    assert!(decode_reference(&invalid).is_err());
+    assert_eq!(GENERATED_IDENTITY(&bytes).unwrap().as_ptr(), bytes.as_ptr());
+    assert!(convert_generated(&[-1]).is_err());
+    assert!(convert_reference(&[-1]).is_err());
+    assert!(convert_generated(&[256]).is_err());
+    assert!(convert_reference(&[256]).is_err());
+    println!("case,sample,implementation,elapsed_ns,checksum");
+    compare_bytes(
+        "bytes_reduce",
+        &bytes,
+        2000,
+        GENERATED_TOTAL,
+        total_reference,
+        |value| *value as u64,
+    );
+    compare_bytes(
+        "bytes_each",
+        &bytes,
+        2000,
+        GENERATED_EACH,
+        each_reference,
+        |value| value.len() as u64,
+    );
+    compare(
+        "bytes_encode",
+        &texts,
+        20000,
+        encode_generated,
+        encode_reference,
+        |value| value.len() as u64,
+    );
+    compare_bytes(
+        "bytes_decode",
+        &bytes,
+        4000,
+        decode_generated,
+        decode_reference,
+        |value| value.len() as u64,
+    );
+    compare(
+        "bytes_from_ints",
+        &integers,
+        2000,
+        convert_generated,
+        convert_reference,
+        |value| value.len() as u64,
+    );
+    compare_bytes(
+        "bytes_slice",
+        &bytes,
+        20000,
+        slice_generated,
+        slice_reference,
+        |value| value.len() as u64,
+    );
+    compare_bytes(
+        "bytes_concat",
+        &bytes,
+        10000,
+        GENERATED_JOIN,
+        join_reference,
+        |value| value.len() as u64,
+    );
+    compare(
+        "bytes_roundtrip",
+        &texts,
+        4000,
+        roundtrip_generated,
+        roundtrip_reference,
+        |value| value.len() as u64,
+    );
+}