RUN-641: Stable memory integrity test

.gitlab/CODEOWNERS

@@ -209,6 +209,7 @@ go_deps.bzl               @dfinity-lab/teams/idx
 /rs/rust_canisters/proxy_canister/      @dfinity-lab/teams/networking-team
 /rs/rust_canisters/response_payload_test/       @dfinity-lab/teams/runtime-owners
 /rs/rust_canisters/stable_structures/	@dfinity-lab/teams/runtime-owners
+/rs/rust_canisters/stable_memory_integrity	@dfinity-lab/teams/runtime-owners
 /rs/rust_canisters/xnet_test/           @dfinity-lab/teams/message-routing-owners
 /rs/scenario_tests/                     @dfinity-lab/teams/ic-testing-verification
 /rs/sns/                                @dfinity-lab/teams/nns-team

rs/rust_canisters/stable_memory_integrity/BUILD.bazel

@@ -0,0 +1,54 @@
+load("//bazel:canisters.bzl", "rust_canister")
+load("@rules_rust//rust:defs.bzl", "rust_library", "rust_test")
+
+package(default_visibility = ["//visibility:public"])
+
+rust_library(
+    name = "stable_memory_integrity",
+    srcs = glob(["src/**/*.rs"]),
+    aliases = {},
+    crate_name = "ic_stable_memory_integrity",
+    proc_macro_deps = [],
+    version = "0.8.0",
+    deps = [
+        "@crate_index//:candid",
+        "@crate_index//:ic-cdk",
+        "@crate_index//:serde",
+    ],
+)
+
+rust_canister(
+    name = "stable_memory_integrity_canister",
+    srcs = ["bin/main.rs"],
+    proc_macro_deps = ["@crate_index//:ic-cdk-macros"],
+    service_file = ":stable_memory_integrity.did",
+    deps = [
+        "//rs/rust_canisters/stable_memory_integrity",
+        "@crate_index//:candid",
+        "@crate_index//:ic-cdk",
+    ],
+)
+
+rust_test(
+    name = "tests",
+    srcs = ["tests/stable_memory_integrity.rs"],
+    aliases = {},
+    crate_root = "tests/stable_memory_integrity.rs",
+    data = [
+        ":stable_memory_integrity_canister.wasm",
+    ],
+    env = {
+        "STABLE_MEMORY_INTEGRITY_CANISTER_WASM_PATH": "$(rootpath :stable_memory_integrity_canister.wasm)",
+    },
+    proc_macro_deps = [],
+    deps = [
+        "//rs/rust_canisters/canister_test",
+        "//rs/rust_canisters/stable_memory_integrity",
+        "//rs/state_machine_tests",
+        "//rs/types/types",
+        "@crate_index//:assert_matches",
+        "@crate_index//:candid",
+        "@crate_index//:lazy_static",
+        "@crate_index//:proptest",
+    ],
+)

rs/rust_canisters/stable_memory_integrity/Cargo.toml

@@ -0,0 +1,22 @@
+[package]
+name = "stable_memory_integrity"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+assert_matches = "1.5.0"
+candid = "0.8.1"
+canister-test = { path = "../canister_test" }
+ic-cdk = "0.6.0"
+ic-cdk-macros = "0.6.0"
+ic-state-machine-tests = { path = "../../state_machine_tests" }
+ic-types = { path = "../../types/types" }
+lazy-static = "1.4.0"
+serde = "1.0.136"
+proptest = "1.2.0"
+
+[[bin]]
+name = "stable_memory_integrity"
+path = "bin/main.rs"

rs/rust_canisters/stable_memory_integrity/README.md

@@ -0,0 +1,5 @@
+# Stable Memory Integrity Canister
+
+This canister can perform arbitrary operations on stable memory. It's purpose is
+to used when testing the correctness of the stable memory implementation in the
+replica.

rs/rust_canisters/stable_memory_integrity/bin/main.rs

@@ -0,0 +1,25 @@
+use ic_cdk::api::stable::{stable64_read, stable64_size};
+use ic_cdk_macros::{query, update};
+
+use ic_stable_memory_integrity::StableOperationResult;
+
+#[update]
+fn perform_and_check_ops(ops: Vec<StableOperationResult>) {
+    for op in ops {
+        op.perform_and_check()
+    }
+}
+
+#[query]
+fn final_size() -> u64 {
+    stable64_size()
+}
+
+#[query]
+fn read(start: u64, length: u64) -> Vec<u8> {
+    let mut result = vec![0; length as usize];
+    stable64_read(start, &mut result);
+    result
+}
+
+fn main() {}

rs/rust_canisters/stable_memory_integrity/src/lib.rs

@@ -0,0 +1,74 @@
+use candid::CandidType;
+use ic_cdk::api::stable::{
+    stable64_grow, stable64_read, stable64_size, stable64_write, stable_read, stable_write,
+};
+use serde::{Deserialize, Serialize};
+
+#[derive(Clone, Debug, Serialize, Deserialize, CandidType, PartialEq)]
+pub enum StableOperationResult {
+    Size(u64),
+    Grow {
+        new_pages: u64,
+        result: Result<u64, ()>,
+    },
+    Read {
+        start: u64,
+        result: Vec<u8>,
+    },
+    Write {
+        start: u64,
+        contents: Vec<u8>,
+    },
+    Read32 {
+        start: u32,
+        result: Vec<u8>,
+    },
+    Write32 {
+        start: u32,
+        contents: Vec<u8>,
+    },
+}
+
+impl StableOperationResult {
+    pub fn perform_and_check(self) {
+        match self {
+            StableOperationResult::Size(expected_size) => {
+                let result = stable64_size();
+                assert_eq!(expected_size, result);
+            }
+            StableOperationResult::Grow { new_pages, result } => {
+                let initial_size = stable64_size();
+                let actual_result = stable64_grow(new_pages).map_err(|_| ());
+                assert_eq!(result, actual_result);
+                let new_size = stable64_size();
+                if actual_result.is_ok() {
+                    assert_eq!(new_size, initial_size + new_pages);
+                } else {
+                    assert_eq!(new_size, initial_size);
+                }
+            }
+            StableOperationResult::Read { start, result } => {
+                let mut actual_result = vec![0; result.len()];
+                stable64_read(start, &mut actual_result);
+                assert_eq!(result, actual_result);
+            }
+            StableOperationResult::Write { start, contents } => {
+                stable64_write(start, &contents);
+                let mut result = vec![0; contents.len()];
+                stable64_read(start, &mut result);
+                assert_eq!(contents, result);
+            }
+            StableOperationResult::Read32 { start, result } => {
+                let mut actual_result = vec![0; result.len()];
+                stable_read(start, &mut actual_result);
+                assert_eq!(result, actual_result);
+            }
+            StableOperationResult::Write32 { start, contents } => {
+                stable_write(start, &contents);
+                let mut result = vec![0; contents.len()];
+                stable_read(start, &mut result);
+                assert_eq!(contents, result);
+            }
+        }
+    }
+}

rs/rust_canisters/stable_memory_integrity/stable_memory_integrity.did

@@ -0,0 +1 @@
+service : {}