fix: code coverage

Author: mathisbot

.github/workflows/rust.yml

@@ -54,24 +54,6 @@ jobs:
       - name: Run fmt
         run: cargo fmt --verbose --all -- --check
 
-  coverage:
-    runs-on: ubuntu-latest
-    container:
-      image: xd009642/tarpaulin
-      options: --security-opt seccomp=unconfined
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v3
-
-      - name: Generate code coverage
-        run: |
-          cargo tarpaulin --all-targets --all-features --lib --timeout 180 --out xml
-
-      - name: Upload to codecov.io
-        uses: codecov/codecov-action@v2
-        with:
-          fail_ci_if_error: true
-
   x86_64-unknown-none:
     runs-on: ubuntu-latest
 

README.md

@@ -1,6 +1,6 @@
 # Homomorphic Encryption Scheme in Rust
 
-[![Coverage Status](https://coveralls.io/repos/github/mathisbot/homomorph-rust/badge.svg)](https://coveralls.io/github/mathisbot/homomorph-rust)
+[Code coverage](tarpaulin-report.html)
 
 This repository contains a Rust implementation of an homomorphic encryption scheme.
 

check.ps1

@@ -42,6 +42,8 @@ Run-Command "cargo run --example new_struct"
 Run-Command "cargo clippy --all-targets --all-features -- -D warnings --no-deps"
 Run-Command "cargo test --release -- --ignored"
 Run-Command "cargo fmt"
+# Optional
+# Run-Command "cargo tarpaulin --lib --all-features --locked --out Html"
 
 Write-Host "`n./src contains $(Count-Lines "src") non-empty lines" -ForegroundColor blue
 Write-Host "Ready to push!" -ForegroundColor Green

check.sh

@@ -40,6 +40,8 @@ run_command "cargo run --example new_struct"
 run_command "cargo clippy --all-targets --all-features -- -D warnings --no-deps"
 run_command "cargo test --release -- --ignored"
 run_command "cargo fmt"
+# Optional
+# run_command "cargo tarpaulin --lib --all-features --locked --out Html"
 
 echo -e "\n./src contains $(count_lines 'src') non-empty lines" 
 echo -e "\033[32mReady to push!\033[0m"

src/cipher.rs

@@ -111,9 +111,9 @@ unsafe impl<T: Copy + Sized> ByteConvertible for T {
     fn from_bytes(bytes: &[u8]) -> Self {
         assert!(
             bytes.len() == size_of::<T>(),
-            "Invalid size of bytes for conversion: {} instead of {}",
-            bytes.len(),
-            size_of::<T>()
+            "Invalid byte count for conversion: expected {} got {}",
+            size_of::<T>(),
+            bytes.len()
         );
 
         let mut data: MaybeUninit<T> = core::mem::MaybeUninit::uninit();
@@ -261,12 +261,19 @@ mod tests {
     #[derive(Copy, Clone, Debug, PartialEq)]
     #[repr(C)]
     struct MyStruct {
-        a: usize,
-        b: usize,
+        a: u32,
+        b: u32,
     }
 
     #[test]
     fn test_byteconvertible() {
+        let raw = [2_u8, 1_u8];
+        let data = u16::from_bytes(&raw);
+        assert_eq!(258, data);
+
+        let bytes = data.to_bytes();
+        assert_eq!(raw, bytes.as_slice());
+
         let data = 0b1000_1010_u8;
         let bytes = data.to_bytes();
         let decrypted = u8::from_bytes(&bytes);
@@ -285,10 +292,10 @@ mod tests {
     }
 
     #[test]
-    #[should_panic = "Invalid size of bytes for conversion: 2 instead of 1"]
+    #[should_panic = "Invalid byte count for conversion: expected 8 got 1"]
     fn test_byteconvertible_panic() {
-        let bytes = [0u8; 2];
-        let _ = u8::from_bytes(&bytes);
+        let bytes = [0u8; 1];
+        let _ = MyStruct::from_bytes(&bytes);
     }
 
     #[test]

src/context.rs

@@ -443,6 +443,18 @@ impl Context {
 mod tests {
     use super::*;
 
+    #[test]
+    #[should_panic = "Delta must be strictly less than d"]
+    fn test_parameters_delta_panic() {
+        let _ = Parameters::new(6, 3, 6, 5);
+    }
+
+    #[test]
+    #[should_panic = "Parameters must be strictly positive"]
+    fn test_parameters_null_panic() {
+        let _ = Parameters::new(6, 0, 2, 5);
+    }
+
     #[test]
     fn test_secret_key() {
         let s = vec![5, 14, 8];

src/operations.rs

@@ -155,7 +155,7 @@ pub trait HomomorphicOperation2<T: ByteConvertible> {
 /// impl<const N: usize> HomomorphicOperation<N, MyStruct> for MyOperation {
 ///     /// ## Safety
 ///     ///
-///     /// `d/delta` on cipher must have been at least `18*sizeof::<T>()`.
+///     /// `d/delta` on cipher must have been at least `3*sizeof::<T>()`.
 ///     unsafe fn apply(args: [&Ciphered<MyStruct>; N]) -> Ciphered<MyStruct> {
 ///         let result = args[0].deref().clone();
 ///
@@ -166,7 +166,7 @@ pub trait HomomorphicOperation2<T: ByteConvertible> {
 /// }
 ///
 /// // Usage
-/// let params = Parameters::new(128, 128, 1, 128);
+/// let params = Parameters::new(32, 8, 4, 8);
 /// let mut context = Context::new(params);
 /// context.generate_secret_key();
 /// context.generate_public_key();