1use backend::{
  2    hal::{api::ModuleNew, layouts::Module},
  3    implementation::cpu_spqlios::FFT64,
  4};
  5
  6use crate::glwe::tests::{
  7    generic_automorphism::{test_automorphism, test_automorphism_inplace},
  8    generic_encryption::{test_encrypt_pk, test_encrypt_sk, test_encrypt_sk_compressed, test_encrypt_zero_sk},
  9    generic_external_product::{test_external_product, test_external_product_inplace},
 10    generic_keyswitch::{test_keyswitch, test_keyswitch_inplace},
 11    generic_serialization::{test_serialization, test_serialization_compressed},
 12    packing::test_packing,
 13    trace::test_trace_inplace,
 14};
 15
 16#[test]
 17fn encrypt_sk() {
 18    let log_n: usize = 8;
 19    let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n);
 20    (1..4).for_each(|rank| {
 21        println!("test encrypt_sk rank: {}", rank);
 22        test_encrypt_sk(&module, 8, 54, 30, 3.2, rank);
 23    });
 24}
 25
 26#[test]
 27fn encrypt_sk_compressed() {
 28    let log_n: usize = 8;
 29    let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n);
 30    (1..4).for_each(|rank| {
 31        println!("test encrypt_sk rank: {}", rank);
 32        test_encrypt_sk_compressed(&module, 8, 54, 30, 3.2, rank);
 33    });
 34}
 35
 36#[test]
 37fn encrypt_zero_sk() {
 38    let log_n: usize = 8;
 39    let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n);
 40    (1..4).for_each(|rank| {
 41        println!("test encrypt_zero_sk rank: {}", rank);
 42        test_encrypt_zero_sk(&module, 8, 64, 3.2, rank);
 43    });
 44}
 45
 46#[test]
 47fn encrypt_pk() {
 48    let log_n: usize = 8;
 49    let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n);
 50    (1..4).for_each(|rank| {
 51        println!("test encrypt_pk rank: {}", rank);
 52        test_encrypt_pk(&module, 8, 64, 64, 3.2, rank)
 53    });
 54}
 55
 56#[test]
 57fn apply() {
 58    let log_n: usize = 8;
 59    let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n);
 60    let basek: usize = 12;
 61    let k_in: usize = 45;
 62    let digits: usize = k_in.div_ceil(basek);
 63    (1..4).for_each(|rank_in| {
 64        (1..4).for_each(|rank_out| {
 65            (1..digits + 1).for_each(|di| {
 66                let k_ksk: usize = k_in + basek * di;
 67                let k_out: usize = k_ksk; // better capture noise
 68                println!(
 69                    "test keyswitch digits: {} rank_in: {} rank_out: {}",
 70                    di, rank_in, rank_out
 71                );
 72                test_keyswitch(
 73                    &module, basek, k_out, k_in, k_ksk, di, rank_in, rank_out, 3.2,
 74                );
 75            })
 76        });
 77    });
 78}
 79
 80#[test]
 81fn apply_inplace() {
 82    let log_n: usize = 8;
 83    let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n);
 84    let basek: usize = 12;
 85    let k_ct: usize = 45;
 86    let digits: usize = k_ct.div_ceil(basek);
 87    (1..4).for_each(|rank| {
 88        (1..digits + 1).for_each(|di| {
 89            let k_ksk: usize = k_ct + basek * di;
 90            println!("test keyswitch_inplace digits: {} rank: {}", di, rank);
 91            test_keyswitch_inplace(&module, basek, k_ct, k_ksk, di, rank, 3.2);
 92        });
 93    });
 94}
 95
 96#[test]
 97fn automorphism_inplace() {
 98    let log_n: usize = 8;
 99    let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n);
100    let basek: usize = 12;
101    let k_ct: usize = 60;
102    let digits: usize = k_ct.div_ceil(basek);
103    (1..4).for_each(|rank| {
104        (1..digits + 1).for_each(|di| {
105            let k_ksk: usize = k_ct + basek * di;
106            println!("test automorphism_inplace digits: {} rank: {}", di, rank);
107            test_automorphism_inplace(&module, basek, -5, k_ct, k_ksk, di, rank, 3.2);
108        });
109    });
110}
111
112#[test]
113fn automorphism() {
114    let log_n: usize = 8;
115    let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n);
116    let basek: usize = 12;
117    let k_in: usize = 60;
118    let digits: usize = k_in.div_ceil(basek);
119    (1..4).for_each(|rank| {
120        (1..digits + 1).for_each(|di| {
121            let k_ksk: usize = k_in + basek * di;
122            let k_out: usize = k_ksk; // Better capture noise.
123            println!("test automorphism digits: {} rank: {}", di, rank);
124            test_automorphism(&module, basek, -5, k_out, k_in, k_ksk, di, rank, 3.2);
125        })
126    });
127}
128
129#[test]
130fn external_product() {
131    let log_n: usize = 8;
132    let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n);
133    let basek: usize = 12;
134    let k_in: usize = 45;
135    let digits: usize = k_in.div_ceil(basek);
136    (1..4).for_each(|rank| {
137        (1..digits + 1).for_each(|di| {
138            let k_ggsw: usize = k_in + basek * di;
139            let k_out: usize = k_ggsw; // Better capture noise
140            println!("test external_product digits: {} rank: {}", di, rank);
141            test_external_product(&module, basek, k_out, k_in, k_ggsw, di, rank, 3.2);
142        });
143    });
144}
145
146#[test]
147fn external_product_inplace() {
148    let log_n: usize = 8;
149    let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n);
150    let basek: usize = 12;
151    let k_ct: usize = 60;
152    let digits: usize = k_ct.div_ceil(basek);
153    (1..4).for_each(|rank| {
154        (1..digits + 1).for_each(|di| {
155            let k_ggsw: usize = k_ct + basek * di;
156            println!("test external_product digits: {} rank: {}", di, rank);
157            test_external_product_inplace(&module, basek, k_ct, k_ggsw, di, rank, 3.2);
158        });
159    });
160}
161
162#[test]
163fn trace_inplace() {
164    let log_n: usize = 8;
165    let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n);
166    (1..4).for_each(|rank| {
167        println!("test trace_inplace rank: {}", rank);
168        test_trace_inplace(&module, 8, 54, 3.2, rank);
169    });
170}
171
172#[test]
173fn packing() {
174    let log_n: usize = 5;
175    let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n);
176    test_packing(&module);
177}
178
179#[test]
180fn serialization() {
181    let log_n: usize = 5;
182    let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n);
183    test_serialization(&module);
184}
185
186#[test]
187fn serialization_compressed() {
188    let log_n: usize = 5;
189    let module: Module<FFT64> = Module::<FFT64>::new(1 << log_n);
190    test_serialization_compressed(&module);
191}