first commit

bigpiseal3.5.1/dotnet/tests/CiphertextTests.cs

+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT license.
+
+using Microsoft.Research.SEAL;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Numerics;
+
+namespace SEALNetTest
+{
+    [TestClass]
+    public class CiphertextTests
+    {
+        [TestMethod]
+        public void CreateTest()
+        {
+            Ciphertext cipher = new Ciphertext();
+            Assert.IsNotNull(cipher);
+            Assert.AreEqual(0ul, cipher.Size);
+            Assert.AreEqual(0ul, cipher.PolyModulusDegree);
+            Assert.AreEqual(0ul, cipher.CoeffModulusSize);
+
+            Ciphertext copy = new Ciphertext(cipher);
+            Assert.IsNotNull(copy);
+            Assert.AreEqual(0ul, copy.Size);
+            Assert.AreEqual(0ul, copy.PolyModulusDegree);
+            Assert.AreEqual(0ul, copy.CoeffModulusSize);
+        }
+
+        [TestMethod]
+        public void Create2Test()
+        {
+            SEALContext context = GlobalContext.BFVContext;
+            ParmsId parms = context.FirstParmsId;
+
+            Assert.AreNotEqual(0ul, parms.Block[0]);
+            Assert.AreNotEqual(0ul, parms.Block[1]);
+            Assert.AreNotEqual(0ul, parms.Block[2]);
+            Assert.AreNotEqual(0ul, parms.Block[3]);
+
+            Ciphertext cipher = new Ciphertext(context, parms);
+
+            Assert.AreEqual(parms, cipher.ParmsId);
+        }
+
+        [TestMethod]
+        public void Create3Test()
+        {
+            SEALContext context = GlobalContext.BFVContext;
+            ParmsId parms = context.FirstParmsId;
+
+            Assert.AreNotEqual(0ul, parms.Block[0]);
+            Assert.AreNotEqual(0ul, parms.Block[1]);
+            Assert.AreNotEqual(0ul, parms.Block[2]);
+            Assert.AreNotEqual(0ul, parms.Block[3]);
+
+            Ciphertext cipher = new Ciphertext(context, parms, sizeCapacity: 5);
+
+            Assert.AreEqual(5ul, cipher.SizeCapacity);
+        }
+
+        [TestMethod]
+        public void ResizeTest()
+        {
+            SEALContext context = GlobalContext.BFVContext;
+            ParmsId parms = context.FirstParmsId;
+
+            Ciphertext cipher = new Ciphertext(context, parms);
+
+            Assert.AreEqual(2ul, cipher.SizeCapacity);
+
+            cipher.Reserve(context, parms, sizeCapacity: 10);
+            Assert.AreEqual(10ul, cipher.SizeCapacity);
+
+            Ciphertext cipher2 = new Ciphertext();
+
+            Assert.AreEqual(0ul, cipher2.SizeCapacity);
+
+            cipher2.Reserve(context, 5);
+            Assert.AreEqual(5ul, cipher2.SizeCapacity);
+
+            Ciphertext cipher3 = new Ciphertext();
+
+            Assert.AreEqual(0ul, cipher3.SizeCapacity);
+
+            cipher3.Reserve(4);
+            Assert.AreEqual(0ul, cipher3.SizeCapacity);
+
+            Ciphertext cipher4 = new Ciphertext(context);
+            cipher4.Resize(context, context.GetContextData(context.FirstParmsId).NextContextData.ParmsId, 4);
+            Assert.AreEqual(10ul, cipher.SizeCapacity);
+
+            Ciphertext cipher5 = new Ciphertext(context);
+            cipher5.Resize(context, 6ul);
+            Assert.AreEqual(6ul, cipher5.SizeCapacity);
+        }
+
+        [TestMethod]
+        public void ReleaseTest()
+        {
+            Ciphertext cipher = new Ciphertext();
+
+            Assert.AreEqual(0ul, cipher.Size);
+            cipher.Resize(4);
+            Assert.AreEqual(4ul, cipher.Size);
+            cipher.Release();
+            Assert.AreEqual(0ul, cipher.Size);
+        }
+
+        [TestMethod]
+        public void SaveLoadTest()
+        {
+            SEALContext context = GlobalContext.BFVContext;
+            KeyGenerator keygen = new KeyGenerator(context);
+            Encryptor encryptor = new Encryptor(context, keygen.PublicKey);
+            Plaintext plain = new Plaintext("2x^3 + 4x^2 + 5x^1 + 6");
+            Ciphertext cipher = new Ciphertext();
+
+            encryptor.Encrypt(plain, cipher);
+
+            Assert.AreEqual(2ul, cipher.Size);
+            Assert.AreEqual(8192ul, cipher.PolyModulusDegree);
+            Assert.AreEqual(4ul, cipher.CoeffModulusSize);
+
+            Ciphertext loaded = new Ciphertext();
+
+            Assert.AreEqual(0ul, loaded.Size);
+            Assert.AreEqual(0ul, loaded.PolyModulusDegree);
+            Assert.AreEqual(0ul, loaded.CoeffModulusSize);
+
+            using (MemoryStream mem = new MemoryStream())
+            {
+                cipher.Save(mem);
+
+                mem.Seek(offset: 0, loc: SeekOrigin.Begin);
+
+                loaded.Load(context, mem);
+            }
+
+            Assert.AreEqual(2ul, loaded.Size);
+            Assert.AreEqual(8192ul, loaded.PolyModulusDegree);
+            Assert.AreEqual(4ul, loaded.CoeffModulusSize);
+            Assert.IsTrue(ValCheck.IsValidFor(loaded, context));
+
+            ulong ulongCount = cipher.Size * cipher.PolyModulusDegree * cipher.CoeffModulusSize;
+            for (ulong i = 0; i < ulongCount; i++)
+            {
+                Assert.AreEqual(cipher[i], loaded[i]);
+            }
+        }
+
+        [TestMethod]
+        public void IndexTest()
+        {
+            SEALContext context = GlobalContext.BFVContext;
+            KeyGenerator keygen = new KeyGenerator(context);
+            Encryptor encryptor = new Encryptor(context, keygen.PublicKey);
+            Plaintext plain = new Plaintext("1");
+            Ciphertext cipher = new Ciphertext();
+
+            encryptor.Encrypt(plain, cipher);
+
+            Assert.AreEqual(2ul, cipher.Size);
+            Assert.AreNotEqual(0ul, cipher[0, 0]);
+            Assert.AreNotEqual(0ul, cipher[0, 1]);
+            Assert.AreNotEqual(0ul, cipher[0, 2]);
+            Assert.AreNotEqual(0ul, cipher[1, 0]);
+            Assert.AreNotEqual(0ul, cipher[1, 1]);
+            Assert.AreNotEqual(0ul, cipher[1, 2]);
+        }
+
+        [TestMethod]
+        public void IndexRangeFail1Test()
+        {
+            SEALContext context = GlobalContext.BFVContext;
+            KeyGenerator keygen = new KeyGenerator(context);
+            Encryptor encryptor = new Encryptor(context, keygen.PublicKey);
+            Plaintext plain = new Plaintext("1");
+            Ciphertext cipher = new Ciphertext(context);
+
+            encryptor.Encrypt(plain, cipher);
+
+            Utilities.AssertThrows<IndexOutOfRangeException>(() =>
+            {
+                // We only have 2 polynomials
+                ulong data = cipher[2, 0];
+            });
+        }
+
+        [TestMethod]
+        public void IndexRangeFail2Test()
+        {
+            SEALContext context = GlobalContext.BFVContext;
+            KeyGenerator keygen = new KeyGenerator(context);
+            Encryptor encryptor = new Encryptor(context, keygen.PublicKey);
+            Plaintext plain = new Plaintext("1");
+            Ciphertext cipher = new Ciphertext();
+
+            encryptor.Encrypt(plain, cipher);
+
+            // We only have 2 polynomials
+            ulong data = cipher[1, 0];
+
+            // We should have 8192 coefficients
+            data = cipher[0, 32767]; // This will succeed
+
+            Utilities.AssertThrows<IndexOutOfRangeException>(() =>
+            {
+                data = cipher[0, 32768]; // This will fail
+            });
+        }
+
+        [TestMethod]
+        public void IndexRangeFail3Test()
+        {
+            SEALContext context = GlobalContext.BFVContext;
+            KeyGenerator keygen = new KeyGenerator(context);
+            Encryptor encryptor = new Encryptor(context, keygen.PublicKey);
+            Plaintext plain = new Plaintext("1");
+            Ciphertext cipher = new Ciphertext();
+
+            encryptor.Encrypt(plain, cipher);
+            ulong data = 0;
+
+            Utilities.AssertThrows<IndexOutOfRangeException>(() => data = cipher[65536]);
+            Utilities.AssertThrows<IndexOutOfRangeException>(() => cipher[65536] = 10ul);
+        }
+
+        [TestMethod]
+        public void ScaleTest()
+        {
+            EncryptionParameters parms = new EncryptionParameters(SchemeType.CKKS)
+            {
+                PolyModulusDegree = 8,
+                CoeffModulus = CoeffModulus.Create(8, new int[] { 40, 40, 40, 40 })
+            };
+            SEALContext context = new SEALContext(parms,
+                expandModChain: true,
+                secLevel: SecLevelType.None);
+            KeyGenerator keygen = new KeyGenerator(context);
+            GaloisKeys galoisKeys = keygen.GaloisKeysLocal();
+            Encryptor encryptor = new Encryptor(context, keygen.PublicKey);
+            Evaluator evaluator = new Evaluator(context);
+            CKKSEncoder encoder = new CKKSEncoder(context);
+
+            MemoryPoolHandle pool = MemoryManager.GetPool(MMProfOpt.ForceNew);
+            Assert.AreEqual(0ul, pool.AllocByteCount);
+
+            Ciphertext encrypted = new Ciphertext(pool);
+            Plaintext plain = new Plaintext();
+
+            MemoryPoolHandle cipherPool = encrypted.Pool;
+            Assert.IsNotNull(cipherPool);
+            Assert.AreEqual(0ul, cipherPool.AllocByteCount);
+
+            List<Complex> input = new List<Complex>()
+            {
+                new Complex(1, 1),
+                new Complex(2, 2),
+                new Complex(3, 3),
+                new Complex(4, 4)
+            };
+            double delta = Math.Pow(2, 70);
+            encoder.Encode(input, context.FirstParmsId, delta, plain);
+            encryptor.Encrypt(plain, encrypted);
+
+            Assert.AreEqual(delta, encrypted.Scale, delta: Math.Pow(2, 60));
+
+            Ciphertext encrypted2 = new Ciphertext();
+            encrypted2.Set(encrypted);
+            Assert.AreEqual(delta, encrypted2.Scale, delta: Math.Pow(2, 60));
+
+            evaluator.RescaleToNextInplace(encrypted);
+
+            Assert.AreEqual(Math.Pow(2, 30), encrypted.Scale, delta: 10000);
+            Assert.AreNotEqual(0ul, cipherPool.AllocByteCount);
+
+            double newScale = Math.Pow(2, 10);
+            encrypted.Scale = newScale;
+            Assert.AreEqual(newScale, encrypted.Scale, delta: 100);
+        }
+
+        [TestMethod]
+        public void ExceptionsTest()
+        {
+            SEALContext context = GlobalContext.BFVContext;
+            MemoryPoolHandle pool = MemoryManager.GetPool(MMProfOpt.ForceGlobal);
+            MemoryPoolHandle poolu = new MemoryPoolHandle();
+            Ciphertext cipher = new Ciphertext();
+            Ciphertext copy = null;
+
+            Utilities.AssertThrows<ArgumentNullException>(() => copy = new Ciphertext((Ciphertext)null));
+
+            Utilities.AssertThrows<ArgumentNullException>(() => cipher = new Ciphertext(context, null, pool));
+            Utilities.AssertThrows<ArgumentNullException>(() => cipher = new Ciphertext(null, context.FirstParmsId, pool));
+            Utilities.AssertThrows<ArgumentException>(() => cipher = new Ciphertext(context, ParmsId.Zero, pool));
+
+            Utilities.AssertThrows<ArgumentNullException>(() => cipher = new Ciphertext((SEALContext)null, poolu));
+            Utilities.AssertThrows<ArgumentException>(() => cipher = new Ciphertext(context, poolu));
+
+            Utilities.AssertThrows<ArgumentNullException>(() => cipher = new Ciphertext(context, null, 6ul));
+            Utilities.AssertThrows<ArgumentNullException>(() => cipher = new Ciphertext(null, context.FirstParmsId, 6ul, poolu));
+            Utilities.AssertThrows<ArgumentException>(() => cipher = new Ciphertext(context, ParmsId.Zero, 6ul, poolu));
+
+            Utilities.AssertThrows<ArgumentNullException>(() => cipher.Reserve(context, null, 10ul));
+            Utilities.AssertThrows<ArgumentNullException>(() => cipher.Reserve(null, ParmsId.Zero, 10ul));
+            Utilities.AssertThrows<ArgumentException>(() => cipher.Reserve(context, ParmsId.Zero, 10ul));
+
+            Utilities.AssertThrows<ArgumentNullException>(() => cipher.Reserve(null, 10ul));
+
+            Utilities.AssertThrows<ArgumentNullException>(() => cipher.Resize(context, null, 10ul));
+            Utilities.AssertThrows<ArgumentNullException>(() => cipher.Resize(null, ParmsId.Zero, 10ul));
+            Utilities.AssertThrows<ArgumentException>(() => cipher.Resize(context, ParmsId.Zero, 10ul));
+
+            Utilities.AssertThrows<ArgumentNullException>(() => cipher.Resize(null, 10ul));
+
+            Utilities.AssertThrows<ArgumentNullException>(() => cipher.Set(null));
+
+            Utilities.AssertThrows<ArgumentNullException>(() => ValCheck.IsValidFor(cipher, null));
+
+            Utilities.AssertThrows<ArgumentNullException>(() => cipher.Save(null));
+
+            Utilities.AssertThrows<ArgumentNullException>(() => cipher.UnsafeLoad(context, null));
+            Utilities.AssertThrows<ArgumentNullException>(() => cipher.UnsafeLoad(null, new MemoryStream()));
+            Utilities.AssertThrows<EndOfStreamException>(() => cipher.UnsafeLoad(context, new MemoryStream()));
+
+            Utilities.AssertThrows<ArgumentNullException>(() => cipher.Load(null, new MemoryStream()));
+            Utilities.AssertThrows<ArgumentNullException>(() => cipher.Load(context, null));
+        }
+    }
+}

bigpiseal3.5.1/dotnet/tests/DecryptorTests.cs

+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT license.
+
+using Microsoft.Research.SEAL;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using System;
+
+namespace SEALNetTest
+{
+    [TestClass]
+    public class DecryptorTests
+    {
+        SEALContext context_;
+        KeyGenerator keyGen_;
+        SecretKey secretKey_;
+        PublicKey publicKey_;
+
+        [TestInitialize]
+        public void TestInit()
+        {
+            context_ = GlobalContext.BFVContext;
+            keyGen_ = new KeyGenerator(context_);
+            secretKey_ = keyGen_.SecretKey;
+            publicKey_ = keyGen_.PublicKey;
+        }
+
+        [TestMethod]
+        public void CreateTest()
+        {
+            Decryptor decryptor = new Decryptor(context_, secretKey_);
+
+            Assert.IsNotNull(decryptor);
+        }
+
+        [TestMethod]
+        public void DecryptTest()
+        {
+            Encryptor encryptor = new Encryptor(context_, publicKey_);
+            Decryptor decryptor = new Decryptor(context_, secretKey_);
+
+            Plaintext plain = new Plaintext("1x^1 + 2");
+            Ciphertext cipher = new Ciphertext();
+
+            Assert.AreEqual(0ul, cipher.Size);
+
+            encryptor.Encrypt(plain, cipher);
+
+            Assert.AreEqual(2ul, cipher.Size);
+
+            Plaintext decrypted = new Plaintext();
+            Assert.AreEqual(0ul, decrypted.CoeffCount);
+
+            decryptor.Decrypt(cipher, decrypted);
+
+            Assert.AreEqual(2ul, decrypted.CoeffCount);
+            Assert.AreEqual(2ul, decrypted[0]);
+            Assert.AreEqual(1ul, decrypted[1]);
+        }
+
+        [TestMethod]
+        public void InvariantNoiseBudgetTest()
+        {
+            Encryptor encryptor = new Encryptor(context_, publicKey_);
+            Decryptor decryptor = new Decryptor(context_, secretKey_);
+
+            Plaintext plain = new Plaintext("1");
+            Ciphertext cipher = new Ciphertext();
+
+            encryptor.Encrypt(plain, cipher);
+
+            int budget = decryptor.InvariantNoiseBudget(cipher);
+            Assert.IsTrue(budget > 80);
+        }
+
+        [TestMethod]
+        public void ExceptionsTest()
+        {
+            Decryptor decryptor = new Decryptor(context_, secretKey_);
+            SecretKey secret = new SecretKey();
+            Ciphertext cipher = new Ciphertext();
+            Plaintext plain = new Plaintext();
+
+            Utilities.AssertThrows<ArgumentNullException>(() => decryptor = new Decryptor(context_, null));
+            Utilities.AssertThrows<ArgumentNullException>(() => decryptor = new Decryptor(null, secretKey_));
+            Utilities.AssertThrows<ArgumentException>(() => decryptor = new Decryptor(context_, secret));
+
+            Utilities.AssertThrows<ArgumentNullException>(() => decryptor.Decrypt(cipher, null));
+            Utilities.AssertThrows<ArgumentNullException>(() => decryptor.Decrypt(null, plain));
+            Utilities.AssertThrows<ArgumentException>(() => decryptor.Decrypt(cipher, plain));
+
+            Utilities.AssertThrows<ArgumentNullException>(() => decryptor.InvariantNoiseBudget(null));
+        }
+    }
+}

bigpiseal3.5.1/dotnet/tests/EncryptionParameterQualifiersTests.cs

+using Microsoft.Research.SEAL;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace SEALNetTest
+{
+    [TestClass]
+    public class EncryptionParameterQualifiersTests
+    {
+        [TestMethod]
+        public void PropertiesTest()
+        {
+            SEALContext context = GlobalContext.BFVContext;
+
+            Assert.IsTrue(context.FirstContextData.Qualifiers.ParametersSet);
+            Assert.IsTrue(context.FirstContextData.Qualifiers.UsingBatching);
+            Assert.IsTrue(context.FirstContextData.Qualifiers.UsingFastPlainLift);
+            Assert.IsTrue(context.FirstContextData.Qualifiers.UsingFFT);
+            Assert.AreEqual(SecLevelType.TC128, context.FirstContextData.Qualifiers.SecLevel);
+            Assert.IsFalse(context.FirstContextData.Qualifiers.UsingDescendingModulusChain);
+            Assert.IsTrue(context.FirstContextData.Qualifiers.UsingNTT);
+            Assert.IsTrue(context.UsingKeyswitching);
+
+            EncryptionParameters parms = new EncryptionParameters(SchemeType.CKKS)
+            {
+                PolyModulusDegree = 4096,
+                CoeffModulus = CoeffModulus.BFVDefault(4096)
+            };
+
+            SEALContext context2 = new SEALContext(parms);
+
+            Assert.IsTrue(context2.FirstContextData.Qualifiers.ParametersSet);
+            Assert.IsTrue(context2.FirstContextData.Qualifiers.UsingBatching);
+            Assert.IsFalse(context2.FirstContextData.Qualifiers.UsingFastPlainLift);
+            Assert.IsTrue(context2.FirstContextData.Qualifiers.UsingFFT);
+            Assert.AreEqual(SecLevelType.TC128, context2.FirstContextData.Qualifiers.SecLevel);
+            Assert.IsFalse(context.FirstContextData.Qualifiers.UsingDescendingModulusChain);
+            Assert.IsTrue(context2.FirstContextData.Qualifiers.UsingNTT);
+            Assert.IsTrue(context.UsingKeyswitching);
+
+            EncryptionParameterQualifiers qualifiers = new EncryptionParameterQualifiers(context2.FirstContextData.Qualifiers);
+
+            Assert.IsNotNull(qualifiers);
+            Assert.IsTrue(qualifiers.ParametersSet);
+            Assert.IsTrue(qualifiers.UsingBatching);
+            Assert.IsFalse(qualifiers.UsingFastPlainLift);
+            Assert.IsTrue(qualifiers.UsingFFT);
+            Assert.AreEqual(SecLevelType.TC128, qualifiers.SecLevel);
+            Assert.IsTrue(qualifiers.UsingDescendingModulusChain);
+            Assert.IsTrue(qualifiers.UsingNTT);
+        }
+
+        [TestMethod]
+        public void ParameterErrorTest()
+        {
+            SEALContext context = GlobalContext.BFVContext;
+            EncryptionParameterQualifiers qualifiers = context.FirstContextData.Qualifiers;
+
+            Assert.AreEqual(qualifiers.ParametersErrorName(), "success");
+            Assert.AreEqual(qualifiers.ParametersErrorMessage(), "valid");
+
+            EncryptionParameters encParam = new EncryptionParameters(SchemeType.BFV)
+            {
+                PolyModulusDegree = 127,
+                PlainModulus = new Modulus(1 << 6),
+                CoeffModulus = CoeffModulus.Create(128, new int[] { 30, 30, 30 })
+            };
+            context = new SEALContext(encParam, expandModChain: true, secLevel: SecLevelType.None);
+            qualifiers = context.FirstContextData.Qualifiers;
+            Assert.AreEqual(qualifiers.ParametersErrorName(), "invalid_poly_modulus_degree_non_power_of_two");
+            Assert.AreEqual(qualifiers.ParametersErrorMessage(), "poly_modulus_degree is not a power of two");
+        }
+
+        [TestMethod]
+        public void ExceptionsTest()
+        {
+            EncryptionParameterQualifiers epq1 = GlobalContext.BFVContext.FirstContextData.Qualifiers;
+            EncryptionParameterQualifiers epq2 = null;
+
+            Utilities.AssertThrows<ArgumentNullException>(() => epq2 = new EncryptionParameterQualifiers(null));
+        }
+    }
+}

bigpiseal3.5.1/dotnet/tests/EncryptionParametersTests.cs

+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT license.
+
+using Microsoft.Research.SEAL;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using System;
+using System.Collections.Generic;
+using System.IO;
+
+namespace SEALNetTest
+{
+    public delegate void TestDelegate(SchemeType scheme);
+
+    [TestClass]
+    public class EncryptionParametersTests
+    {
+        [TestMethod]
+        public void CreateTest()
+        {
+            EncryptionParameters encParams = new EncryptionParameters(SchemeType.BFV);
+
+            Assert.IsNotNull(encParams);
+            Assert.AreEqual(SchemeType.BFV, encParams.Scheme);
+
+            EncryptionParameters encParams2 = new EncryptionParameters(SchemeType.CKKS);
+
+            Assert.IsNotNull(encParams2);
+            Assert.AreEqual(SchemeType.CKKS, encParams2.Scheme);
+
+            EncryptionParameters encParams3 = new EncryptionParameters(SchemeType.CKKS);
+
+            Assert.IsNotNull(encParams3);
+            Assert.AreEqual(SchemeType.CKKS, encParams3.Scheme);
+
+            EncryptionParameters copy = new EncryptionParameters(encParams);
+
+            Assert.AreEqual(SchemeType.BFV, copy.Scheme);
+            Assert.AreEqual(encParams, copy);
+            Assert.AreEqual(encParams.GetHashCode(), copy.GetHashCode());
+
+            EncryptionParameters third = new EncryptionParameters(SchemeType.CKKS);
+            third.Set(copy);
+
+            Assert.AreEqual(SchemeType.BFV, third.Scheme);
+            Assert.AreEqual(encParams, third);
+            Assert.AreEqual(encParams.GetHashCode(), third.GetHashCode());
+        }
+
+        [TestMethod]
+        public void SetPlainModulusCKKSTest()
+        {
+            EncryptionParameters parms = new EncryptionParameters(SchemeType.CKKS);
+
+            Utilities.AssertThrows<InvalidOperationException>(() =>
+            {
+                parms.PlainModulus = new Modulus(8192);
+            });
+
+            Utilities.AssertThrows<InvalidOperationException>(() =>
+            {
+                parms.SetPlainModulus(8192);
+            });
+        }
+
+        [TestMethod]
+        public void CoeffModulusTest()
+        {
+            EncryptionParameters encParams = new EncryptionParameters(SchemeType.BFV);
+
+            Assert.IsNotNull(encParams);
+
+            List<Modulus> coeffs = new List<Modulus>(encParams.CoeffModulus);
+            Assert.IsNotNull(coeffs);
+            Assert.AreEqual(0, coeffs.Count);
+
+            encParams.CoeffModulus = CoeffModulus.BFVDefault(4096);
+
+            List<Modulus> newCoeffs = new List<Modulus>(encParams.CoeffModulus);
+            Assert.IsNotNull(newCoeffs);
+            Assert.AreEqual(3, newCoeffs.Count);
+            Assert.AreEqual(0xffffee001ul, newCoeffs[0].Value);
+            Assert.AreEqual(0xffffc4001ul, newCoeffs[1].Value);
+            Assert.AreEqual(0x1ffffe0001ul, newCoeffs[2].Value);
+        }
+
+        [TestMethod]
+        public void SaveLoadTest()
+        {
+            TestDelegate save_load_test = delegate(SchemeType scheme)
+            {
+                List<Modulus> coeffModulus = (List<Modulus>)CoeffModulus.Create(8, new int[] { 40, 40 });
+                EncryptionParameters parms = new EncryptionParameters(scheme)
+                {
+                    PolyModulusDegree = 8,
+                    CoeffModulus = coeffModulus
+                };
+                if (scheme == SchemeType.BFV)
+                    parms.SetPlainModulus(257);
+
+                EncryptionParameters loaded = new EncryptionParameters();
+
+                using (MemoryStream stream = new MemoryStream())
+                {
+                    parms.Save(stream);
+                    stream.Seek(offset: 0, loc: SeekOrigin.Begin);
+                    loaded.Load(stream);
+                }
+
+                Assert.AreEqual(scheme, loaded.Scheme);
+                Assert.AreEqual(8ul, loaded.PolyModulusDegree);
+                if (scheme == SchemeType.BFV)
+                    Assert.AreEqual(257ul, loaded.PlainModulus.Value);
+                else if (scheme == SchemeType.CKKS)
+                    Assert.AreEqual(0ul, loaded.PlainModulus.Value);
+
+                List<Modulus> loadedCoeffModulus = new List<Modulus>(loaded.CoeffModulus);
+                Assert.AreEqual(2, loadedCoeffModulus.Count);
+                Assert.AreNotSame(coeffModulus[0], loadedCoeffModulus[0]);
+                Assert.AreNotSame(coeffModulus[1], loadedCoeffModulus[1]);
+                Assert.AreEqual(coeffModulus[0], loadedCoeffModulus[0]);
+                Assert.AreEqual(coeffModulus[1], loadedCoeffModulus[1]);
+            };
+            save_load_test(SchemeType.BFV);
+            save_load_test(SchemeType.CKKS);
+        }
+
+        [TestMethod]
+        public void EqualsTest()
+        {
+            EncryptionParameters parms = new EncryptionParameters(SchemeType.BFV)
+            {
+                PolyModulusDegree = 8,
+                PlainModulus = new Modulus(257),
+                CoeffModulus = CoeffModulus.Create(8, new int[] { 40, 40 })
+            };
+
+            EncryptionParameters parms2 = new EncryptionParameters(SchemeType.CKKS);
+
+            Assert.AreNotEqual(parms, parms2);
+            Assert.IsFalse(parms.Equals(null));
+        }
+
+        [TestMethod]
+        public void ExceptionsTest()
+        {
+            EncryptionParameters parms = new EncryptionParameters(SchemeType.BFV);
+            Utilities.AssertThrows<ArgumentNullException>(() => parms = new EncryptionParameters(null));
+            Utilities.AssertThrows<ArgumentNullException>(() => parms.Set(null));
+            Utilities.AssertThrows<ArgumentNullException>(() => parms.CoeffModulus = null);
+            Utilities.AssertThrows<ArgumentNullException>(() => parms.Save(null));
+            Utilities.AssertThrows<ArgumentNullException>(() => parms.Load(null));
+            Utilities.AssertThrows<EndOfStreamException>(() => parms.Load(new MemoryStream()));
+        }
+    }
+}

bigpiseal3.5.1/dotnet/tests/EncryptorTests.cs

+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT license.
+
+using Microsoft.Research.SEAL;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Numerics;
+
+namespace SEALNetTest
+{
+    [TestClass]
+    public class EncryptorTests
+    {
+        [TestMethod]
+        public void EncryptTest()
+        {
+            {
+                SEALContext context = GlobalContext.BFVContext;
+                KeyGenerator keyGen = new KeyGenerator(context);
+                PublicKey publicKey = keyGen.PublicKey;
+                SecretKey secretKey = keyGen.SecretKey;
+                Encryptor encryptor = new Encryptor(context, publicKey, secretKey);
+
+                Assert.IsNotNull(encryptor);
+
+                Plaintext plain = new Plaintext("1x^1 + 1");
+
+                Ciphertext cipher = new Ciphertext();
+                Assert.AreEqual(0ul, cipher.Size);
+                encryptor.Encrypt(plain, cipher);
+                Assert.IsNotNull(cipher);
+                Assert.AreEqual(2ul, cipher.Size);
+            }
+            {
+                SEALContext context = GlobalContext.BFVContext;
+                KeyGenerator keyGen = new KeyGenerator(context);
+                SecretKey secretKey = keyGen.SecretKey;
+                Encryptor encryptor = new Encryptor(context, secretKey);
+
+                Assert.IsNotNull(encryptor);
+
+                Plaintext plain = new Plaintext("1x^1 + 1");
+
+                Ciphertext cipher = new Ciphertext();
+                Assert.AreEqual(0ul, cipher.Size);
+                encryptor.EncryptSymmetric(plain, cipher);
+                Assert.IsNotNull(cipher);
+                Assert.AreEqual(2ul, cipher.Size);
+            }
+        }
+
+        [TestMethod]
+        public void EncryptZeroTest()
+        {
+            {
+                SEALContext context = GlobalContext.BFVContext;
+                KeyGenerator keyGen = new KeyGenerator(context);
+                PublicKey publicKey = keyGen.PublicKey;
+                SecretKey secretKey = keyGen.SecretKey;
+                Decryptor decryptor = new Decryptor(context, secretKey);
+
+                Assert.IsNotNull(decryptor);
+
+                Ciphertext cipher = new Ciphertext();
+                Plaintext plain = new Plaintext();
+                ParmsId nextParms = context.FirstContextData.NextContextData.ParmsId;
+
+                {
+                    Encryptor encryptor = new Encryptor(context, publicKey);
+                    Assert.IsNotNull(encryptor);
+
+                    encryptor.EncryptZero(cipher);
+                    Assert.IsFalse(cipher.IsNTTForm);
+                    Assert.IsFalse(cipher.IsTransparent);
+                    Assert.AreEqual(cipher.Scale, 1.0, double.Epsilon);
+                    decryptor.Decrypt(cipher, plain);
+                    Assert.IsTrue(plain.IsZero);
+
+                    encryptor.EncryptZero(nextParms, cipher);
+                    Assert.IsFalse(cipher.IsNTTForm);
+                    Assert.IsFalse(cipher.IsTransparent);
+                    Assert.AreEqual(cipher.Scale, 1.0, double.Epsilon);
+                    Assert.AreEqual(cipher.ParmsId, nextParms);
+                    decryptor.Decrypt(cipher, plain);
+                    Assert.IsTrue(plain.IsZero);
+                }
+                {
+                    Encryptor encryptor = new Encryptor(context, secretKey);
+
+                    encryptor.EncryptZeroSymmetric(cipher);
+                    Assert.IsFalse(cipher.IsNTTForm);
+                    Assert.IsFalse(cipher.IsTransparent);
+                    Assert.AreEqual(cipher.Scale, 1.0, double.Epsilon);
+                    decryptor.Decrypt(cipher, plain);
+                    Assert.IsTrue(plain.IsZero);
+
+                    encryptor.EncryptZeroSymmetric(nextParms, cipher);
+                    Assert.IsFalse(cipher.IsNTTForm);
+                    Assert.IsFalse(cipher.IsTransparent);
+                    Assert.AreEqual(cipher.Scale, 1.0, double.Epsilon);
+                    Assert.AreEqual(cipher.ParmsId, nextParms);
+                    decryptor.Decrypt(cipher, plain);
+                    Assert.IsTrue(plain.IsZero);
+                }
+                using (MemoryStream stream = new MemoryStream())
+                {
+                    Encryptor encryptor = new Encryptor(context, secretKey);
+
+                    encryptor.EncryptZeroSymmetric().Save(stream);
+                    stream.Seek(0, SeekOrigin.Begin);
+                    cipher.Load(context, stream);
+                    Assert.IsFalse(cipher.IsNTTForm);
+                    Assert.IsFalse(cipher.IsTransparent);
+                    Assert.AreEqual(cipher.Scale, 1.0, double.Epsilon);
+                    decryptor.Decrypt(cipher, plain);
+                    Assert.IsTrue(plain.IsZero);
+                }
+                using (MemoryStream stream = new MemoryStream())
+                {
+                    Encryptor encryptor = new Encryptor(context, secretKey);
+
+                    encryptor.EncryptZeroSymmetric(nextParms).Save(stream);
+                    stream.Seek(0, SeekOrigin.Begin);
+                    cipher.Load(context, stream);
+                    Assert.IsFalse(cipher.IsNTTForm);
+                    Assert.IsFalse(cipher.IsTransparent);
+                    Assert.AreEqual(cipher.Scale, 1.0, double.Epsilon);
+                    Assert.AreEqual(cipher.ParmsId, nextParms);
+                    decryptor.Decrypt(cipher, plain);
+                    Assert.IsTrue(plain.IsZero);
+                }
+            }
+            {
+                SEALContext context = GlobalContext.CKKSContext;
+                KeyGenerator keyGen = new KeyGenerator(context);
+                PublicKey publicKey = keyGen.PublicKey;
+                SecretKey secretKey = keyGen.SecretKey;
+                Decryptor decryptor = new Decryptor(context, secretKey);
+                CKKSEncoder encoder = new CKKSEncoder(context);
+
+                Assert.IsNotNull(decryptor);
+
+                Ciphertext cipher = new Ciphertext();
+                Plaintext plain = new Plaintext();
+                ParmsId nextParms = context.FirstContextData.NextContextData.ParmsId;
+                List<Complex> res = new List<Complex>();
+
+                {
+                    Encryptor encryptor = new Encryptor(context, publicKey);
+                    Assert.IsNotNull(encryptor);
+
+                    encryptor.EncryptZero(cipher);
+                    Assert.IsTrue(cipher.IsNTTForm);
+                    Assert.IsFalse(cipher.IsTransparent);
+                    Assert.AreEqual(cipher.Scale, 1.0, double.Epsilon);
+                    cipher.Scale = Math.Pow(2.0, 30);
+                    decryptor.Decrypt(cipher, plain);
+
+                    encoder.Decode(plain, res);
+                    foreach (Complex val in res)
+                    {
+                        Assert.AreEqual(val.Real, 0.0, 0.01);
+                        Assert.AreEqual(val.Imaginary, 0.0, 0.01);
+                    }
+
+                    encryptor.EncryptZero(nextParms, cipher);
+                    Assert.IsTrue(cipher.IsNTTForm);
+                    Assert.IsFalse(cipher.IsTransparent);
+                    Assert.AreEqual(cipher.Scale, 1.0, double.Epsilon);
+                    cipher.Scale = Math.Pow(2.0, 30);
+                    Assert.AreEqual(cipher.ParmsId, nextParms);
+                    decryptor.Decrypt(cipher, plain);
+                    Assert.AreEqual(plain.ParmsId, nextParms);
+
+                    encoder.Decode(plain, res);
+                    foreach (Complex val in res)
+                    {
+                        Assert.AreEqual(val.Real, 0.0, 0.01);
+                        Assert.AreEqual(val.Imaginary, 0.0, 0.01);
+                    }
+                }
+                {
+                    Encryptor encryptor = new Encryptor(context, secretKey);
+
+                    encryptor.EncryptZeroSymmetric(cipher);
+                    Assert.IsTrue(cipher.IsNTTForm);
+                    Assert.IsFalse(cipher.IsTransparent);
+                    Assert.AreEqual(cipher.Scale, 1.0, double.Epsilon);
+                    cipher.Scale = Math.Pow(2.0, 30);
+                    decryptor.Decrypt(cipher, plain);
+
+                    encoder.Decode(plain, res);
+                    foreach (Complex val in res)
+                    {
+                        Assert.AreEqual(val.Real, 0.0, 0.01);
+                        Assert.AreEqual(val.Imaginary, 0.0, 0.01);
+                    }
+
+                    encryptor.EncryptZeroSymmetric(nextParms, cipher);
+                    Assert.IsTrue(cipher.IsNTTForm);
+                    Assert.IsFalse(cipher.IsTransparent);
+                    Assert.AreEqual(cipher.Scale, 1.0, double.Epsilon);
+                    cipher.Scale = Math.Pow(2.0, 30);
+                    Assert.AreEqual(cipher.ParmsId, nextParms);
+                    decryptor.Decrypt(cipher, plain);
+                    Assert.AreEqual(plain.ParmsId, nextParms);
+
+                    encoder.Decode(plain, res);
+                    foreach (Complex val in res)
+                    {
+                        Assert.AreEqual(val.Real, 0.0, 0.01);
+                        Assert.AreEqual(val.Imaginary, 0.0, 0.01);
+                    }
+                }
+                using (MemoryStream stream = new MemoryStream())
+                {
+                    Encryptor encryptor = new Encryptor(context, secretKey);
+
+                    encryptor.EncryptZeroSymmetric().Save(stream);
+                    stream.Seek(0, SeekOrigin.Begin);
+                    cipher.Load(context, stream);
+                    Assert.IsTrue(cipher.IsNTTForm);
+                    Assert.IsFalse(cipher.IsTransparent);
+                    Assert.AreEqual(cipher.Scale, 1.0, double.Epsilon);
+                    cipher.Scale = Math.Pow(2.0, 30);
+                    decryptor.Decrypt(cipher, plain);
+
+                    encoder.Decode(plain, res);
+                    foreach (Complex val in res)
+                    {
+                        Assert.AreEqual(val.Real, 0.0, 0.01);
+                        Assert.AreEqual(val.Imaginary, 0.0, 0.01);
+                    }
+                }
+                using (MemoryStream stream = new MemoryStream())
+                {
+                    Encryptor encryptor = new Encryptor(context, secretKey);
+
+                    encryptor.EncryptZeroSymmetric(nextParms).Save(stream);
+                    stream.Seek(0, SeekOrigin.Begin);
+                    cipher.Load(context, stream);
+                    Assert.IsTrue(cipher.IsNTTForm);
+                    Assert.IsFalse(cipher.IsTransparent);
+                    Assert.AreEqual(cipher.Scale, 1.0, double.Epsilon);
+                    cipher.Scale = Math.Pow(2.0, 30);
+                    Assert.AreEqual(cipher.ParmsId, nextParms);
+                    decryptor.Decrypt(cipher, plain);
+                    Assert.AreEqual(plain.ParmsId, nextParms);
+
+                    encoder.Decode(plain, res);
+                    foreach (Complex val in res)
+                    {
+                        Assert.AreEqual(val.Real, 0.0, 0.01);
+                        Assert.AreEqual(val.Imaginary, 0.0, 0.01);
+                    }
+                }
+            }
+        }
+
+        [TestMethod]
+        public void ExceptionsTest()
+        {
+            SEALContext context = GlobalContext.BFVContext;
+            KeyGenerator keygen = new KeyGenerator(context);
+            PublicKey pubKey = keygen.PublicKey;
+            PublicKey pubKey_invalid = new PublicKey();
+            SecretKey secKey = keygen.SecretKey;
+            SecretKey secKey_invalid = new SecretKey();
+            Encryptor encryptor = new Encryptor(context, pubKey);
+            Plaintext plain = new Plaintext();
+            Ciphertext cipher = new Ciphertext();
+            MemoryPoolHandle pool_invalid = new MemoryPoolHandle();
+            ParmsId parmsId_invalid = new ParmsId();
+
+            Utilities.AssertThrows<ArgumentNullException>(() => encryptor = new Encryptor(context, null));
+            Utilities.AssertThrows<ArgumentNullException>(() => encryptor = new Encryptor(null, pubKey));
+            Utilities.AssertThrows<ArgumentException>(() => encryptor = new Encryptor(context, pubKey_invalid));
+            Utilities.AssertThrows<ArgumentException>(() => encryptor = new Encryptor(context, pubKey_invalid, secKey));
+            encryptor = new Encryptor(context, pubKey, secKey);
+            Utilities.AssertThrows<ArgumentException>(() => encryptor.SetPublicKey(pubKey_invalid));
+            Utilities.AssertThrows<ArgumentException>(() => encryptor.SetSecretKey(secKey_invalid));
+
+            Utilities.AssertThrows<ArgumentNullException>(() => encryptor.Encrypt(plain, null));
+            Utilities.AssertThrows<ArgumentNullException>(() => encryptor.Encrypt(null, cipher));
+            Utilities.AssertThrows<ArgumentException>(() => encryptor.Encrypt(plain, cipher, pool_invalid));
+            Utilities.AssertThrows<ArgumentException>(() => encryptor.EncryptZero(cipher, pool_invalid));
+            Utilities.AssertThrows<ArgumentException>(() => encryptor.EncryptZero(parmsId_invalid, cipher));
+
+            Utilities.AssertThrows<ArgumentNullException>(() => encryptor.EncryptSymmetric(plain, destination: null));
+            Utilities.AssertThrows<ArgumentNullException>(() => encryptor.EncryptSymmetric(null, cipher));
+            Utilities.AssertThrows<ArgumentException>(() => encryptor.EncryptSymmetric(plain, cipher, pool_invalid));
+            Utilities.AssertThrows<ArgumentException>(() => encryptor.EncryptZeroSymmetric(cipher, pool_invalid));
+            Utilities.AssertThrows<ArgumentException>(() => encryptor.EncryptZeroSymmetric(parmsId_invalid, cipher));
+
+            Utilities.AssertThrows<ArgumentNullException>(() => encryptor.EncryptSymmetric(plain).Save(null));
+            Utilities.AssertThrows<ArgumentNullException>(() => encryptor.EncryptZeroSymmetric().Save(null));
+        }
+    }
+}

bigpiseal3.5.1/dotnet/tests/EvaluatorTests.cs

+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT license.
+
+using Microsoft.Research.SEAL;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Numerics;
+
+namespace SEALNetTest
+{
+    [TestClass]
+    public class EvaluatorTests
+    {
+        [TestMethod]
+        public void CreateTest()
+        {
+            Evaluator evaluator = new Evaluator(GlobalContext.BFVContext);
+            Assert.IsNotNull(evaluator);
+        }
+
+        [TestMethod]
+        public void NegateTest()
+        {
+            EncryptionParameters parms = new EncryptionParameters(SchemeType.BFV)
+            {
+                PolyModulusDegree = 64,
+                PlainModulus = new Modulus(1 << 6),
+                CoeffModulus = CoeffModulus.Create(64, new int[] { 40 })
+            };
+            SEALContext context = new SEALContext(parms,
+                expandModChain: false,
+                secLevel: SecLevelType.None);
+            KeyGenerator keygen = new KeyGenerator(context);
+
+            Assert.IsTrue(context.ParametersSet);
+
+            Encryptor encryptor = new Encryptor(context, keygen.PublicKey);
+            Decryptor decryptor = new Decryptor(context, keygen.SecretKey);
+            Evaluator evaluator = new Evaluator(context);
+
+            Ciphertext encrypted = new Ciphertext();
+            Ciphertext encdestination = new Ciphertext();
+            Plaintext plain = new Plaintext("3x^2 + 2x^1 + 1");
+            Plaintext plaindest = new Plaintext();
+            encryptor.Encrypt(plain, encrypted);
+            evaluator.Negate(encrypted, encdestination);
+            decryptor.Decrypt(encdestination, plaindest);
+
+            // coefficients are negated (modulo 64)
+            Assert.AreEqual(0x3Ful, plaindest[0]);
+            Assert.AreEqual(0x3Eul, plaindest[1]);
+            Assert.AreEqual(0x3Dul, plaindest[2]);
+
+            plain = new Plaintext("6x^3 + 7x^2 + 8x^1 + 9");
+            encryptor.Encrypt(plain, encrypted);
+            evaluator.NegateInplace(encrypted);
+            decryptor.Decrypt(encrypted, plain);
+
+            // coefficients are negated (modulo 64)
+            Assert.AreEqual(0x37ul, plain[0]);
+            Assert.AreEqual(0x38ul, plain[1]);
+            Assert.AreEqual(0x39ul, plain[2]);
+            Assert.AreEqual(0x3Aul, plain[3]);
+        }
+
+        [TestMethod]
+        public void AddTest()
+        {
+            EncryptionParameters parms = new EncryptionParameters(SchemeType.BFV)
+            {
+                PolyModulusDegree = 64,
+                PlainModulus = new Modulus(1 << 6),
+                CoeffModulus = CoeffModulus.Create(64, new int[] { 40 })
+            };
+            SEALContext context = new SEALContext(parms,
+                expandModChain: false,
+                secLevel: SecLevelType.None);
+            KeyGenerator keygen = new KeyGenerator(context);
+
+            Encryptor encryptor = new Encryptor(context, keygen.PublicKey);
+            Decryptor decryptor = new Decryptor(context, keygen.SecretKey);
+            Evaluator evaluator = new Evaluator(context);
+
+            Ciphertext encrypted1 = new Ciphertext();
+            Ciphertext encrypted2 = new Ciphertext();
+            Ciphertext encdestination = new Ciphertext();
+
+            Plaintext plain1 = new Plaintext("5x^4 + 4x^3 + 3x^2 + 2x^1 + 1");
+            Plaintext plain2 = new Plaintext("4x^7 + 5x^6 + 6x^5 + 7x^4 + 8x^3 + 9x^2 + Ax^1 + B");
+            Plaintext plaindest = new Plaintext();
+
+            encryptor.Encrypt(plain1, encrypted1);
+            encryptor.Encrypt(plain2, encrypted2);
+            evaluator.Add(encrypted1, encrypted2, encdestination);
+            decryptor.Decrypt(encdestination, plaindest);
+
+            Assert.AreEqual(12ul, plaindest[0]);
+            Assert.AreEqual(12ul, plaindest[1]);
+            Assert.AreEqual(12ul, plaindest[2]);
+            Assert.AreEqual(12ul, plaindest[3]);
+            Assert.AreEqual(12ul, plaindest[4]);
+            Assert.AreEqual(6ul, plaindest[5]);
+            Assert.AreEqual(5ul, plaindest[6]);
+            Assert.AreEqual(4ul, plaindest[7]);
+
+            plain1 = new Plaintext("1x^2 + 2x^1 + 3");
+            plain2 = new Plaintext("2x^3 + 2x^2 + 2x^1 + 2");
+
+            encryptor.Encrypt(plain1, encrypted1);
+            encryptor.Encrypt(plain2, encrypted2);
+            evaluator.AddInplace(encrypted1, encrypted2);
+            decryptor.Decrypt(encrypted1, plaindest);
+
+            Assert.AreEqual(5ul, plaindest[0]);
+            Assert.AreEqual(4ul, plaindest[1]);
+            Assert.AreEqual(3ul, plaindest[2]);
+            Assert.AreEqual(2ul, plaindest[3]);
+        }
+
+        [TestMethod]
+        public void AddPlainTest()
+        {
+            EncryptionParameters parms = new EncryptionParameters(SchemeType.BFV)
+            {
+                PolyModulusDegree = 64,
+                PlainModulus = new Modulus(1 << 6),
+                CoeffModulus = CoeffModulus.Create(64, new int[] { 40 })
+            };
+            SEALContext context = new SEALContext(parms,
+                expandModChain: false,
+                secLevel: SecLevelType.None);
+            KeyGenerator keygen = new KeyGenerator(context);
+
+            Encryptor encryptor = new Encryptor(context, keygen.PublicKey);
+            Decryptor decryptor = new Decryptor(context, keygen.SecretKey);
+            Evaluator evaluator = new Evaluator(context);
+
+            Ciphertext encrypted = new Ciphertext();
+            Ciphertext encdest = new Ciphertext();
+            Plaintext plain = new Plaintext("3x^2 + 2x^1 + 1");
+            Plaintext plaindest = new Plaintext();
+
+            encryptor.Encrypt(new Plaintext("2x^2 + 2x^1 + 2"), encrypted);
+            evaluator.AddPlain(encrypted, plain, encdest);
+            decryptor.Decrypt(encdest, plaindest);
+
+            Assert.AreEqual(3ul, plaindest[0]);
+            Assert.AreEqual(4ul, plaindest[1]);
+            Assert.AreEqual(5ul, plaindest[2]);
+
+            plain.Set("1x^2 + 1x^1 + 1");
+            encryptor.Encrypt(new Plaintext("2x^3 + 2x^2 + 2x^1 + 2"), encrypted);
+            evaluator.AddPlainInplace(encrypted, plain);
+            decryptor.Decrypt(encrypted, plaindest);
+
+            Assert.AreEqual(4ul, plaindest.CoeffCount);
+            Assert.AreEqual(3ul, plaindest[0]);
+            Assert.AreEqual(3ul, plaindest[1]);
+            Assert.AreEqual(3ul, plaindest[2]);
+            Assert.AreEqual(2ul, plaindest[3]);
+        }
+
+        [TestMethod]
+        public void AddManyTest()
+        {
+            EncryptionParameters parms = new EncryptionParameters(SchemeType.BFV)
+            {
+                PolyModulusDegree = 64,
+                PlainModulus = new Modulus(1 << 6),
+                CoeffModulus = CoeffModulus.Create(64, new int[] { 40 })
+            };
+            SEALContext context = new SEALContext(parms,
+                expandModChain: false,
+                secLevel: SecLevelType.None);
+            KeyGenerator keygen = new KeyGenerator(context);
+
+            Encryptor encryptor = new Encryptor(context, keygen.PublicKey);
+            Decryptor decryptor = new Decryptor(context, keygen.SecretKey);
+            Evaluator evaluator = new Evaluator(context);
+
+            Ciphertext[] encrypteds = new Ciphertext[6];
+
+            for(int i = 0; i < encrypteds.Length; i++)
+            {
+                encrypteds[i] = new Ciphertext();
+                encryptor.Encrypt(new Plaintext((i + 1).ToString()), encrypteds[i]);
+            }
+
+            Ciphertext encdest = new Ciphertext();
+            Plaintext plaindest = new Plaintext();
+            evaluator.AddMany(encrypteds, encdest);
+            decryptor.Decrypt(encdest, plaindest);
+
+            // 1+2+3+4+5+6
+            Assert.AreEqual(21ul, plaindest[0]);
+        }
+
+        [TestMethod]
+        public void SubTest()
+        {
+            EncryptionParameters parms = new EncryptionParameters(SchemeType.BFV)
+            {
+                PolyModulusDegree = 64,
+                PlainModulus = new Modulus(1 << 6),
+                CoeffModulus = CoeffModulus.Create(64, new int[] { 40 })
+            };
+            SEALContext context = new SEALContext(parms,
+                expandModChain: false,
+                secLevel: SecLevelType.None);
+            KeyGenerator keygen = new KeyGenerator(context);
+
+            Encryptor encryptor = new Encryptor(context, keygen.PublicKey);
+            Decryptor decryptor = new Decryptor(context, keygen.SecretKey);
+            Evaluator evaluator = new Evaluator(context);
+
+            Ciphertext encrypted1 = new Ciphertext();
+            Ciphertext encrypted2 = new Ciphertext();
+            Ciphertext encdest = new Ciphertext();
+            Plaintext plain1 = new Plaintext("Ax^2 + Bx^1 + C");
+            Plaintext plain2 = new Plaintext("5x^3 + 5x^2 + 5x^1 + 5");
+            Plaintext plaindest = new Plaintext();
+
+            encryptor.Encrypt(plain1, encrypted1);
+            encryptor.Encrypt(plain2, encrypted2);
+            evaluator.Sub(encrypted1, encrypted2, encdest);
+            decryptor.Decrypt(encdest, plaindest);
+
+            Assert.AreEqual(7ul, plaindest[0]);
+            Assert.AreEqual(6ul, plaindest[1]);
+            Assert.AreEqual(5ul, plaindest[2]);
+            Assert.AreEqual(0x3Bul, plaindest[3]);
+
+            plain1.Set("Ax^3 + Bx^2 + Cx^1 + D");
+            plain2.Set("5x^2 + 5x^1 + 5");
+
+            encryptor.Encrypt(plain1, encrypted1);
+            encryptor.Encrypt(plain2, encrypted2);
+            evaluator.SubInplace(encrypted1, encrypted2);
+            decryptor.Decrypt(encrypted1, plaindest);
+
+            Assert.AreEqual(8ul, plaindest[0]);
+            Assert.AreEqual(7ul, plaindest[1]);
+            Assert.AreEqual(6ul, plaindest[2]);
+            Assert.AreEqual(10ul, plaindest[3]);
+        }
+
+        [TestMethod]
+        public void SubPlainTest()
+        {
+            EncryptionParameters parms = new EncryptionParameters(SchemeType.BFV)
+            {
+                PolyModulusDegree = 64,
+                PlainModulus = new Modulus(1 << 6),
+                CoeffModulus = CoeffModulus.Create(64, new int[] { 40 })
+            };
+            SEALContext context = new SEALContext(parms,
+                expandModChain: false,
+                secLevel: SecLevelType.None);
+            KeyGenerator keygen = new KeyGenerator(context);
+
+            Encryptor encryptor = new Encryptor(context, keygen.PublicKey);
+            Decryptor decryptor = new Decryptor(context, keygen.SecretKey);
+            Evaluator evaluator = new Evaluator(context);
+
+            Ciphertext encrypted = new Ciphertext();
+            Ciphertext encdest = new Ciphertext();
+            Plaintext plain = new Plaintext("5x^2 + 4x^1 + 3");
+            Plaintext plaindest = new Plaintext();
+
+            encryptor.Encrypt(new Plaintext("3x^1 + 4"), encrypted);
+            evaluator.SubPlain(encrypted, plain, encdest);
+            decryptor.Decrypt(encdest, plaindest);
+
+            Assert.AreEqual(3ul, plaindest.CoeffCount);
+            Assert.AreEqual(1ul, plaindest[0]);
+            Assert.AreEqual(0x3Ful, plaindest[1]); // -1
+            Assert.AreEqual(0x3Bul, plaindest[2]); // -5
+
+            plain.Set("6x^3 + 1x^2 + 7x^1 + 2");
+            encryptor.Encrypt(new Plaintext("Ax^2 + Bx^1 + C"), encrypted);
+            evaluator.SubPlainInplace(encrypted, plain);
+            decryptor.Decrypt(encrypted, plaindest);
+
+            Assert.AreEqual(4ul, plaindest.CoeffCount);
+            Assert.AreEqual(10ul, plaindest[0]);
+            Assert.AreEqual(4ul, plaindest[1]);
+            Assert.AreEqual(9ul, plaindest[2]);
+            Assert.AreEqual(0x3Aul, plaindest[3]); // -6
+        }
+
+        [TestMethod]
+        public void MultiplyTest()
+        {
+            EncryptionParameters parms = new EncryptionParameters(SchemeType.BFV)
+            {
+                PolyModulusDegree = 64,
+                PlainModulus = new Modulus(1 << 6),
+                CoeffModulus = CoeffModulus.Create(64, new int[] { 40 })
+            };
+            SEALContext context = new SEALContext(parms,
+                expandModChain: false,
+                secLevel: SecLevelType.None);
+            KeyGenerator keygen = new KeyGenerator(context);
+
+            Encryptor encryptor = new Encryptor(context, keygen.PublicKey);
+            Decryptor decryptor = new Decryptor(context, keygen.SecretKey);
+            Evaluator evaluator = new Evaluator(context);
+
+            Ciphertext encrypted1 = new Ciphertext();
+            Ciphertext encrypted2 = new Ciphertext();
+            Ciphertext encdest = new Ciphertext();
+            Plaintext plaindest = new Plaintext();
+
+            encryptor.Encrypt(new Plaintext("1x^4 + 2x^3 + 3x^2 + 4x^1 + 5"), encrypted1);
+            encryptor.Encrypt(new Plaintext("3x^2 + 2x^1 + 1"), encrypted2);
+            evaluator.Multiply(encrypted1, encrypted2, encdest);
+            decryptor.Decrypt(encdest, plaindest);
+
+            // {3x^6 + 8x^5 + Ex^4 + 14x^3 + 1Ax^2 + Ex^1 + 5}
+            Assert.AreEqual(7ul, plaindest.CoeffCount);
+            Assert.AreEqual(5ul, plaindest[0]);
+            Assert.AreEqual(14ul, plaindest[1]);
+            Assert.AreEqual(26ul, plaindest[2]);
+            Assert.AreEqual(20ul, plaindest[3]);
+            Assert.AreEqual(14ul, plaindest[4]);
+            Assert.AreEqual(8ul, plaindest[5]);
+            Assert.AreEqual(3ul, plaindest[6]);
+
+            encryptor.Encrypt(new Plaintext("2x^2 + 3x^1 + 4"), encrypted1);
+            encryptor.Encrypt(new Plaintext("4x^1 + 5"), encrypted2);
+            evaluator.MultiplyInplace(encrypted1, encrypted2);
+            decryptor.Decrypt(encrypted1, plaindest);
+
+            // {8x^3 + 16x^2 + 1Fx^1 + 14}
+            Assert.AreEqual(4ul, plaindest.CoeffCount);
+            Assert.AreEqual(20ul, plaindest[0]);
+            Assert.AreEqual(31ul, plaindest[1]);
+            Assert.AreEqual(22ul, plaindest[2]);
+            Assert.AreEqual(8ul, plaindest[3]);
+        }
+
+        [TestMethod]
+        public void MultiplyManyTest()
+        {
+            EncryptionParameters parms = new EncryptionParameters(SchemeType.BFV)
+            {
+                PolyModulusDegree = 128,
+                PlainModulus = new Modulus(1 << 6),
+                CoeffModulus = CoeffModulus.Create(128, new int[] { 40, 40, 40 })
+            };
+            SEALContext context = new SEALContext(parms,
+                expandModChain: false,
+                secLevel: SecLevelType.None);
+            KeyGenerator keygen = new KeyGenerator(context);
+
+            Encryptor encryptor = new Encryptor(context, keygen.PublicKey);
+            Decryptor decryptor = new Decryptor(context, keygen.SecretKey);
+            Evaluator evaluator = new Evaluator(context);
+            RelinKeys relinKeys = keygen.RelinKeysLocal();
+
+            Ciphertext[] encrypteds = new Ciphertext[4];
+            Ciphertext encdest = new Ciphertext();
+            Plaintext plaindest = new Plaintext();
+
+            for (int i = 0; i < encrypteds.Length; i++)
+            {
+                encrypteds[i] = new Ciphertext();
+                encryptor.Encrypt(new Plaintext((i + 1).ToString()), encrypteds[i]);
+            }
+
+            evaluator.MultiplyMany(encrypteds, relinKeys, encdest);
+            decryptor.Decrypt(encdest, plaindest);
+
+            Assert.AreEqual(1ul, plaindest.CoeffCount);
+            Assert.AreEqual(24ul, plaindest[0]);
+
+            Utilities.AssertThrows<ArgumentException>(() =>
+            {
+                // Uninitialized memory pool handle
+                MemoryPoolHandle pool = new MemoryPoolHandle();
+                evaluator.MultiplyMany(encrypteds, relinKeys, encdest, pool);
+            });
+        }
+
+        [TestMethod]
+        public void MultiplyPlainTest()
+        {
+            EncryptionParameters parms = new EncryptionParameters(SchemeType.BFV)
+            {
+                PolyModulusDegree = 128,
+                PlainModulus = new Modulus(1 << 6),
+                CoeffModulus = CoeffModulus.Create(128, new int[] { 40, 40 })
+            };
+            SEALContext context = new SEALContext(parms,
+                expandModChain: false,
+                secLevel: SecLevelType.None);
+            KeyGenerator keygen = new KeyGenerator(context);
+
+            Encryptor encryptor = new Encryptor(context, keygen.PublicKey);
+            Decryptor decryptor = new Decryptor(context, keygen.SecretKey);
+            Evaluator evaluator = new Evaluator(context);
+            RelinKeys relinKeys = keygen.RelinKeysLocal();
+
+            Ciphertext encrypted = new Ciphertext();
+            Ciphertext encdest = new Ciphertext();
+            Plaintext plain = new Plaintext("2x^2 + 1");
+            Plaintext plaindest = new Plaintext();
+
+            encryptor.Encrypt(new Plaintext("3x^2 + 2"), encrypted);
+            evaluator.MultiplyPlain(encrypted, plain, encdest);
+            decryptor.Decrypt(encdest, plaindest);
+
+            // {6x^4 + 7x^2 + 2}
+            Assert.AreEqual(5ul, plaindest.CoeffCount);
+            Assert.AreEqual(2ul, plaindest[0]);
+            Assert.AreEqual(0ul, plaindest[1]);
+            Assert.AreEqual(7ul, plaindest[2]);
+            Assert.AreEqual(0ul, plaindest[3]);
+            Assert.AreEqual(6ul, plaindest[4]);
+
+            encryptor.Encrypt(new Plaintext("4x^1 + 3"), encrypted);
+            plain.Set("2x^2 + 1");
+            evaluator.MultiplyPlainInplace(encrypted, plain);
+            decryptor.Decrypt(encrypted, plaindest);
+
+            // {8x^3 + 6x^2 + 4x^1 + 3}
+            Assert.AreEqual(4ul, plaindest.CoeffCount);
+            Assert.AreEqual(3ul, plaindest[0]);
+            Assert.AreEqual(4ul, plaindest[1]);
+            Assert.AreEqual(6ul, plaindest[2]);
+            Assert.AreEqual(8ul, plaindest[3]);
+
+            encryptor.Encrypt(new Plaintext("4x^1 + 3"), encrypted);
+            plain.Set("3x^5");
+            evaluator.MultiplyPlainInplace(encrypted, plain);
+            decryptor.Decrypt(encrypted, plaindest);
+
+            // {Cx^6 + 9x^5}
+            Assert.AreEqual(7ul, plaindest.CoeffCount);
+            Assert.AreEqual(2ul, plaindest.NonZeroCoeffCount);
+            Assert.AreEqual(0ul, plaindest[0]);
+            Assert.AreEqual(0ul, plaindest[1]);
+            Assert.AreEqual(0ul, plaindest[2]);
+            Assert.AreEqual(0ul, plaindest[3]);
+            Assert.AreEqual(0ul, plaindest[4]);
+            Assert.AreEqual(9ul, plaindest[5]);
+            Assert.AreEqual(12ul, plaindest[6]);
+
+            Utilities.AssertThrows<ArgumentException>(() =>
+            {
+                // Uninitialized pool
+                MemoryPoolHandle pool = new MemoryPoolHandle();
+                evaluator.MultiplyPlain(encrypted, plain, encdest, pool);
+            });
+        }
+
+        [TestMethod]
+        public void SquareTest()
+        {
+            EncryptionParameters parms = new EncryptionParameters(SchemeType.BFV)
+            {
+                PolyModulusDegree = 128,
+                PlainModulus = new Modulus(1 << 6),
+                CoeffModulus = CoeffModulus.Create(128, new int[] { 40, 40 })
+            };
+            SEALContext context = new SEALContext(parms,
+                expandModChain: false,
+                secLevel: SecLevelType.None);
+            KeyGenerator keygen = new KeyGenerator(context);
+
+            Encryptor encryptor = new Encryptor(context, keygen.PublicKey);
+            Decryptor decryptor = new Decryptor(context, keygen.SecretKey);
+            Evaluator evaluator = new Evaluator(context);
+
+            Ciphertext encrypted = new Ciphertext();
+            Ciphertext encdest = new Ciphertext();
+            Plaintext plain = new Plaintext("2x^2 + 3x^1 + 4");
+            Plaintext plaindest = new Plaintext();
+
+            encryptor.Encrypt(plain, encrypted);
+            evaluator.Square(encrypted, encdest);
+            decryptor.Decrypt(encdest, plaindest);
+
+            // {4x^4 + Cx^3 + 19x^2 + 18x^1 + 10}
+            Assert.AreEqual(5ul, plaindest.CoeffCount);
+            Assert.AreEqual(16ul, plaindest[0]);
+            Assert.AreEqual(24ul, plaindest[1]);
+            Assert.AreEqual(25ul, plaindest[2]);
+            Assert.AreEqual(12ul, plaindest[3]);
+            Assert.AreEqual(4ul, plaindest[4]);
+
+            encryptor.Encrypt(new Plaintext("3x^1 + 2"), encrypted);
+            evaluator.SquareInplace(encrypted);
+            decryptor.Decrypt(encrypted, plaindest);
+
+            // {9x^2 + Cx^1 + 4}
+            Assert.AreEqual(3ul, plaindest.CoeffCount);
+            Assert.AreEqual(4ul, plaindest[0]);
+            Assert.AreEqual(12ul, plaindest[1]);
+            Assert.AreEqual(9ul, plaindest[2]);
+        }
+
+        [TestMethod]
+        public void ExponentiateTest()
+        {
+            EncryptionParameters parms = new EncryptionParameters(SchemeType.BFV)
+            {
+                PolyModulusDegree = 128,
+                PlainModulus = new Modulus(1 << 6),
+                CoeffModulus = CoeffModulus.Create(128, new int[] { 40, 40, 40 })
+            };
+            SEALContext context = new SEALContext(parms,
+                expandModChain: false,
+                secLevel: SecLevelType.None);
+            KeyGenerator keygen = new KeyGenerator(context);
+
+            Encryptor encryptor = new Encryptor(context, keygen.PublicKey);
+            Decryptor decryptor = new Decryptor(context, keygen.SecretKey);
+            Evaluator evaluator = new Evaluator(context);
+            RelinKeys relinKeys = keygen.RelinKeysLocal();
+
+            Ciphertext encrypted = new Ciphertext();
+            Ciphertext encdest = new Ciphertext();
+            Plaintext plain = new Plaintext();
+
+            encryptor.Encrypt(new Plaintext("2x^2 + 1"), encrypted);
+            evaluator.Exponentiate(encrypted, 3, relinKeys, encdest);
+            decryptor.Decrypt(encdest, plain);
+
+            // {8x^6 + Cx^4 + 6x^2 + 1}
+            Assert.AreEqual(7ul, plain.CoeffCount);
+            Assert.AreEqual(1ul, plain[0]);
+            Assert.AreEqual(0ul, plain[1]);
+            Assert.AreEqual(6ul, plain[2]);
+            Assert.AreEqual(0ul, plain[3]);
+            Assert.AreEqual(12ul, plain[4]);
+            Assert.AreEqual(0ul, plain[5]);
+            Assert.AreEqual(8ul, plain[6]);
+
+            encryptor.Encrypt(new Plaintext("3x^3 + 2"), encrypted);
+            evaluator.ExponentiateInplace(encrypted, 4, relinKeys);
+            decryptor.Decrypt(encrypted, plain);
+
+            // {11x^12 + 18x^9 + 18x^6 + 20x^3 + 10}
+            Assert.AreEqual(13ul, plain.CoeffCount);
+            Assert.AreEqual(16ul, plain[0]);
+            Assert.AreEqual(0ul, plain[1]);
+            Assert.AreEqual(0ul, plain[2]);
+            Assert.AreEqual(32ul, plain[3]);
+            Assert.AreEqual(0ul, plain[4]);
+            Assert.AreEqual(0ul, plain[5]);
+            Assert.AreEqual(24ul, plain[6]);
+            Assert.AreEqual(0ul, plain[7]);
+            Assert.AreEqual(0ul, plain[8]);
+            Assert.AreEqual(24ul, plain[9]);
+            Assert.AreEqual(0ul, plain[10]);
+            Assert.AreEqual(0ul, plain[11]);
+            Assert.AreEqual(17ul, plain[12]);
+        }
+
+        [TestMethod]
+        public void ApplyGaloisTest()
+        {
+            EncryptionParameters parms = new EncryptionParameters(SchemeType.BFV)
+            {
+                PolyModulusDegree = 8,
+                PlainModulus = new Modulus(257),
+                CoeffModulus = CoeffModulus.Create(8, new int[] { 40, 40 })
+            };
+            SEALContext context = new SEALContext(parms,
+                expandModChain: false,
+                secLevel: SecLevelType.None);
+            KeyGenerator keygen = new KeyGenerator(context);
+            GaloisKeys galoisKeys = keygen.GaloisKeysLocal(galoisElts: new uint[] { 1u, 3u, 5u, 15u });
+
+            Encryptor encryptor = new Encryptor(context, keygen.PublicKey);
+            Decryptor decryptor = new Decryptor(context, keygen.SecretKey);
+            Evaluator evaluator = new Evaluator(context);
+
+            Plaintext plain = new Plaintext("1");
+            Plaintext plaindest = new Plaintext();
+            Ciphertext encrypted = new Ciphertext();
+            Ciphertext encdest = new Ciphertext();
+
+            encryptor.Encrypt(plain, encrypted);
+            evaluator.ApplyGalois(encrypted, galoisElt: 1, galoisKeys: galoisKeys, destination: encdest);
+            decryptor.Decrypt(encdest, plaindest);
+
+            Assert.AreEqual(1ul, plaindest.CoeffCount);
+            Assert.AreEqual(1ul, plaindest[0]);
+
+            plain.Set("1x^1");
+            encryptor.Encrypt(plain, encrypted);
+            evaluator.ApplyGalois(encrypted, galoisElt: 1, galoisKeys: galoisKeys, destination: encdest);
+            decryptor.Decrypt(encdest, plaindest);
+
+            // {1x^1}
+            Assert.AreEqual(2ul, plaindest.CoeffCount);
+            Assert.AreEqual(0ul, plaindest[0]);
+            Assert.AreEqual(1ul, plaindest[1]);
+
+            evaluator.ApplyGalois(encdest, galoisElt: 3, galoisKeys: galoisKeys, destination: encrypted);
+            decryptor.Decrypt(encrypted, plaindest);
+
+            // {1x^3}
+            Assert.AreEqual(4ul, plaindest.CoeffCount);
+            Assert.AreEqual(0ul, plaindest[0]);
+            Assert.AreEqual(0ul, plaindest[1]);
+            Assert.AreEqual(0ul, plaindest[2]);
+            Assert.AreEqual(1ul, plaindest[3]);
+
+            evaluator.ApplyGalois(encrypted, galoisElt: 5, galoisKeys: galoisKeys, destination: encdest);
+            decryptor.Decrypt(encdest, plaindest);
+
+            // {100x^7}
+            Assert.AreEqual(8ul, plaindest.CoeffCount);
+            Assert.AreEqual(0ul, plaindest[0]);
+            Assert.AreEqual(0ul, plaindest[1]);
+            Assert.AreEqual(0ul, plaindest[2]);
+            Assert.AreEqual(0ul, plaindest[3]);
+            Assert.AreEqual(0ul, plaindest[4]);
+            Assert.AreEqual(0ul, plaindest[5]);
+            Assert.AreEqual(0ul, plaindest[6]);
+            Assert.AreEqual(256ul, plaindest[7]);
+
+            plain.Set("1x^2");
+            encryptor.Encrypt(plain, encrypted);
+            evaluator.ApplyGaloisInplace(encrypted, 1, galoisKeys);
+            decryptor.Decrypt(encrypted, plaindest);
+
+            // {1x^2}
+            Assert.AreEqual(3ul, plaindest.CoeffCount);
+            Assert.AreEqual(0ul, plaindest[0]);
+            Assert.AreEqual(0ul, plaindest[1]);
+            Assert.AreEqual(1ul, plaindest[2]);
+
+            evaluator.ApplyGaloisInplace(encrypted, 3, galoisKeys);
+            decryptor.Decrypt(encrypted, plaindest);
+
+            // {1x^6}
+            Assert.AreEqual(7ul, plaindest.CoeffCount);
+            Assert.AreEqual(0ul, plaindest[0]);
+            Assert.AreEqual(0ul, plaindest[1]);
+            Assert.AreEqual(0ul, plaindest[2]);
+            Assert.AreEqual(0ul, plaindest[3]);
+            Assert.AreEqual(0ul, plaindest[4]);
+            Assert.AreEqual(0ul, plaindest[5]);
+            Assert.AreEqual(1ul, plaindest[6]);
+
+            evaluator.ApplyGaloisInplace(encrypted, 5, galoisKeys);
+            decryptor.Decrypt(encrypted, plaindest);
+
+            // {100x^6}
+            Assert.AreEqual(7ul, plaindest.CoeffCount);
+            Assert.AreEqual(0ul, plaindest[0]);
+            Assert.AreEqual(0ul, plaindest[1]);
+            Assert.AreEqual(0ul, plaindest[2]);
+            Assert.AreEqual(0ul, plaindest[3]);
+            Assert.AreEqual(0ul, plaindest[4]);
+            Assert.AreEqual(0ul, plaindest[5]);
+            Assert.AreEqual(256ul, plaindest[6]);
+        }
+
+        [TestMethod]
+        public void TransformPlainToNTTTest()
+        {
+            EncryptionParameters parms = new EncryptionParameters(SchemeType.BFV)
+            {
+                PolyModulusDegree = 128,
+                PlainModulus = new Modulus(1 << 6),
+                CoeffModulus = CoeffModulus.Create(128, new int[] { 40, 40, 40 })
+            };
+            SEALContext context = new SEALContext(parms,
+                expandModChain: false,
+                secLevel: SecLevelType.None);
+            Evaluator evaluator = new Evaluator(context);
+
+            Plaintext plain = new Plaintext("0");
+            Plaintext plaindest = new Plaintext();
+            Assert.IsFalse(plain.IsNTTForm);
+
+            evaluator.TransformToNTT(plain, context.FirstParmsId, plaindest);
+            Assert.IsTrue(plaindest.IsZero);
+            Assert.IsTrue(plaindest.IsNTTForm);
+            Assert.IsTrue(plaindest.ParmsId == context.FirstParmsId);
+
+            plain = new Plaintext("1");
+            Assert.IsFalse(plain.IsNTTForm);
+
+            evaluator.TransformToNTTInplace(plain, context.FirstParmsId);
+            Assert.IsTrue(plain.IsNTTForm);
+
+            for (ulong i = 0; i < 256; i++)
+            {
+                Assert.AreEqual(1ul, plain[i]);
+            }
+        }
+
+        [TestMethod]
+        public void TransformEncryptedToNTTTest()
+        {
+            EncryptionParameters parms = new EncryptionParameters(SchemeType.BFV)
+            {
+                PolyModulusDegree = 128,
+                PlainModulus = new Modulus(1 << 6),
+                CoeffModulus = CoeffModulus.Create(128, new int[] { 40, 40 })
+            };
+            SEALContext context = new SEALContext(parms,
+                expandModChain: false,
+                secLevel: SecLevelType.None);
+            KeyGenerator keygen = new KeyGenerator(context);
+
+            Encryptor encryptor = new Encryptor(context, keygen.PublicKey);
+            Decryptor decryptor = new Decryptor(context, keygen.SecretKey);
+            Evaluator evaluator = new Evaluator(context);
+
+            Ciphertext encrypted = new Ciphertext();
+            Ciphertext encdest = new Ciphertext();
+            Ciphertext encdest2 = new Ciphertext();
+            Plaintext plaindest = new Plaintext();
+
+            encryptor.Encrypt(new Plaintext("0"), encrypted);
+            Assert.IsFalse(encrypted.IsNTTForm);
+
+            evaluator.TransformToNTT(encrypted, encdest);
+            Assert.IsTrue(encdest.IsNTTForm);
+
+            evaluator.TransformFromNTT(encdest, encdest2);
+            Assert.IsFalse(encdest2.IsNTTForm);
+
+            decryptor.Decrypt(encdest2, plaindest);
+            Assert.AreEqual(1ul, plaindest.CoeffCount);
+            Assert.AreEqual(0ul, plaindest[0]);
+            Assert.AreEqual(context.FirstParmsId, encdest2.ParmsId);
+
+            encryptor.Encrypt(new Plaintext("1"), encrypted);
+            Assert.IsFalse(encrypted.IsNTTForm);
+
+            evaluator.TransformToNTTInplace(encrypted);
+            Assert.IsTrue(encrypted.IsNTTForm);
+
+            evaluator.TransformFromNTTInplace(encrypted);
+            Assert.IsFalse(encrypted.IsNTTForm);
+
+            decryptor.Decrypt(encrypted, plaindest);
+
+            Assert.AreEqual(1ul, plaindest.CoeffCount);
+            Assert.AreEqual(1ul, plaindest[0]);
+            Assert.AreEqual(context.FirstParmsId, encrypted.ParmsId);
+        }
+
+        [TestMethod]
+        public void ModSwitchToNextTest()
+        {
+            EncryptionParameters parms = new EncryptionParameters(SchemeType.BFV)
+            {
+                PolyModulusDegree = 128,
+                PlainModulus = new Modulus(1 << 6),
+                CoeffModulus = CoeffModulus.Create(128, new int[] { 30, 30, 30 })
+            };
+            SEALContext context = new SEALContext(parms,
+                expandModChain: true,
+                secLevel: SecLevelType.None);
+            KeyGenerator keygen = new KeyGenerator(context);
+
+            Encryptor encryptor = new Encryptor(context, keygen.PublicKey);
+            Decryptor decryptor = new Decryptor(context, keygen.SecretKey);
+            Evaluator evaluator = new Evaluator(context);
+
+            Ciphertext encrypted = new Ciphertext(context);
+            Ciphertext encdest = new Ciphertext();
+            Plaintext plain = new Plaintext();
+
+            plain.Set("0");
+            encryptor.Encrypt(plain, encrypted);
+            evaluator.ModSwitchToNext(encrypted, encdest);
+            decryptor.Decrypt(encdest, plain);
+
+            Assert.AreEqual(1ul, plain.CoeffCount);
+            Assert.AreEqual(0ul, plain[0]);
+
+            plain.Set("1");
+            encryptor.Encrypt(plain, encrypted);
+            evaluator.ModSwitchToNextInplace(encrypted);
+            decryptor.Decrypt(encrypted, plain);
+
+            Assert.AreEqual(1ul, plain.CoeffCount);
+            Assert.AreEqual(1ul, plain[0]);
+        }
+
+        [TestMethod]
+        public void ModSwitchToTest()
+        {
+            EncryptionParameters parms = new EncryptionParameters(SchemeType.BFV)
+            {
+                PolyModulusDegree = 128,
+                PlainModulus = new Modulus(1 << 6),
+                CoeffModulus = CoeffModulus.Create(128, new int[] { 30, 30, 30, 30 })
+            };
+            SEALContext context = new SEALContext(parms,
+                expandModChain: true,
+                secLevel: SecLevelType.None);
+            KeyGenerator keygen = new KeyGenerator(context);
+
+            Encryptor encryptor = new Encryptor(context, keygen.PublicKey);
+            Decryptor decryptor = new Decryptor(context, keygen.SecretKey);
+            Evaluator evaluator = new Evaluator(context);
+
+            Ciphertext encrypted = new Ciphertext(context);
+            Ciphertext encdest = new Ciphertext(context);
+            Plaintext plaindest = new Plaintext();
+
+            encryptor.Encrypt(new Plaintext("1"), encrypted);
+            ParmsId destParmsId = context.FirstContextData.NextContextData
+                .NextContextData.ParmsId;
+
+            evaluator.ModSwitchTo(encrypted, context.FirstParmsId, encdest);
+            decryptor.Decrypt(encdest, plaindest);
+
+            Assert.IsTrue(encrypted.ParmsId == context.FirstParmsId);
+            Assert.IsTrue(encdest.ParmsId == context.FirstParmsId);
+            Assert.AreEqual(1ul, plaindest.CoeffCount);
+            Assert.AreEqual(1ul, plaindest[0]);
+
+            evaluator.ModSwitchTo(encrypted, destParmsId, encdest);
+            decryptor.Decrypt(encdest, plaindest);
+
+            Assert.IsTrue(encrypted.ParmsId == context.FirstParmsId);
+            Assert.IsTrue(encdest.ParmsId == destParmsId);
+            Assert.AreEqual(1ul, plaindest.CoeffCount);
+            Assert.AreEqual(1ul, plaindest[0]);
+
+            encryptor.Encrypt(new Plaintext("3x^2 + 2x^1 + 1"), encrypted);
+            evaluator.ModSwitchToInplace(encrypted, context.FirstParmsId);
+            decryptor.Decrypt(encrypted, plaindest);
+
+            Assert.IsTrue(encrypted.ParmsId == context.FirstParmsId);
+            Assert.AreEqual(3ul, plaindest.CoeffCount);
+            Assert.AreEqual(1ul, plaindest[0]);
+            Assert.AreEqual(2ul, plaindest[1]);
+            Assert.AreEqual(3ul, plaindest[2]);
+
+            evaluator.ModSwitchToInplace(encrypted, destParmsId);
+            decryptor.Decrypt(encrypted, plaindest);
+
+            Assert.IsTrue(encrypted.ParmsId == destParmsId);
+            Assert.AreEqual(3ul, plaindest.CoeffCount);
+            Assert.AreEqual(1ul, plaindest[0]);
+            Assert.AreEqual(2ul, plaindest[1]);
+            Assert.AreEqual(3ul, plaindest[2]);
+        }
+
+        [TestMethod]
+        public void ModSwitchToPlainTest()
+        {
+            EncryptionParameters parms = new EncryptionParameters(SchemeType.CKKS)
+            {
+                PolyModulusDegree = 1024,
+                CoeffModulus = CoeffModulus.Create(1024, new int[] { 40, 40, 40, 40, 40 })
+            };
+
+            SEALContext context = new SEALContext(parms,
+                expandModChain: true,
+                secLevel: SecLevelType.None);
+            CKKSEncoder encoder = new CKKSEncoder(context);
+            KeyGenerator keygen = new KeyGenerator(context);
+            SecretKey secretKey = keygen.SecretKey;
+            PublicKey publicKey = keygen.PublicKey;
+            RelinKeys relinKeys = keygen.RelinKeysLocal();
+
+            Encryptor encryptor = new Encryptor(context, publicKey);
+            Evaluator evaluator = new Evaluator(context);
+            Decryptor decryptor = new Decryptor(context, secretKey);
+
+            double scale = parms.CoeffModulus.Last().Value;
+            Plaintext coeff1 = new Plaintext();
+            Plaintext coeff2 = new Plaintext();
+            Plaintext coeff3 = new Plaintext();
+            encoder.Encode(2.0, scale, coeff1);
+            encoder.Encode(3.0, scale, coeff2);
+            encoder.Encode(1.0, scale, coeff3);
+
+            Ciphertext encX1 = new Ciphertext();
+            Ciphertext encX2 = new Ciphertext();
+            Ciphertext encX3 = new Ciphertext();
+            encryptor.Encrypt(coeff1, encX1);
+            evaluator.Square(encX1, encX3);
+            evaluator.MultiplyPlain(encX1, coeff2, encX2);
+            evaluator.RelinearizeInplace(encX3, relinKeys);
+            evaluator.RescaleToNextInplace(encX3);
+            evaluator.RelinearizeInplace(encX2, relinKeys);
+            evaluator.RescaleToInplace(encX2, encX3.ParmsId);
+
+            evaluator.ModSwitchToInplace(coeff3, encX3.ParmsId);
+            evaluator.ModSwitchToNextInplace(coeff2);
+
+            evaluator.MultiplyPlainInplace(encX3, coeff3);
+
+            Plaintext result = new Plaintext();
+            decryptor.Decrypt(encX3, result);
+            Assert.IsNotNull(result);
+
+            List<double> destination = new List<double>();
+            encoder.Decode(result, destination);
+
+            Assert.IsNotNull(destination);
+            foreach(double val in destination)
+            {
+                Assert.AreEqual(4.0, val, delta: 0.001);
+            }
+
+            encoder.Decode(coeff2, destination);
+
+            foreach(double val in destination)
+            {
+                Assert.AreEqual(3.0, val, delta: 0.001);
+            }
+
+            decryptor.Decrypt(encX2, result);
+            encoder.Decode(result, destination);
+
+            foreach (double val in destination)
+            {
+                Assert.AreEqual(6.0, val, delta: 0.001);
+            }
+        }
+
+        [TestMethod]
+        public void RotateMatrixTest()
+        {
+            EncryptionParameters parms = new EncryptionParameters(SchemeType.BFV)
+            {
+                PolyModulusDegree = 8,
+                PlainModulus = new Modulus(257),
+                CoeffModulus = CoeffModulus.Create(8, new int[] { 40, 40 })
+            };
+            SEALContext context = new SEALContext(parms,
+                expandModChain: false,
+                secLevel: SecLevelType.None);
+            KeyGenerator keygen = new KeyGenerator(context);
+            GaloisKeys galoisKeys = keygen.GaloisKeysLocal();
+
+            Encryptor encryptor = new Encryptor(context, keygen.PublicKey);
+            Decryptor decryptor = new Decryptor(context, keygen.SecretKey);
+            Evaluator evaluator = new Evaluator(context);
+            BatchEncoder encoder = new BatchEncoder(context);
+
+            Plaintext plain = new Plaintext();
+            List<ulong> vec = new List<ulong>
+            {
+                1, 2, 3, 4,
+                5, 6, 7, 8
+            };
+
+            encoder.Encode(vec, plain);
+
+            Ciphertext encrypted = new Ciphertext();
+            Ciphertext encdest = new Ciphertext();
+            Plaintext plaindest = new Plaintext();
+
+            encryptor.Encrypt(plain, encrypted);
+            evaluator.RotateColumns(encrypted, galoisKeys, encdest);
+            decryptor.Decrypt(encdest, plaindest);
+            encoder.Decode(plaindest, vec);
+
+            Assert.IsTrue(AreCollectionsEqual(vec, new List<ulong>
+            {
+                5, 6, 7, 8,
+                1, 2, 3, 4
+            }));
+
+            evaluator.RotateRows(encdest, -1, galoisKeys, encrypted);
+            decryptor.Decrypt(encrypted, plaindest);
+            encoder.Decode(plaindest, vec);
+
+            Assert.IsTrue(AreCollectionsEqual(vec, new List<ulong>
+            {
+                8, 5, 6, 7,
+                4, 1, 2, 3
+            }));
+
+            evaluator.RotateRowsInplace(encrypted, 2, galoisKeys);
+            decryptor.Decrypt(encrypted, plaindest);
+            encoder.Decode(plaindest, vec);
+
+            Assert.IsTrue(AreCollectionsEqual(vec, new List<ulong>
+            {
+                6, 7, 8, 5,
+                2, 3, 4, 1
+            }));
+
+            evaluator.RotateColumnsInplace(encrypted, galoisKeys);
+            decryptor.Decrypt(encrypted, plaindest);
+            encoder.Decode(plaindest, vec);
+
+            Assert.IsTrue(AreCollectionsEqual(vec, new List<ulong>
+            {
+                2, 3, 4, 1,
+                6, 7, 8, 5
+            }));
+        }
+
+        [TestMethod]
+        public void RelinearizeTest()
+        {
+            EncryptionParameters parms = new EncryptionParameters(SchemeType.BFV)
+            {
+                PolyModulusDegree = 128,
+                PlainModulus = new Modulus(1 << 6),
+                CoeffModulus = CoeffModulus.Create(128, new int[] { 40, 40, 40 })
+            };
+            SEALContext context = new SEALContext(parms,
+                expandModChain: false,
+                secLevel: SecLevelType.None);
+            KeyGenerator keygen = new KeyGenerator(context);
+            RelinKeys relinKeys = keygen.RelinKeysLocal();
+
+            Encryptor encryptor = new Encryptor(context, keygen.PublicKey);
+            Decryptor decryptor = new Decryptor(context, keygen.SecretKey);
+            Evaluator evaluator = new Evaluator(context);
+
+            Ciphertext encrypted1 = new Ciphertext(context);
+            Ciphertext encrypted2 = new Ciphertext(context);
+            Plaintext plain1 = new Plaintext();
+            Plaintext plain2 = new Plaintext();
+
+            plain1.Set(0);
+            encryptor.Encrypt(plain1, encrypted1);
+            evaluator.SquareInplace(encrypted1);
+            evaluator.RelinearizeInplace(encrypted1, relinKeys);
+            decryptor.Decrypt(encrypted1, plain2);
+
+            Assert.AreEqual(1ul, plain2.CoeffCount);
+            Assert.AreEqual(0ul, plain2[0]);
+
+            plain1.Set("1x^10 + 2");
+            encryptor.Encrypt(plain1, encrypted1);
+            evaluator.SquareInplace(encrypted1);
+            evaluator.RelinearizeInplace(encrypted1, relinKeys);
+            evaluator.SquareInplace(encrypted1);
+            evaluator.Relinearize(encrypted1, relinKeys, encrypted2);
+            decryptor.Decrypt(encrypted2, plain2);
+
+            // {1x^40 + 8x^30 + 18x^20 + 20x^10 + 10}
+            Assert.AreEqual(41ul, plain2.CoeffCount);
+            Assert.AreEqual(16ul, plain2[0]);
+            Assert.AreEqual(32ul, plain2[10]);
+            Assert.AreEqual(24ul, plain2[20]);
+            Assert.AreEqual(8ul,  plain2[30]);
+            Assert.AreEqual(1ul,  plain2[40]);
+        }
+
+        [TestMethod]
+        public void RotateVectorTest()
+        {
+            int slotSize = 4;
+            EncryptionParameters parms = new EncryptionParameters(SchemeType.CKKS)
+            {
+                PolyModulusDegree = 2 * (ulong)slotSize,
+                CoeffModulus = CoeffModulus.Create(2 * (ulong)slotSize, new int[] { 40, 40, 40, 40 })
+            };
+            SEALContext context = new SEALContext(parms,
+                expandModChain: false,
+                secLevel: SecLevelType.None);
+            KeyGenerator keygen = new KeyGenerator(context);
+            GaloisKeys galoisKeys = keygen.GaloisKeysLocal();
+
+            Encryptor encryptor = new Encryptor(context, keygen.PublicKey);
+            Decryptor decryptor = new Decryptor(context, keygen.SecretKey);
+            Evaluator evaluator = new Evaluator(context);
+            CKKSEncoder encoder = new CKKSEncoder(context);
+
+            const double delta = 1ul << 30;
+
+            Ciphertext encrypted = new Ciphertext();
+            Plaintext plain = new Plaintext();
+
+            List<Complex> input = new List<Complex>
+            {
+                new Complex(1, 1),
+                new Complex(2, 2),
+                new Complex(3, 3),
+                new Complex(4, 4)
+            };
+
+            List<Complex> output = new List<Complex>();
+
+            encoder.Encode(input, context.FirstParmsId, delta, plain);
+
+            int shift = 1;
+            encryptor.Encrypt(plain, encrypted);
+            evaluator.RotateVectorInplace(encrypted, shift, galoisKeys);
+            decryptor.Decrypt(encrypted, plain);
+            encoder.Decode(plain, output);
+
+            for (int i = 0; i < slotSize; i++)
+            {
+                Assert.AreEqual(input[(i + shift) % slotSize].Real, Math.Round(output[i].Real), delta: 0.1);
+                Assert.AreEqual(input[(i + shift) % slotSize].Imaginary, Math.Round(output[i].Imaginary), delta: 0.1);
+            }
+
+            encoder.Encode(input, context.FirstParmsId, delta, plain);
+            shift = 3;
+            encryptor.Encrypt(plain, encrypted);
+            evaluator.RotateVectorInplace(encrypted, shift, galoisKeys);
+            decryptor.Decrypt(encrypted, plain);
+            encoder.Decode(plain, output);
+
+            for (int i = 0; i < slotSize; i++)
+            {
+                Assert.AreEqual(input[(i + shift) % slotSize].Real, Math.Round(output[i].Real), delta: 0.1);
+                Assert.AreEqual(input[(i + shift) % slotSize].Imaginary, Math.Round(output[i].Imaginary), delta: 0.1);
+            }
+        }
+
+        [TestMethod]
+        public void ComplexConjugateTest()
+        {
+            int slotSize = 4;
+            EncryptionParameters parms = new EncryptionParameters(SchemeType.CKKS)
+            {
+                PolyModulusDegree = 2 * (ulong)slotSize,
+                CoeffModulus = CoeffModulus.Create(2 * (ulong)slotSize, new int[] { 40, 40, 40, 40 })
+            };
+            SEALContext context = new SEALContext(parms,
+                expandModChain: false,
+                secLevel: SecLevelType.None);
+            KeyGenerator keygen = new KeyGenerator(context);
+            GaloisKeys galoisKeys = keygen.GaloisKeysLocal();
+
+            Encryptor encryptor = new Encryptor(context, keygen.PublicKey);
+            Decryptor decryptor = new Decryptor(context, keygen.SecretKey);
+            Evaluator evaluator = new Evaluator(context);
+            CKKSEncoder encoder = new CKKSEncoder(context);
+
+            const double delta = 1ul << 30;
+
+            Ciphertext encrypted = new Ciphertext();
+            Plaintext plain = new Plaintext();
+
+            List<Complex> input = new List<Complex>
+            {
+                new Complex(1, 1),
+                new Complex(2, 2),
+                new Complex(3, 3),
+                new Complex(4, 4)
+            };
+
+            List<Complex> output = new List<Complex>();
+
+            encoder.Encode(input, context.FirstParmsId, delta, plain);
+            encryptor.Encrypt(plain, encrypted);
+            evaluator.ComplexConjugateInplace(encrypted, galoisKeys);
+            decryptor.Decrypt(encrypted, plain);
+            encoder.Decode(plain, output);
+
+            for (int i = 0; i < slotSize; i++)
+            {
+                Assert.AreEqual(input[i].Real, output[i].Real, delta: 0.1);
+                Assert.AreEqual(-input[i].Imaginary, output[i].Imaginary, delta: 0.1);
+            }
+        }
+
+        [TestMethod]
+        public void ExceptionsTest()
+        {
+            EncryptionParameters parms = new EncryptionParameters(SchemeType.BFV)
+            {
+                PolyModulusDegree = 64,
+                PlainModulus = new Modulus(65537ul),
+                CoeffModulus = CoeffModulus.Create(64, new int[] { 40, 40 })
+            };
+            SEALContext context = new SEALContext(parms,
+                expandModChain: false,
+                secLevel: SecLevelType.None);
+
+            Evaluator evaluator = null;
+            Utilities.AssertThrows<ArgumentNullException>(() => evaluator = new Evaluator(null));
+            evaluator = new Evaluator(context);
+
+            KeyGenerator keygen = new KeyGenerator(context);
+            GaloisKeys galoisKeys = keygen.GaloisKeysLocal();
+            RelinKeys relinKeys = keygen.RelinKeysLocal();
+
+            Ciphertext encrypted1 = new Ciphertext();
+            Ciphertext encrypted2 = new Ciphertext();
+            Ciphertext encrypted3 = new Ciphertext();
+            Plaintext plain1 = new Plaintext();
+            Plaintext plain2 = new Plaintext();
+            List<Ciphertext> encrypteds = new List<Ciphertext>();
+
+            MemoryPoolHandle pool = MemoryManager.GetPool(MMProfOpt.ForceGlobal);
+
+            Utilities.AssertThrows<ArgumentNullException>(() => evaluator.Add(null, encrypted2, encrypted3));
+            Utilities.AssertThrows<ArgumentNullException>(() => evaluator.Add(encrypted1, null, encrypted3));
+            Utilities.AssertThrows<ArgumentNullException>(() => evaluator.Add(encrypted1, encrypted2, null));
+            Utilities.AssertThrows<ArgumentException>(() => evaluator.Add(encrypted1, encrypted2, encrypted3));
+
+            Utilities.AssertThrows<ArgumentNullException>(() => evaluator.AddInplace(encrypted1, null));
+            Utilities.AssertThrows<ArgumentNullException>(() => evaluator.AddInplace(null, encrypted2));
+
+            Utilities.AssertThrows<ArgumentNullException>(() => evaluator.AddMany(encrypteds, null));
+            Utilities.AssertThrows<ArgumentNullException>(() => evaluator.AddMany(null, encrypted2));
+
+            Utilities.AssertThrows<ArgumentNullException>(() => evaluator.AddPlain(encrypted1, plain1, null));
+            Utilities.AssertThrows<ArgumentNullException>(() => evaluator.AddPlain(encrypted1, null, encrypted2));
+            Utilities.AssertThrows<ArgumentNullException>(() => evaluator.AddPlain(null, plain1, encrypted2));
+            Utilities.AssertThrows<ArgumentException>(() => evaluator.AddPlain(encrypted1, plain1, encrypted2));
+
+            Utilities.AssertThrows<ArgumentNullException>(() => evaluator.AddPlainInplace(encrypted1, null));
+            Utilities.AssertThrows<ArgumentNullException>(() => evaluator.AddPlainInplace(null, plain1));
+
+            Utilities.AssertThrows<ArgumentNullException>(() => evaluator.ApplyGalois(encrypted1, 1, galoisKeys, null));
+            Utilities.AssertThrows<ArgumentNullException>(() => evaluator.ApplyGalois(encrypted1, 1, null, encrypted2));
+            Utilities.AssertThrows<ArgumentNullException>(() => evaluator.ApplyGalois(null, 1, galoisKeys, encrypted2));
+            Utilities.AssertThrows<ArgumentException>(() => evaluator.ApplyGalois(encrypted1, 1, galoisKeys, encrypted2, pool));
+
+            Utilities.AssertThrows<ArgumentNullException>(() => evaluator.ApplyGaloisInplace(encrypted1, 1, null));
+            Utilities.AssertThrows<ArgumentNullException>(() => evaluator.ApplyGaloisInplace(null, 1, galoisKeys));
+
+            Utilities.AssertThrows<ArgumentNullException>(() => evaluator.ComplexConjugate(encrypted1, galoisKeys, null));
+            Utilities.AssertThrows<ArgumentNullException>(() => evaluator.ComplexConjugate(encrypted1, null, encrypted2));
+            Utilities.AssertThrows<ArgumentNullException>(() => evaluator.ComplexConjugate(null, galoisKeys, encrypted2));
+
+            Utilities.AssertThrows<ArgumentNullException>(() => evaluator.ComplexConjugateInplace(encrypted1, null));
+            Utilities.AssertThrows<ArgumentNullException>(() => evaluator.ComplexConjugateInplace(null, galoisKeys));
+
+            Utilities.AssertThrows<ArgumentNullException>(() => evaluator.Exponentiate(encrypted1, 2, relinKeys, null));
+            Utilities.AssertThrows<ArgumentNullException>(() => evaluator.Exponentiate(encrypted1, 2, null, encrypted2));
+            Utilities.AssertThrows<ArgumentNullException>(() => evaluator.Exponentiate(null, 2, relinKeys, encrypted2));
+
+            Utilities.AssertThrows<ArgumentNullException>(() => evaluator.ExponentiateInplace(encrypted1, 2, null));
+            Utilities.AssertThrows<ArgumentNullException>(() => evaluator.ExponentiateInplace(null, 2, relinKeys));
+
+            Utilities.AssertThrows<ArgumentNullException>(() => evaluator.ModSwitchTo(plain1, ParmsId.Zero, null));
+            Utilities.AssertThrows<ArgumentNullException>(() => evaluator.ModSwitchTo(plain1, null, plain2));
+            Utilities.AssertThrows<ArgumentNullException>(() => evaluator.ModSwitchTo(null, ParmsId.Zero, plain2));
+
+            Utilities.AssertThrows<ArgumentNullException>(() => evaluator.ModSwitchTo(encrypted1, ParmsId.Zero, null));
+            Utilities.AssertThrows<ArgumentNullException>(() => evaluator.ModSwitchTo(encrypted1, null, encrypted2));
+            Utilities.AssertThrows<ArgumentNullException>(() => evaluator.ModSwitchTo(null, ParmsId.Zero, encrypted2));
+            Utilities.AssertThrows<ArgumentException>(() => evaluator.ModSwitchTo(encrypted1, ParmsId.Zero, encrypted2, pool));
+
+            Utilities.AssertThrows<ArgumentNullException>(() => evaluator.ModSwitchToInplace(encrypted1, null));
+            Utilities.AssertThrows<ArgumentNullException>(() => evaluator.ModSwitchToInplace(encrypted: null, parmsId: ParmsId.Zero));
+            Utilities.AssertThrows<ArgumentException>(() => evaluator.ModSwitchToInplace(encrypted1, ParmsId.Zero, pool));
+
+            Utilities.AssertThrows<ArgumentNullException>(() => evaluator.ModSwitchToInplace(plain1, null));
+            Utilities.AssertThrows<ArgumentNullException>(() => evaluator.ModSwitchToInplace(plain: null, parmsId: ParmsId.Zero));
+
+            Utilities.AssertThrows<ArgumentNullException>(() => evaluator.ModSwitchToNext(plain1, null));
+            Utilities.AssertThrows<ArgumentNullException>(() => evaluator.ModSwitchToNext(null, plain2));
+
+            Utilities.AssertThrows<ArgumentNullException>(() => evaluator.ModSwitchToNextInplace(null));
+
+            Utilities.AssertThrows<ArgumentNullException>(() => evaluator.ModSwitchToNext(encrypted1, null));
+            Utilities.AssertThrows<ArgumentNullException>(() => evaluator.ModSwitchToNext(null, encrypted2));
+            Utilities.AssertThrows<ArgumentException>(() => evaluator.ModSwitchToNext(encrypted1, encrypted2, pool));
+
+            Utilities.AssertThrows<ArgumentNullException>(() => evaluator.ModSwitchToNextInplace(encrypted: null));
+            Utilities.AssertThrows<ArgumentException>(() => evaluator.ModSwitchToNextInplace(encrypted1, pool));
+
+            Utilities.AssertThrows<ArgumentNullException>(() => evaluator.Multiply(encrypted1, encrypted2, null));
+            Utilities.AssertThrows<ArgumentNullException>(() => evaluator.Multiply(encrypted1, null, encrypted3));
+            Utilities.AssertThrows<ArgumentNullException>(() => evaluator.Multiply(null, encrypted2, encrypted3));
+            Utilities.AssertThrows<ArgumentException>(() => evaluator.Multiply(encrypted1, encrypted2, encrypted3, pool));
+
+            Utilities.AssertThrows<ArgumentNullException>(() => evaluator.MultiplyInplace(encrypted1, null));
+            Utilities.AssertThrows<ArgumentNullException>(() => evaluator.MultiplyInplace(null, encrypted2));
+            Utilities.AssertThrows<ArgumentException>(() => evaluator.MultiplyInplace(encrypted1, encrypted2, pool));
+
+            Utilities.AssertThrows<ArgumentNullException>(() => evaluator.MultiplyMany(encrypteds, relinKeys, null));
+            Utilities.AssertThrows<ArgumentNullException>(() => evaluator.MultiplyMany(encrypteds, null, encrypted2));
+            Utilities.AssertThrows<ArgumentNullException>(() => evaluator.MultiplyMany(null, relinKeys, encrypted2));
+            Utilities.AssertThrows<ArgumentException>(() => evaluator.MultiplyMany(encrypteds, relinKeys, encrypted2, pool));
+
+            Utilities.AssertThrows<ArgumentNullException>(() => evaluator.MultiplyPlain(encrypted1, plain1, null));
+            Utilities.AssertThrows<ArgumentNullException>(() => evaluator.MultiplyPlain(encrypted1, null, encrypted2));
+            Utilities.AssertThrows<ArgumentNullException>(() => evaluator.MultiplyPlain(null, plain1, encrypted2));
+            Utilities.AssertThrows<ArgumentException>(() => evaluator.MultiplyPlain(encrypted1, plain1, encrypted2, pool));
+
+            Utilities.AssertThrows<ArgumentNullException>(() => evaluator.MultiplyPlainInplace(encrypted1, null));
+            Utilities.AssertThrows<ArgumentNullException>(() => evaluator.MultiplyPlainInplace(null, plain1));
+
+            Utilities.AssertThrows<ArgumentNullException>(() => evaluator.Negate(encrypted1, null));
+            Utilities.AssertThrows<ArgumentNullException>(() => evaluator.Negate(null, encrypted2));
+            Utilities.AssertThrows<ArgumentException>(() => evaluator.Negate(encrypted1, encrypted2));
+
+            Utilities.AssertThrows<ArgumentNullException>(() => evaluator.NegateInplace(null));
+
+            Utilities.AssertThrows<ArgumentNullException>(() => evaluator.Relinearize(encrypted1, relinKeys, null));
+            Utilities.AssertThrows<ArgumentNullException>(() => evaluator.Relinearize(encrypted1, null, encrypted2));
+            Utilities.AssertThrows<ArgumentNullException>(() => evaluator.Relinearize(null, relinKeys, encrypted2));
+            Utilities.AssertThrows<ArgumentException>(() => evaluator.Relinearize(encrypted1, relinKeys, encrypted2, pool));
+
+            Utilities.AssertThrows<ArgumentNullException>(() => evaluator.RelinearizeInplace(encrypted1, null));
+            Utilities.AssertThrows<ArgumentNullException>(() => evaluator.RelinearizeInplace(null, relinKeys));
+            Utilities.AssertThrows<ArgumentException>(() => evaluator.RelinearizeInplace(encrypted1, relinKeys, pool));
+
+            Utilities.AssertThrows<ArgumentNullException>(() => evaluator.RescaleTo(encrypted1, ParmsId.Zero, null));
+            Utilities.AssertThrows<ArgumentNullException>(() => evaluator.RescaleTo(encrypted1, null, encrypted2));
+            Utilities.AssertThrows<ArgumentNullException>(() => evaluator.RescaleTo(null, ParmsId.Zero, encrypted2));
+            Utilities.AssertThrows<ArgumentException>(() => evaluator.RescaleTo(encrypted1, ParmsId.Zero, encrypted2, pool));
+
+            Utilities.AssertThrows<ArgumentNullException>(() => evaluator.RescaleToInplace(encrypted1, null));
+            Utilities.AssertThrows<ArgumentNullException>(() => evaluator.RescaleToInplace(null, ParmsId.Zero));
+            Utilities.AssertThrows<ArgumentException>(() => evaluator.RescaleToInplace(encrypted1, ParmsId.Zero, pool));
+
+            Utilities.AssertThrows<ArgumentNullException>(() => evaluator.RescaleToNext(encrypted1, null));
+            Utilities.AssertThrows<ArgumentNullException>(() => evaluator.RescaleToNext(null, encrypted2));
+            Utilities.AssertThrows<ArgumentException>(() => evaluator.RescaleToNext(encrypted1, encrypted2, pool));
+
+            Utilities.AssertThrows<ArgumentNullException>(() => evaluator.RescaleToNextInplace(null));
+            Utilities.AssertThrows<ArgumentException>(() => evaluator.RescaleToNextInplace(encrypted1, pool));
+
+            Utilities.AssertThrows<ArgumentNullException>(() => evaluator.RotateColumns(encrypted1, galoisKeys, null));
+            Utilities.AssertThrows<ArgumentNullException>(() => evaluator.RotateColumns(encrypted1, null, encrypted2));
+            Utilities.AssertThrows<ArgumentNullException>(() => evaluator.RotateColumns(null, galoisKeys, encrypted2));
+            Utilities.AssertThrows<ArgumentException>(() => evaluator.RotateColumns(encrypted1, galoisKeys, encrypted2, pool));
+
+            Utilities.AssertThrows<ArgumentNullException>(() => evaluator.RotateColumnsInplace(encrypted1, null));
+            Utilities.AssertThrows<ArgumentNullException>(() => evaluator.RotateColumnsInplace(null, galoisKeys));
+            Utilities.AssertThrows<ArgumentException>(() => evaluator.RotateColumnsInplace(encrypted1, galoisKeys, pool));
+
+            Utilities.AssertThrows<ArgumentNullException>(() => evaluator.RotateRows(encrypted1, 1, galoisKeys, null));
+            Utilities.AssertThrows<ArgumentNullException>(() => evaluator.RotateRows(encrypted1, 1, null, encrypted2));
+            Utilities.AssertThrows<ArgumentNullException>(() => evaluator.RotateRows(null, 1, galoisKeys, encrypted2));
+            Utilities.AssertThrows<ArgumentException>(() => evaluator.RotateRows(encrypted1, 1, galoisKeys, encrypted2, pool));
+
+            Utilities.AssertThrows<ArgumentNullException>(() => evaluator.RotateRowsInplace(encrypted1, 1, null));
+            Utilities.AssertThrows<ArgumentNullException>(() => evaluator.RotateRowsInplace(null, 1, galoisKeys));
+            Utilities.AssertThrows<ArgumentException>(() => evaluator.RotateRowsInplace(encrypted1, 1, galoisKeys, pool));
+
+            Utilities.AssertThrows<ArgumentNullException>(() => evaluator.RotateVector(encrypted1, 1, galoisKeys, null));
+            Utilities.AssertThrows<ArgumentNullException>(() => evaluator.RotateVector(encrypted1, 1, null, encrypted2));
+            Utilities.AssertThrows<ArgumentNullException>(() => evaluator.RotateVector(null, 1, galoisKeys, encrypted2));
+
+            Utilities.AssertThrows<ArgumentNullException>(() => evaluator.RotateVectorInplace(encrypted1, 1, null));
+            Utilities.AssertThrows<ArgumentNullException>(() => evaluator.RotateVectorInplace(null, 1, galoisKeys));
+
+            Utilities.AssertThrows<ArgumentNullException>(() => evaluator.Square(encrypted1, null));
+            Utilities.AssertThrows<ArgumentNullException>(() => evaluator.Square(null, encrypted2));
+            Utilities.AssertThrows<ArgumentException>(() => evaluator.Square(encrypted1, encrypted2, pool));
+
+            Utilities.AssertThrows<ArgumentNullException>(() => evaluator.SquareInplace(null));
+            Utilities.AssertThrows<ArgumentException>(() => evaluator.SquareInplace(encrypted1, pool));
+
+            Utilities.AssertThrows<ArgumentNullException>(() => evaluator.Sub(encrypted1, encrypted2, null));
+            Utilities.AssertThrows<ArgumentNullException>(() => evaluator.Sub(encrypted1, null, encrypted3));
+            Utilities.AssertThrows<ArgumentNullException>(() => evaluator.Sub(null, encrypted2, encrypted3));
+            Utilities.AssertThrows<ArgumentException>(() => evaluator.Sub(encrypted1, encrypted2, encrypted3));
+
+            Utilities.AssertThrows<ArgumentNullException>(() => evaluator.SubInplace(encrypted1, null));
+            Utilities.AssertThrows<ArgumentNullException>(() => evaluator.SubInplace(null, encrypted2));
+
+            Utilities.AssertThrows<ArgumentNullException>(() => evaluator.SubPlain(encrypted1, plain1, null));
+            Utilities.AssertThrows<ArgumentNullException>(() => evaluator.SubPlain(encrypted1, null, encrypted2));
+            Utilities.AssertThrows<ArgumentNullException>(() => evaluator.SubPlain(null, plain1, encrypted2));
+            Utilities.AssertThrows<ArgumentException>(() => evaluator.SubPlain(encrypted1, plain1, encrypted2));
+
+            Utilities.AssertThrows<ArgumentNullException>(() => evaluator.SubPlainInplace(encrypted1, null));
+            Utilities.AssertThrows<ArgumentNullException>(() => evaluator.SubPlainInplace(null, plain1));
+            Utilities.AssertThrows<ArgumentException>(() => evaluator.SubPlainInplace(encrypted1, plain1));
+
+            Utilities.AssertThrows<ArgumentNullException>(() => evaluator.TransformFromNTT(encrypted1, null));
+            Utilities.AssertThrows<ArgumentNullException>(() => evaluator.TransformFromNTT(null, encrypted2));
+            Utilities.AssertThrows<ArgumentException>(() => evaluator.TransformFromNTT(encrypted1, encrypted2));
+
+            Utilities.AssertThrows<ArgumentNullException>(() => evaluator.TransformFromNTTInplace(null));
+
+            Utilities.AssertThrows<ArgumentNullException>(() => evaluator.TransformToNTT(encrypted1, null));
+            Utilities.AssertThrows<ArgumentNullException>(() => evaluator.TransformToNTT(null, encrypted2));
+
+            Utilities.AssertThrows<ArgumentNullException>(() => evaluator.TransformToNTTInplace(null));
+
+            Utilities.AssertThrows<ArgumentNullException>(() => evaluator.TransformToNTT(plain1, ParmsId.Zero, null));
+            Utilities.AssertThrows<ArgumentNullException>(() => evaluator.TransformToNTT(plain1, null, plain2));
+            Utilities.AssertThrows<ArgumentNullException>(() => evaluator.TransformToNTT(null, ParmsId.Zero, plain2));
+            Utilities.AssertThrows<ArgumentException>(() => evaluator.TransformToNTT(plain1, ParmsId.Zero, plain2, pool));
+
+            Utilities.AssertThrows<ArgumentNullException>(() => evaluator.TransformToNTTInplace(plain1, null));
+            Utilities.AssertThrows<ArgumentNullException>(() => evaluator.TransformToNTTInplace(null, ParmsId.Zero));
+            Utilities.AssertThrows<ArgumentException>(() => evaluator.TransformToNTTInplace(plain1, ParmsId.Zero, pool));
+        }
+
+        /// <summary>
+        /// Returns true if the two given collections have equivalent elements, false otherwise
+        /// </summary>
+        private static bool AreCollectionsEqual<T>(IEnumerable<T> coll1, IEnumerable<T> coll2)
+        {
+            int size1 = coll1.Count();
+            int size2 = coll2.Count();
+
+            if (size1 != size2)
+                return false;
+
+            IEnumerator<T> en1 = coll1.GetEnumerator();
+            IEnumerator<T> en2 = coll2.GetEnumerator();
+
+            while (en1.MoveNext() && en2.MoveNext())
+            {
+                if (!en1.Current.Equals(en2.Current))
+                    return false;
+            }
+
+            return true;
+        }
+    }
+}

bigpiseal3.5.1/dotnet/tests/GaloisKeysTests.cs

+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT license.
+
+using Microsoft.Research.SEAL;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+
+namespace SEALNetTest
+{
+    [TestClass]
+    public class GaloisKeysTests
+    {
+        [TestMethod]
+        public void CreateTest()
+        {
+            GaloisKeys keys = new GaloisKeys();
+
+            Assert.IsNotNull(keys);
+            Assert.AreEqual(0ul, keys.Size);
+        }
+
+        [TestMethod]
+        public void CreateNonEmptyTest()
+        {
+            SEALContext context = GlobalContext.BFVContext;
+            KeyGenerator keygen = new KeyGenerator(context);
+
+            GaloisKeys keys = keygen.GaloisKeysLocal();
+
+            Assert.IsNotNull(keys);
+            Assert.AreEqual(24ul, keys.Size);
+
+            GaloisKeys copy = new GaloisKeys(keys);
+
+            Assert.IsNotNull(copy);
+            Assert.AreEqual(24ul, copy.Size);
+        }
+
+        [TestMethod]
+        public void SaveLoadTest()
+        {
+            SEALContext context = GlobalContext.BFVContext;
+            KeyGenerator keyGen = new KeyGenerator(context);
+
+            GaloisKeys keys = keyGen.GaloisKeysLocal();
+            GaloisKeys other = new GaloisKeys();
+
+            Assert.IsNotNull(keys);
+            Assert.AreEqual(24ul, keys.Size);
+
+            using (MemoryStream ms = new MemoryStream())
+            {
+                keys.Save(ms);
+
+                ms.Seek(offset: 0, loc: SeekOrigin.Begin);
+
+                other.Load(context, ms);
+            }
+
+            Assert.AreEqual(24ul, other.Size);
+            Assert.IsTrue(ValCheck.IsValidFor(other, context));
+
+            List<IEnumerable<PublicKey>> keysData = new List<IEnumerable<PublicKey>>(keys.Data);
+            List<IEnumerable<PublicKey>> otherData = new List<IEnumerable<PublicKey>>(other.Data);
+
+            Assert.AreEqual(keysData.Count, otherData.Count);
+            for (int i = 0; i < keysData.Count; i++)
+            {
+                List<PublicKey> keysCiphers = new List<PublicKey>(keysData[i]);
+                List<PublicKey> otherCiphers = new List<PublicKey>(otherData[i]);
+
+                Assert.AreEqual(keysCiphers.Count, otherCiphers.Count);
+
+                for (int j = 0; j < keysCiphers.Count; j++)
+                {
+                    PublicKey keysCipher = keysCiphers[j];
+                    PublicKey otherCipher = otherCiphers[j];
+
+                    Assert.AreEqual(keysCipher.Data.Size, otherCipher.Data.Size);
+                    Assert.AreEqual(keysCipher.Data.PolyModulusDegree, otherCipher.Data.PolyModulusDegree);
+                    Assert.AreEqual(keysCipher.Data.CoeffModulusSize, otherCipher.Data.CoeffModulusSize);
+
+                    ulong coeffCount = keysCipher.Data.Size * keysCipher.Data.PolyModulusDegree * keysCipher.Data.CoeffModulusSize;
+                    for (ulong k = 0; k < coeffCount; k++)
+                    {
+                        Assert.AreEqual(keysCipher.Data[k], otherCipher.Data[k]);
+                    }
+                }
+            }
+        }
+
+        [TestMethod]
+        public void SeededKeyTest()
+        {
+            EncryptionParameters parms = new EncryptionParameters(SchemeType.BFV)
+            {
+                PolyModulusDegree = 8,
+                PlainModulus = new Modulus(257),
+                CoeffModulus = CoeffModulus.Create(8, new int[] { 40, 40 })
+            };
+            SEALContext context = new SEALContext(parms,
+                expandModChain: false,
+                secLevel: SecLevelType.None);
+            KeyGenerator keygen = new KeyGenerator(context);
+            Encryptor encryptor = new Encryptor(context, keygen.PublicKey);
+            Decryptor decryptor = new Decryptor(context, keygen.SecretKey);
+            Evaluator evaluator = new Evaluator(context);
+            BatchEncoder encoder = new BatchEncoder(context);
+
+            GaloisKeys galoisKeys = new GaloisKeys();
+            using (MemoryStream stream = new MemoryStream())
+            {
+                keygen.GaloisKeys().Save(stream);
+                stream.Seek(0, SeekOrigin.Begin);
+                galoisKeys.Load(context, stream);
+            }
+
+            Plaintext plain = new Plaintext();
+            List<ulong> vec = new List<ulong>
+            {
+                1, 2, 3, 4,
+                5, 6, 7, 8
+            };
+
+            encoder.Encode(vec, plain);
+
+            Ciphertext encrypted = new Ciphertext();
+            Ciphertext encdest = new Ciphertext();
+            Plaintext plaindest = new Plaintext();
+
+            encryptor.Encrypt(plain, encrypted);
+            evaluator.RotateColumns(encrypted, galoisKeys, encdest);
+            decryptor.Decrypt(encdest, plaindest);
+            encoder.Decode(plaindest, vec);
+
+            Assert.IsTrue(AreCollectionsEqual(vec, new List<ulong>
+            {
+                5, 6, 7, 8,
+                1, 2, 3, 4
+            }));
+
+            evaluator.RotateRows(encdest, -1, galoisKeys, encrypted);
+            decryptor.Decrypt(encrypted, plaindest);
+            encoder.Decode(plaindest, vec);
+
+            Assert.IsTrue(AreCollectionsEqual(vec, new List<ulong>
+            {
+                8, 5, 6, 7,
+                4, 1, 2, 3
+            }));
+
+            evaluator.RotateRowsInplace(encrypted, 2, galoisKeys);
+            decryptor.Decrypt(encrypted, plaindest);
+            encoder.Decode(plaindest, vec);
+
+            Assert.IsTrue(AreCollectionsEqual(vec, new List<ulong>
+            {
+                6, 7, 8, 5,
+                2, 3, 4, 1
+            }));
+
+            evaluator.RotateColumnsInplace(encrypted, galoisKeys);
+            decryptor.Decrypt(encrypted, plaindest);
+            encoder.Decode(plaindest, vec);
+
+            Assert.IsTrue(AreCollectionsEqual(vec, new List<ulong>
+            {
+                2, 3, 4, 1,
+                6, 7, 8, 5
+            }));
+        }
+
+        [TestMethod]
+        public void SetTest()
+        {
+            SEALContext context = GlobalContext.BFVContext;
+            KeyGenerator keygen = new KeyGenerator(context);
+
+            GaloisKeys keys = keygen.GaloisKeysLocal();
+
+            Assert.IsNotNull(keys);
+            Assert.AreEqual(24ul, keys.Size);
+
+            GaloisKeys keys2 = new GaloisKeys();
+
+            Assert.IsNotNull(keys2);
+            Assert.AreEqual(0ul, keys2.Size);
+
+            keys2.Set(keys);
+
+            Assert.AreNotSame(keys, keys2);
+            Assert.AreEqual(24ul, keys2.Size);
+        }
+
+        [TestMethod]
+        public void KeyTest()
+        {
+            SEALContext context = GlobalContext.BFVContext;
+            KeyGenerator keygen = new KeyGenerator(context);
+
+            GaloisKeys keys = keygen.GaloisKeysLocal();
+            MemoryPoolHandle handle = keys.Pool;
+
+            Assert.IsNotNull(keys);
+            Assert.AreEqual(24ul, keys.Size);
+
+            Assert.IsFalse(keys.HasKey(galoisElt: 1));
+            Assert.IsTrue(keys.HasKey(galoisElt: 3));
+            Assert.IsFalse(keys.HasKey(galoisElt: 5));
+            Assert.IsFalse(keys.HasKey(galoisElt: 7));
+            Assert.IsTrue(keys.HasKey(galoisElt: 9));
+            Assert.IsFalse(keys.HasKey(galoisElt: 11));
+
+            IEnumerable<PublicKey> key = keys.Key(3);
+            Assert.AreEqual(4, key.Count());
+
+            IEnumerable<PublicKey> key2 = keys.Key(9);
+            Assert.AreEqual(4, key2.Count());
+
+            Assert.IsTrue(handle.AllocByteCount > 0ul);
+        }
+
+        [TestMethod]
+        public void KeyEltTest()
+        {
+            SEALContext context = GlobalContext.BFVContext;
+            KeyGenerator keygen = new KeyGenerator(context);
+
+            GaloisKeys keys = keygen.GaloisKeysLocal(galoisElts: new uint[] { 1, 3 });
+            Assert.IsNotNull(keys);
+
+            Assert.AreEqual(2ul, keys.Size);
+
+            Assert.IsTrue(keys.HasKey(1));
+            Assert.IsTrue(keys.HasKey(3));
+            Assert.IsFalse(keys.HasKey(5));
+        }
+
+        [TestMethod]
+        public void KeyStepTest()
+        {
+            EncryptionParameters parms = new EncryptionParameters(SchemeType.CKKS)
+            {
+                PolyModulusDegree = 64,
+                CoeffModulus = CoeffModulus.Create(64, new int[] { 60, 60 })
+            };
+            SEALContext context = new SEALContext(parms,
+                expandModChain: false,
+                secLevel: SecLevelType.None);
+            KeyGenerator keygen = new KeyGenerator(context);
+
+            GaloisKeys keys = keygen.GaloisKeysLocal(steps: new int[] { 1, 2, 3 });
+            Assert.IsNotNull(keys);
+
+            Assert.AreEqual(3ul, keys.Size);
+
+            Assert.IsFalse(keys.HasKey(1));
+            Assert.IsTrue(keys.HasKey(3));
+            Assert.IsFalse(keys.HasKey(5));
+            Assert.IsFalse(keys.HasKey(7));
+            Assert.IsTrue(keys.HasKey(9));
+            Assert.IsFalse(keys.HasKey(11));
+            Assert.IsFalse(keys.HasKey(13));
+            Assert.IsFalse(keys.HasKey(15));
+            Assert.IsFalse(keys.HasKey(17));
+            Assert.IsFalse(keys.HasKey(19));
+            Assert.IsFalse(keys.HasKey(21));
+            Assert.IsFalse(keys.HasKey(23));
+            Assert.IsFalse(keys.HasKey(25));
+            Assert.IsTrue(keys.HasKey(27));
+        }
+
+        [TestMethod]
+        public void ExceptionsTest()
+        {
+            SEALContext context = GlobalContext.BFVContext;
+            GaloisKeys keys = new GaloisKeys();
+
+            Utilities.AssertThrows<ArgumentNullException>(() => keys = new GaloisKeys(null));
+
+            Utilities.AssertThrows<ArgumentNullException>(() => keys.Set(null));
+
+            Utilities.AssertThrows<ArgumentNullException>(() => ValCheck.IsValidFor(keys, null));
+
+            Utilities.AssertThrows<ArgumentNullException>(() => keys.Save(null));
+
+            Utilities.AssertThrows<ArgumentNullException>(() => keys.UnsafeLoad(context, null));
+            Utilities.AssertThrows<EndOfStreamException>(() => keys.UnsafeLoad(context, new MemoryStream()));
+            Utilities.AssertThrows<ArgumentNullException>(() => keys.UnsafeLoad(null, new MemoryStream()));
+
+            Utilities.AssertThrows<ArgumentNullException>(() => keys.Load(context, null));
+            Utilities.AssertThrows<ArgumentNullException>(() => keys.Load(null, new MemoryStream()));
+        }
+
+        /// <summary>
+        /// Returns true if the two given collections have equivalent elements, false otherwise
+        /// </summary>
+        private static bool AreCollectionsEqual<T>(IEnumerable<T> coll1, IEnumerable<T> coll2)
+        {
+            int size1 = coll1.Count();
+            int size2 = coll2.Count();
+
+            if (size1 != size2)
+                return false;
+
+            IEnumerator<T> en1 = coll1.GetEnumerator();
+            IEnumerator<T> en2 = coll2.GetEnumerator();
+
+            while (en1.MoveNext() && en2.MoveNext())
+            {
+                if (!en1.Current.Equals(en2.Current))
+                    return false;
+            }
+
+            return true;
+        }
+    }
+}

bigpiseal3.5.1/dotnet/tests/GlobalContext.cs

+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT license.
+
+using Microsoft.Research.SEAL;
+
+namespace SEALNetTest
+{
+    /// <summary>
+    /// Provides a global SEALContext that can be used by Tests.
+    /// Necessary to run tests fast, as creating a SEALContext can take around
+    /// 2 seconds.
+    /// </summary>
+    static class GlobalContext
+    {
+        static GlobalContext()
+        {
+            EncryptionParameters encParams = new EncryptionParameters(SchemeType.BFV)
+            {
+                PolyModulusDegree = 8192,
+                CoeffModulus = CoeffModulus.BFVDefault(polyModulusDegree: 8192)
+            };
+            encParams.SetPlainModulus(65537ul);
+            BFVContext = new SEALContext(encParams);
+
+            encParams = new EncryptionParameters(SchemeType.CKKS)
+            {
+                PolyModulusDegree = 8192,
+                CoeffModulus = CoeffModulus.BFVDefault(polyModulusDegree: 8192)
+            };
+            CKKSContext = new SEALContext(encParams);
+        }
+
+        public static SEALContext BFVContext { get; private set; } = null;
+        public static SEALContext CKKSContext { get; private set; } = null;
+    }
+}

bigpiseal3.5.1/dotnet/tests/IntegerEncoderTests.cs

+using Microsoft.Research.SEAL;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using System;
+
+namespace SEALNetTest
+{
+    [TestClass]
+    public class IntegerEncoderTests
+    {
+        [TestMethod]
+        public void CreateTest()
+        {
+            IntegerEncoder encoder = new IntegerEncoder(GlobalContext.BFVContext);
+            Assert.IsNotNull(encoder);
+            Assert.AreEqual(65537ul, encoder.PlainModulus.Value);
+        }
+
+        [TestMethod]
+        public void EncodeTest()
+        {
+            IntegerEncoder encoder = new IntegerEncoder(GlobalContext.BFVContext);
+
+            Plaintext plain = encoder.Encode(10);
+            Assert.IsNotNull(plain);
+            Assert.AreEqual(4ul, plain.CoeffCount);
+            Assert.AreEqual(0ul, plain[0]);
+            Assert.AreEqual(1ul, plain[1]);
+            Assert.AreEqual(0ul, plain[2]);
+            Assert.AreEqual(1ul, plain[3]);
+
+            plain = encoder.Encode(13u);
+            Assert.AreEqual(4ul, plain.CoeffCount);
+            Assert.AreEqual(1ul, plain[0]);
+            Assert.AreEqual(0ul, plain[1]);
+            Assert.AreEqual(1ul, plain[2]);
+            Assert.AreEqual(1ul, plain[3]);
+
+            plain = encoder.Encode(20L);
+            Assert.AreEqual(5ul, plain.CoeffCount);
+            Assert.AreEqual(0ul, plain[0]);
+            Assert.AreEqual(0ul, plain[1]);
+            Assert.AreEqual(1ul, plain[2]);
+            Assert.AreEqual(0ul, plain[3]);
+            Assert.AreEqual(1ul, plain[4]);
+
+            plain = encoder.Encode(15ul);
+            Assert.AreEqual(4ul, plain.CoeffCount);
+            Assert.AreEqual(1ul, plain[0]);
+            Assert.AreEqual(1ul, plain[1]);
+            Assert.AreEqual(1ul, plain[2]);
+            Assert.AreEqual(1ul, plain[3]);
+
+            BigUInt bui = new BigUInt("AB");
+            plain = encoder.Encode(bui);
+            Assert.AreEqual(8ul, plain.CoeffCount);
+            Assert.AreEqual(1ul, plain[0]);
+            Assert.AreEqual(1ul, plain[1]);
+            Assert.AreEqual(0ul, plain[2]);
+            Assert.AreEqual(1ul, plain[3]);
+            Assert.AreEqual(0ul, plain[4]);
+            Assert.AreEqual(1ul, plain[5]);
+            Assert.AreEqual(0ul, plain[6]);
+            Assert.AreEqual(1ul, plain[7]);
+
+            Plaintext plain2 = new Plaintext();
+
+            encoder.Encode(10, plain2);
+            Assert.AreEqual(4ul, plain2.CoeffCount);
+            Assert.AreEqual(0ul, plain2[0]);
+            Assert.AreEqual(1ul, plain2[1]);
+            Assert.AreEqual(0ul, plain2[2]);
+            Assert.AreEqual(1ul, plain2[3]);
+
+            encoder.Encode(13u, plain2);
+            Assert.AreEqual(4ul, plain2.CoeffCount);
+            Assert.AreEqual(1ul, plain2[0]);
+            Assert.AreEqual(0ul, plain2[1]);
+            Assert.AreEqual(1ul, plain2[2]);
+            Assert.AreEqual(1ul, plain2[3]);
+
+            encoder.Encode(20L, plain2);
+            Assert.AreEqual(5ul, plain2.CoeffCount);
+            Assert.AreEqual(0ul, plain2[0]);
+            Assert.AreEqual(0ul, plain2[1]);
+            Assert.AreEqual(1ul, plain2[2]);
+            Assert.AreEqual(0ul, plain2[3]);
+            Assert.AreEqual(1ul, plain2[4]);
+
+            encoder.Encode(15ul, plain2);
+            Assert.AreEqual(4ul, plain2.CoeffCount);
+            Assert.AreEqual(1ul, plain2[0]);
+            Assert.AreEqual(1ul, plain2[1]);
+            Assert.AreEqual(1ul, plain2[2]);
+            Assert.AreEqual(1ul, plain2[3]);
+
+            encoder.Encode(bui, plain2);
+            Assert.AreEqual(8ul, plain2.CoeffCount);
+            Assert.AreEqual(1ul, plain2[0]);
+            Assert.AreEqual(1ul, plain2[1]);
+            Assert.AreEqual(0ul, plain2[2]);
+            Assert.AreEqual(1ul, plain2[3]);
+            Assert.AreEqual(0ul, plain2[4]);
+            Assert.AreEqual(1ul, plain2[5]);
+            Assert.AreEqual(0ul, plain2[6]);
+            Assert.AreEqual(1ul, plain2[7]);
+        }
+
+        [TestMethod]
+        public void DecodeTest()
+        {
+            IntegerEncoder encoder = new IntegerEncoder(GlobalContext.BFVContext);
+
+            Plaintext plain = new Plaintext("0x^5 + 1x^4 + 1x^3 + 1x^1 + 0");
+            Assert.AreEqual(6ul, plain.CoeffCount);
+
+            ulong resultU64 = encoder.DecodeUInt64(plain);
+            Assert.AreEqual(26UL, resultU64);
+
+            long resultI64 = encoder.DecodeInt64(plain);
+            Assert.AreEqual(26L, resultI64);
+
+            uint resultU32 = encoder.DecodeUInt32(plain);
+            Assert.AreEqual(26U, resultU32);
+
+            int resultI32 = encoder.DecodeInt32(plain);
+            Assert.AreEqual(26, resultI32);
+
+            BigUInt bui = encoder.DecodeBigUInt(plain);
+            Assert.IsNotNull(bui);
+            Assert.AreEqual(0, bui.CompareTo(26ul));
+        }
+
+        [TestMethod]
+        public void ExceptionsTest()
+        {
+            SEALContext context = GlobalContext.BFVContext;
+            SEALContext context_null = null;
+            IntegerEncoder enc = new IntegerEncoder(context);
+            BigUInt bui_null = null;
+            BigUInt bui = new BigUInt(5ul);
+            Plaintext plain = new Plaintext();
+
+            Utilities.AssertThrows<ArgumentNullException>(() => enc = new IntegerEncoder(context_null));
+            Utilities.AssertThrows<ArgumentException>(() => enc = new IntegerEncoder(GlobalContext.CKKSContext));
+
+            Utilities.AssertThrows<ArgumentNullException>(() => enc.Encode(1ul, null));
+            Utilities.AssertThrows<ArgumentNullException>(() => enc.Encode(1L, null));
+            Utilities.AssertThrows<ArgumentNullException>(() => enc.Encode(1, null));
+            Utilities.AssertThrows<ArgumentNullException>(() => enc.Encode(1u, null));
+            Utilities.AssertThrows<ArgumentNullException>(() => enc.Encode(bui_null));
+            Utilities.AssertThrows<ArgumentNullException>(() => enc.Encode(bui, null));
+            Utilities.AssertThrows<ArgumentNullException>(() => enc.Encode(bui_null, plain));
+
+            Utilities.AssertThrows<ArgumentNullException>(() => enc.DecodeUInt32(null));
+            Utilities.AssertThrows<ArgumentNullException>(() => enc.DecodeUInt64(null));
+            Utilities.AssertThrows<ArgumentNullException>(() => enc.DecodeInt32(null));
+            Utilities.AssertThrows<ArgumentNullException>(() => enc.DecodeInt64(null));
+            Utilities.AssertThrows<ArgumentNullException>(() => enc.DecodeBigUInt(null));
+        }
+    }
+}

bigpiseal3.5.1/dotnet/tests/KeyGeneratorTests.cs

+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT license.
+
+using Microsoft.Research.SEAL;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using System;
+using System.Collections.Generic;
+using System.IO;
+
+namespace SEALNetTest
+{
+    [TestClass]
+    public class KeyGeneratorTests
+    {
+        [TestMethod]
+        public void CreateTest()
+        {
+            SEALContext context = GlobalContext.BFVContext;
+            KeyGenerator keygen = new KeyGenerator(context);
+
+            Assert.IsNotNull(keygen);
+
+            PublicKey pubKey = keygen.PublicKey;
+            SecretKey secKey = keygen.SecretKey;
+
+            Assert.IsNotNull(pubKey);
+            Assert.IsNotNull(secKey);
+
+            Ciphertext cipher = pubKey.Data;
+            Assert.IsNotNull(cipher);
+
+            Plaintext plain = secKey.Data;
+            Assert.IsNotNull(plain);
+            Assert.AreEqual(40960ul, plain.CoeffCount);
+        }
+
+        [TestMethod]
+        public void Create2Test()
+        {
+            SEALContext context = GlobalContext.BFVContext;
+            KeyGenerator keygen1 = new KeyGenerator(context);
+            Encryptor encryptor1 = new Encryptor(context, keygen1.PublicKey);
+            Decryptor decryptor1 = new Decryptor(context, keygen1.SecretKey);
+
+            Ciphertext cipher = new Ciphertext();
+            Plaintext plain = new Plaintext("2x^1 + 5");
+            Plaintext plain2 = new Plaintext();
+
+            encryptor1.Encrypt(plain, cipher);
+            decryptor1.Decrypt(cipher, plain2);
+
+            Assert.AreNotSame(plain, plain2);
+            Assert.AreEqual(plain, plain2);
+
+            KeyGenerator keygen2 = new KeyGenerator(context, keygen1.SecretKey);
+            Encryptor encryptor2 = new Encryptor(context, keygen2.PublicKey);
+            Decryptor decryptor2 = new Decryptor(context, keygen2.SecretKey);
+
+            Plaintext plain3 = new Plaintext();
+            decryptor2.Decrypt(cipher, plain3);
+
+            Assert.AreNotSame(plain, plain3);
+            Assert.AreEqual(plain, plain3);
+        }
+
+        [TestMethod]
+        public void KeyCopyTest()
+        {
+            SEALContext context = GlobalContext.BFVContext;
+            PublicKey pk = null;
+            SecretKey sk = null;
+
+            using (KeyGenerator keygen = new KeyGenerator(context))
+            {
+                pk = keygen.PublicKey;
+                sk = keygen.SecretKey;
+            }
+
+            ParmsId parmsIdPK = pk.ParmsId;
+            ParmsId parmsIdSK = sk.ParmsId;
+            Assert.AreEqual(parmsIdPK, parmsIdSK);
+            Assert.AreEqual(parmsIdPK, context.KeyParmsId);
+        }
+
+        [TestMethod]
+        public void ExceptionsTest()
+        {
+            SEALContext context = GlobalContext.BFVContext;
+            KeyGenerator keygen = new KeyGenerator(context);
+            SecretKey secret = new SecretKey();
+            List<uint> elts = new List<uint> { 16385 };
+            List<uint> elts_null = null;
+            List<int> steps = new List<int> { 4096 };
+            List<int> steps_null = null;
+
+            Utilities.AssertThrows<ArgumentNullException>(() => keygen = new KeyGenerator(null));
+
+            Utilities.AssertThrows<ArgumentNullException>(() => keygen = new KeyGenerator(context, null));
+            Utilities.AssertThrows<ArgumentNullException>(() => keygen = new KeyGenerator(null, keygen.SecretKey));
+            Utilities.AssertThrows<ArgumentException>(() => keygen = new KeyGenerator(context, secret));
+
+            Utilities.AssertThrows<ArgumentNullException>(() => keygen.GaloisKeys(elts_null));
+            Utilities.AssertThrows<ArgumentException>(() => keygen.GaloisKeys(elts));
+            Utilities.AssertThrows<ArgumentNullException>(() => keygen.GaloisKeys(steps_null));
+            Utilities.AssertThrows<ArgumentException>(() => keygen.GaloisKeys(steps));
+
+            EncryptionParameters smallParms = new EncryptionParameters(SchemeType.CKKS);
+            smallParms.PolyModulusDegree = 128;
+            smallParms.CoeffModulus = CoeffModulus.Create(smallParms.PolyModulusDegree, new int[] { 60 });
+            context = new SEALContext(smallParms, true, SecLevelType.None);
+            keygen = new KeyGenerator(context);
+            Utilities.AssertThrows<InvalidOperationException>(() => keygen.RelinKeys());
+            Utilities.AssertThrows<InvalidOperationException>(() => keygen.GaloisKeys());
+        }
+    }
+}

bigpiseal3.5.1/dotnet/tests/MemoryManagerTests.cs

+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT license.
+
+using Microsoft.Research.SEAL;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace SEALNetTest
+{
+    [TestClass]
+    public class MemoryManagerTests
+    {
+        [TestMethod]
+        public void SwitchProfileTest()
+        {
+            MemoryPoolHandle handle = MemoryManager.GetPool(MMProfOpt.ForceNew);
+            MMProfFixed fixedProfile = new MMProfFixed(handle);
+
+            MMProf oldProfile = MemoryManager.SwitchProfile(fixedProfile);
+            Assert.IsInstanceOfType(oldProfile, typeof(MMProfGlobal));
+
+            MMProfNew newProfile = new MMProfNew();
+            oldProfile = MemoryManager.SwitchProfile(newProfile);
+
+            Assert.IsInstanceOfType(oldProfile, typeof(MMProfFixed));
+
+            MMProfGlobal globalProfile = new MMProfGlobal();
+            oldProfile = MemoryManager.SwitchProfile(globalProfile);
+
+            Assert.IsInstanceOfType(oldProfile, typeof(MMProfNew));
+
+            MemoryPoolHandle globalHandle = globalProfile.GetPool();
+            Assert.IsNotNull(globalHandle);
+            Assert.IsTrue(globalHandle.IsInitialized);
+        }
+    }
+}
\ No newline at end of file

bigpiseal3.5.1/dotnet/tests/MemoryPoolHandleTests.cs

+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT license.
+
+using Microsoft.Research.SEAL;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using System;
+
+namespace SEALNetTest
+{
+    [TestClass]
+    public class MemoryPoolHandleTests
+    {
+        [TestMethod]
+        public void CreateTest()
+        {
+            MemoryPoolHandle handle = MemoryManager.GetPool();
+            Assert.IsNotNull(handle);
+            Assert.IsTrue(handle.IsInitialized);
+
+            MemoryPoolHandle handle2 = new MemoryPoolHandle(handle);
+            Assert.IsTrue(handle2.IsInitialized);
+            Assert.AreEqual(handle.PoolCount, handle2.PoolCount);
+            Assert.AreEqual(handle.AllocByteCount, handle2.AllocByteCount);
+
+            MemoryPoolHandle handle5 = new MemoryPoolHandle();
+            handle5.Set(handle);
+            Assert.IsTrue(handle5.IsInitialized);
+            Assert.AreEqual(handle.PoolCount, handle5.PoolCount);
+            Assert.AreEqual(handle.AllocByteCount, handle5.AllocByteCount);
+
+            MemoryPoolHandle handle3 = MemoryManager.GetPool(MMProfOpt.ForceNew, clearOnDestruction: true);
+            Assert.IsNotNull(handle3);
+            Assert.AreEqual(0ul, handle3.PoolCount);
+            Assert.AreEqual(0ul, handle3.AllocByteCount);
+
+            MemoryPoolHandle handle4 = MemoryManager.GetPool(MMProfOpt.ForceThreadLocal);
+            Assert.IsNotNull(handle4);
+            Assert.AreEqual(0ul, handle4.PoolCount);
+            Assert.AreEqual(0ul, handle4.AllocByteCount);
+        }
+
+        [TestMethod]
+        public void EqualsTest()
+        {
+            MemoryPoolHandle handle1 = MemoryManager.GetPool(MMProfOpt.ForceNew);
+            MemoryPoolHandle handle2 = MemoryManager.GetPool(MMProfOpt.Default);
+            MemoryPoolHandle handle3 = MemoryManager.GetPool();
+
+            Assert.IsNotNull(handle1);
+            Assert.IsNotNull(handle2);
+            Assert.IsNotNull(handle3);
+
+            Assert.AreNotEqual(handle1, handle2);
+            Assert.AreNotEqual(handle1, handle3);
+            Assert.AreEqual(handle2, handle3);
+
+            Assert.AreNotEqual(handle1.GetHashCode(), handle2.GetHashCode());
+
+            Assert.IsFalse(handle3.Equals(null));
+        }
+
+        [TestMethod]
+        public void StaticMethodsTest()
+        {
+            MemoryPoolHandle handle1 = MemoryPoolHandle.Global();
+            Assert.IsNotNull(handle1);
+
+            MemoryPoolHandle handle2 = MemoryPoolHandle.New(clearOnDestruction: true);
+            Assert.IsNotNull(handle2);
+
+            MemoryPoolHandle handle3 = MemoryPoolHandle.ThreadLocal();
+            Assert.IsNotNull(handle3);
+        }
+
+        [TestMethod]
+        public void UseCountTest()
+        {
+            MemoryPoolHandle pool = MemoryPoolHandle.New();
+            Assert.AreEqual(1L, pool.UseCount);
+            Plaintext plain = new Plaintext(pool);
+            Assert.AreEqual(2L, pool.UseCount);
+            Plaintext plain2 = new Plaintext(pool);
+            Assert.AreEqual(3L, pool.UseCount);
+            plain.Dispose();
+            plain2.Dispose();
+            Assert.AreEqual(1L, pool.UseCount);
+        }
+
+        [TestMethod]
+        public void ExceptionsTest()
+        {
+            MemoryPoolHandle handle = new MemoryPoolHandle();
+
+            Utilities.AssertThrows<ArgumentNullException>(() => handle = new MemoryPoolHandle(null));
+
+            Utilities.AssertThrows<ArgumentNullException>(() => handle.Set(null));
+        }
+    }
+}
\ No newline at end of file

bigpiseal3.5.1/dotnet/tests/ModulusTests.cs

+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT license.
+
+using Microsoft.Research.SEAL;
+using System;
+using System.IO;
+using System.Collections.Generic;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace SEALNetTest
+{
+    [TestClass]
+    public class ModulusTests
+    {
+        [TestMethod]
+        public void EmptyConstructorTest()
+        {
+            Modulus sm = new Modulus();
+
+            Assert.IsNotNull(sm);
+            Assert.IsTrue(sm.IsZero);
+            Assert.AreEqual(0ul, sm.Value);
+            Assert.AreEqual(0, sm.BitCount);
+            Assert.AreEqual(1ul, sm.UInt64Count);
+            Assert.IsFalse(sm.IsPrime);
+        }
+
+        [TestMethod]
+        public void ValueConstructorTest()
+        {
+            Modulus sm = new Modulus(5);
+
+            Assert.IsNotNull(sm);
+            Assert.IsFalse(sm.IsZero);
+            Assert.AreEqual(5ul, sm.Value);
+            Assert.AreEqual(3, sm.BitCount);
+            Assert.IsTrue(sm.IsPrime);
+
+            // Value is exactly 61 bits
+            Modulus sm2 = new Modulus(0x1FFFFFFFFFFFFFFFul);
+
+            Assert.IsNotNull(sm2);
+            Assert.IsFalse(sm2.IsZero);
+            Assert.AreEqual(0x1FFFFFFFFFFFFFFFul, sm2.Value);
+            Assert.AreEqual(61, sm2.BitCount);
+            Assert.AreEqual(1ul, sm2.UInt64Count);
+            Assert.IsTrue(sm2.IsPrime);
+
+            Modulus sm3 = new Modulus(0xF00000F000079ul);
+
+            Assert.IsNotNull(sm3);
+            Assert.IsFalse(sm3.IsZero);
+            Assert.AreEqual(0xF00000F000079ul, sm3.Value);
+            Assert.AreEqual(52, sm3.BitCount);
+            Assert.AreEqual(1ul, sm3.UInt64Count);
+            Assert.IsTrue(sm3.IsPrime);
+        }
+
+        [TestMethod]
+        public void CopyConstructorTest()
+        {
+            Modulus sm = new Modulus(10);
+            Modulus copy = new Modulus(sm);
+
+            Assert.IsNotNull(copy);
+            Assert.IsFalse(copy.IsZero);
+            Assert.AreEqual(10ul, copy.Value);
+        }
+
+        [TestMethod]
+        public void ExplicitCreateTest()
+        {
+            Modulus sm = (Modulus)34ul;
+            Assert.IsNotNull(sm);
+            Assert.AreEqual(34ul, sm.Value);
+        }
+
+        [TestMethod]
+        public void ConstructorFail1Test()
+        {
+            // Should fail if value is 1
+            Utilities.AssertThrows<ArgumentException>(() => { Modulus sm = new Modulus(1); });
+        }
+
+        [TestMethod]
+        public void ConstructorFail2Test()
+        {
+            // Should fail if value is larger than 61 bits
+            Utilities.AssertThrows<ArgumentException>(() => { Modulus sm = new Modulus(0x2000000000000000ul); });
+        }
+
+        [TestMethod]
+        public void SetTest()
+        {
+            Modulus sm1 = new Modulus(456);
+            Modulus sm2 = new Modulus();
+
+            Assert.IsFalse(sm1.IsZero);
+            Assert.AreEqual(456ul, sm1.Value);
+            Assert.IsFalse(sm1.IsPrime);
+            Assert.IsTrue(sm2.IsZero);
+            Assert.AreEqual(0ul, sm2.Value);
+            Assert.IsFalse(sm2.IsPrime);
+
+            sm2.Set(sm1);
+
+            Assert.IsFalse(sm2.IsZero);
+            Assert.AreEqual(456ul, sm2.Value);
+            Assert.IsFalse(sm2.IsPrime);
+
+            sm2.Set(value: 65537ul);
+
+            Assert.IsFalse(sm2.IsZero);
+            Assert.AreEqual(65537ul, sm2.Value);
+            Assert.IsTrue(sm2.IsPrime);
+        }
+
+        [TestMethod]
+        public void SetFail1Test()
+        {
+            // Should faile if set to 1
+            Modulus sm = new Modulus();
+            Utilities.AssertThrows<ArgumentException>(() => sm.Set(1));
+        }
+
+        [TestMethod]
+        public void SetFail2Test()
+        {
+            // Should fail if set to bigger than 61 bits
+            Modulus sm = new Modulus();
+            Utilities.AssertThrows<ArgumentException>(() => sm.Set(0x2000000000000000ul));
+        }
+
+        [TestMethod]
+        public void ConstRatioTest()
+        {
+            Modulus sm = new Modulus();
+            sm.Set(0x1234567890ABCDEFul);
+
+            Tuple<ulong, ulong, ulong> ratio = sm.ConstRatio;
+
+            Assert.IsNotNull(ratio);
+            Assert.AreNotEqual(0ul, ratio.Item1);
+            Assert.AreNotEqual(0ul, ratio.Item2);
+            Assert.AreNotEqual(0ul, ratio.Item3);
+
+            sm.Set(0xF00000F000079ul);
+            ratio = sm.ConstRatio;
+
+            Assert.IsNotNull(ratio);
+            Assert.AreEqual(1224979096621368355ul, ratio.Item1);
+            Assert.AreEqual(4369ul, ratio.Item2);
+            Assert.AreEqual(1144844808538997ul, ratio.Item3);
+        }
+
+        [TestMethod]
+        public void EqualsTest()
+        {
+            Modulus sm1 = new Modulus(0x12345ul);
+            Modulus sm2 = new Modulus(0x12345ul);
+
+            Assert.AreEqual(sm1, sm2);
+            Assert.AreEqual(sm1.GetHashCode(), sm2.GetHashCode());
+            Assert.IsTrue(sm1.Equals(0x12345ul));
+            Assert.IsFalse(sm1.Equals(0x1234ul));
+
+            Assert.IsFalse(sm1.Equals(null));
+        }
+
+        [TestMethod]
+        public void CompareToTest()
+        {
+            Modulus sminv = null;
+            Modulus sm0 = new Modulus();
+            Modulus sm2 = new Modulus(2);
+            Modulus sm5 = new Modulus(5);
+            Modulus smbig = new Modulus(0xFFFFFFF);
+            Assert.AreEqual(1, sm0.CompareTo(sminv));
+            Assert.AreEqual(0, sm0.CompareTo(sm0));
+            Assert.AreEqual(-1, sm2.CompareTo(sm5));
+            Assert.AreEqual(-1, sm2.CompareTo(smbig));
+            Assert.AreEqual(1, sm2.CompareTo(sminv));
+            Assert.AreEqual(0, sm5.CompareTo(sm5));
+            Assert.AreEqual(0, smbig.CompareTo(smbig));
+            Assert.AreEqual(1, smbig.CompareTo(sm0));
+            Assert.AreEqual(1, smbig.CompareTo(sm5));
+            Assert.AreEqual(1, smbig.CompareTo(sminv));
+            Assert.AreEqual(-1, sm5.CompareTo(6));
+            Assert.AreEqual(0, sm5.CompareTo(5));
+            Assert.AreEqual(1, sm5.CompareTo(4));
+            Assert.AreEqual(1, sm5.CompareTo(0));
+        }
+
+        [TestMethod]
+        public void SaveLoadTest()
+        {
+            Modulus sm1 = new Modulus(65537ul);
+            Modulus sm2 = new Modulus();
+
+            Assert.AreNotSame(sm1, sm2);
+            Assert.AreNotEqual(sm1, sm2);
+            Assert.AreNotEqual(sm1.IsPrime, sm2.IsPrime);
+
+            using (MemoryStream stream = new MemoryStream())
+            {
+                sm1.Save(stream);
+                stream.Seek(offset: 0, loc: SeekOrigin.Begin);
+                sm2.Load(stream);
+            }
+
+            Assert.AreNotSame(sm1, sm2);
+            Assert.AreEqual(sm1, sm2);
+            Assert.AreEqual(sm1.BitCount, sm2.BitCount);
+            Assert.AreEqual(sm1.UInt64Count, sm2.UInt64Count);
+            Assert.AreEqual(sm1.ConstRatio.Item1, sm2.ConstRatio.Item1);
+            Assert.AreEqual(sm1.ConstRatio.Item2, sm2.ConstRatio.Item2);
+            Assert.AreEqual(sm1.ConstRatio.Item3, sm2.ConstRatio.Item3);
+            Assert.AreEqual(sm1.IsPrime, sm2.IsPrime);
+        }
+
+        [TestMethod]
+        public void CreateTest()
+        {
+            List<Modulus> cm = (List<Modulus>)CoeffModulus.Create(2, new int[]{ });
+            Assert.AreEqual(0, cm.Count);
+
+            cm = (List<Modulus>)CoeffModulus.Create(2, new int[] { 3 });
+            Assert.AreEqual(1, cm.Count);
+            Assert.AreEqual(5ul, cm[0].Value);
+
+            cm = (List<Modulus>)CoeffModulus.Create(2, new int[] { 3, 4 });
+            Assert.AreEqual(2, cm.Count);
+            Assert.AreEqual(5ul, cm[0].Value);
+            Assert.AreEqual(13ul, cm[1].Value);
+
+            cm = (List<Modulus>)CoeffModulus.Create(2, new int[] { 3, 5, 4, 5 });
+            Assert.AreEqual(4, cm.Count);
+            Assert.AreEqual(5ul, cm[0].Value);
+            Assert.AreEqual(17ul, cm[1].Value);
+            Assert.AreEqual(13ul, cm[2].Value);
+            Assert.AreEqual(29ul, cm[3].Value);
+
+            cm = (List<Modulus>)CoeffModulus.Create(32, new int[] { 30, 40, 30, 30, 40 });
+            Assert.AreEqual(5, cm.Count);
+            Assert.AreEqual(30, (int)(Math.Log(cm[0].Value, 2)) + 1);
+            Assert.AreEqual(40, (int)(Math.Log(cm[1].Value, 2)) + 1);
+            Assert.AreEqual(30, (int)(Math.Log(cm[2].Value, 2)) + 1);
+            Assert.AreEqual(30, (int)(Math.Log(cm[3].Value, 2)) + 1);
+            Assert.AreEqual(40, (int)(Math.Log(cm[4].Value, 2)) + 1);
+            Assert.AreEqual(1ul, cm[0].Value % 64);
+            Assert.AreEqual(1ul, cm[1].Value % 64);
+            Assert.AreEqual(1ul, cm[2].Value % 64);
+            Assert.AreEqual(1ul, cm[3].Value % 64);
+            Assert.AreEqual(1ul, cm[4].Value % 64);
+        }
+
+        [TestMethod]
+        public void ExceptionsTest()
+        {
+            Modulus sm = new Modulus(0x12345ul);
+
+            Utilities.AssertThrows<ArgumentNullException>(() => sm = new Modulus(null));
+            Utilities.AssertThrows<ArgumentNullException>(() => sm.Set(null));
+            Utilities.AssertThrows<ArgumentNullException>(() => sm.Save(null));
+            Utilities.AssertThrows<ArgumentNullException>(() => sm.Load(null));
+            Utilities.AssertThrows<EndOfStreamException>(() => sm.Load(new MemoryStream()));
+
+            // Too small polyModulusDegree
+            Utilities.AssertThrows<ArgumentException>(() => CoeffModulus.Create(1, new int[] { 2 }));
+
+            // Too large polyModulusDegree
+            Utilities.AssertThrows<ArgumentException>(() => CoeffModulus.Create(262144, new int[] { 30 }));
+
+            // Invalid polyModulusDegree
+            Utilities.AssertThrows<ArgumentException>(() => CoeffModulus.Create(1023, new int[] { 20 }));
+
+            // Invalid bitSize
+            Utilities.AssertThrows<ArgumentException>(() => CoeffModulus.Create(2048, new int[] { 0 }));
+            Utilities.AssertThrows<ArgumentException>(() => CoeffModulus.Create(2048, new int[] { -30 }));
+            Utilities.AssertThrows<ArgumentException>(() => CoeffModulus.Create(2048, new int[] { 30, -30 }));
+
+            // Too small primes requested
+            Utilities.AssertThrows<InvalidOperationException>(() => CoeffModulus.Create(2, new int[] { 2 }));
+            Utilities.AssertThrows<InvalidOperationException>(() => CoeffModulus.Create(2, new int[] { 3, 3, 3 }));
+            Utilities.AssertThrows<InvalidOperationException>(() => CoeffModulus.Create(1024, new int[] { 8 }));
+        }
+    }
+}

bigpiseal3.5.1/dotnet/tests/NativeObjectTests.cs

+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT license.
+
+using Microsoft.Research.SEAL;
+using Microsoft.Research.SEAL.Tools;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace SEALNetTest
+{
+    [TestClass]
+    public class NativeObjectTests
+    {
+        [TestMethod]
+        public void IsDisposedTest()
+        {
+            Ciphertext cipher = new Ciphertext();
+            Assert.IsNotNull(cipher);
+            Assert.AreEqual(0ul, cipher.Size);
+            Assert.AreEqual(0ul, cipher.PolyModulusDegree);
+            Assert.AreEqual(0ul, cipher.CoeffModulusSize);
+
+            // After disposing object, accessing any field should fail.
+            cipher.Dispose();
+            Utilities.AssertThrows<ObjectDisposedException>(() => cipher.Size);
+            Utilities.AssertThrows<ObjectDisposedException>(() => cipher.PolyModulusDegree);
+            Utilities.AssertThrows<ObjectDisposedException>(() => cipher.CoeffModulusSize);
+            Utilities.AssertThrows<ObjectDisposedException>(() => cipher.IsTransparent);
+            Utilities.AssertThrows<ObjectDisposedException>(() => cipher.IsNTTForm);
+        }
+    }
+}

bigpiseal3.5.1/dotnet/tests/ParmsIdTests.cs

+using Microsoft.Research.SEAL;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace SEALNetTest
+{
+    [TestClass]
+    public class ParmsIdTests
+    {
+        [TestMethod]
+        public void ParamIDConstructorTest()
+        {
+            ParmsId id = new ParmsId();
+
+            Assert.AreEqual(0ul, id.Block[0]);
+            Assert.AreEqual(0ul, id.Block[1]);
+            Assert.AreEqual(0ul, id.Block[2]);
+            Assert.AreEqual(0ul, id.Block[3]);
+
+            id.Block[0] = 5;
+            id.Block[1] = 4;
+            id.Block[2] = 3;
+            id.Block[3] = 2;
+
+            ParmsId id2 = new ParmsId(id);
+
+            id.Block[1] = 7;
+
+            Assert.AreEqual(5ul, id2.Block[0]);
+            Assert.AreEqual(4ul, id2.Block[1]);
+            Assert.AreEqual(3ul, id2.Block[2]);
+            Assert.AreEqual(2ul, id2.Block[3]);
+            Assert.AreEqual(7ul, id.Block[1]);
+
+            Assert.IsFalse(id2.Equals(null));
+            Assert.AreNotEqual(id.GetHashCode(), id2.GetHashCode());
+        }
+
+        [TestMethod]
+        public void ToStringTest()
+        {
+            ParmsId id = new ParmsId();
+
+            id.Block[0] = 1;
+            id.Block[1] = 2;
+            id.Block[2] = 3;
+            id.Block[3] = 4;
+
+            Assert.AreEqual("0000000000000001 0000000000000002 0000000000000003 0000000000000004", id.ToString());
+        }
+
+        [TestMethod]
+        public void OperatorsTest()
+        {
+            ParmsId id = new ParmsId();
+
+            id.Block[0] = 1;
+            id.Block[1] = 2;
+            id.Block[2] = 3;
+            id.Block[3] = 4;
+
+            ParmsId id2 = new ParmsId(id);
+
+            ParmsId id3 = new ParmsId(id);
+            id3.Block[0] = 2;
+
+            Assert.IsTrue(id == id2);
+            Assert.IsFalse(id == id3);
+
+            ParmsId id_null1 = null;
+            ParmsId id_null2 = null;
+
+            Assert.IsFalse(id_null1 != id_null2);
+            Assert.IsTrue(id_null1 != id);
+        }
+
+        [TestMethod]
+        public void ExceptionsTest()
+        {
+            ParmsId id = new ParmsId();
+            ParmsId id_null = null;
+
+            Utilities.AssertThrows<ArgumentNullException>(() => id = new ParmsId(id_null));
+        }
+    }
+}

bigpiseal3.5.1/dotnet/tests/PlaintextTests.cs

+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT license.
+
+using Microsoft.Research.SEAL;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using System;
+using System.IO;
+
+namespace SEALNetTest
+{
+    [TestClass]
+    public class PlaintextTests
+    {
+        [TestMethod]
+        public void CreateTest()
+        {
+            Plaintext plain = new Plaintext();
+            Assert.IsNotNull(plain);
+            Assert.AreEqual(0ul, plain.CoeffCount);
+
+            Plaintext plain2 = new Plaintext(capacity: 20, coeffCount: 10);
+            Assert.IsNotNull(plain2);
+            Assert.AreEqual(20ul, plain2.Capacity);
+            Assert.AreEqual(10ul, plain2.CoeffCount);
+
+            Plaintext plain3 = new Plaintext();
+            plain3.Set(plain2);
+
+            Assert.IsNotNull(plain3);
+            Assert.AreEqual(10ul, plain3.Capacity);
+            Assert.AreEqual(10ul, plain3.CoeffCount);
+        }
+
+        [TestMethod]
+        public void CreateWithHexTest()
+        {
+            Plaintext plain = new Plaintext("6x^5 + 5x^4 + 3x^2 + 2x^1 + 1");
+            Assert.IsNotNull(plain);
+            Assert.AreEqual(6ul, plain.CoeffCount);
+            Assert.AreEqual(5ul, plain.NonZeroCoeffCount);
+            Assert.AreEqual(1ul, plain[0]);
+            Assert.AreEqual(2ul, plain[1]);
+            Assert.AreEqual(3ul, plain[2]);
+            Assert.AreEqual(0ul, plain[3]);
+            Assert.AreEqual(5ul, plain[4]);
+            Assert.AreEqual(6ul, plain[5]);
+
+            Plaintext plain2 = new Plaintext("6x^5 + 5x^4 + 3x^2 + 2x^1");
+            Assert.IsNotNull(plain);
+            Assert.AreEqual(6ul, plain2.CoeffCount);
+            Assert.AreEqual(4ul, plain2.NonZeroCoeffCount);
+            Assert.AreEqual(0ul, plain2[0]);
+            Assert.AreEqual(2ul, plain2[1]);
+            Assert.AreEqual(3ul, plain2[2]);
+            Assert.AreEqual(0ul, plain2[3]);
+            Assert.AreEqual(5ul, plain2[4]);
+            Assert.AreEqual(6ul, plain2[5]);
+        }
+
+        [TestMethod]
+        public void CopyTest()
+        {
+            Plaintext plain = new Plaintext("6x^5 + 5x^4 + 3x^2 + 2x^1 + 1");
+            Assert.IsFalse(plain.IsNTTForm);
+            Plaintext plain2 = new Plaintext(plain);
+            Assert.AreEqual(plain, plain2);
+            Assert.IsFalse(plain2.IsNTTForm);
+            Assert.AreEqual(plain.ParmsId, plain2.ParmsId);
+
+            SEALContext context = GlobalContext.BFVContext;
+            Evaluator evaluator = new Evaluator(context);
+            evaluator.TransformToNTTInplace(plain, context.FirstParmsId);
+            Assert.IsTrue(plain.IsNTTForm);
+            Assert.IsFalse(plain2.IsNTTForm);
+            Assert.AreNotEqual(plain.ParmsId, plain2.ParmsId);
+            Assert.AreEqual(plain.ParmsId, context.FirstParmsId);
+
+            Plaintext plain3 = new Plaintext(plain);
+            Assert.AreEqual(plain3, plain);
+            Assert.IsTrue(plain3.IsNTTForm);
+            Assert.AreEqual(plain3.ParmsId, context.FirstParmsId);
+        }
+
+        [TestMethod]
+        public void ToStringTest()
+        {
+            Plaintext plain = new Plaintext(coeffCount: 6);
+            plain[0] = 1;
+            plain[1] = 2;
+            plain[2] = 3;
+            plain[3] = 0;
+            plain[4] = 5;
+            plain[5] = 6;
+
+            Assert.AreEqual(6ul, plain.CoeffCount);
+            Assert.AreEqual(5ul, plain.NonZeroCoeffCount);
+
+            string str = plain.ToString();
+            Assert.AreEqual("6x^5 + 5x^4 + 3x^2 + 2x^1 + 1", str);
+        }
+
+        [TestMethod]
+        public void SetZeroTest()
+        {
+            Plaintext plain = new Plaintext(coeffCount: 10);
+            plain[0] = 1;
+            plain[1] = 2;
+            plain[2] = 3;
+            plain[3] = 4;
+            plain[4] = 5;
+            plain[5] = 6;
+            plain[6] = 7;
+            plain[7] = 8;
+            plain[8] = 9;
+            plain[9] = 10;
+
+            plain.SetZero(6, 3);
+
+            Assert.AreEqual(1ul, plain[0]);
+            Assert.AreEqual(2ul, plain[1]);
+            Assert.AreEqual(3ul, plain[2]);
+            Assert.AreEqual(4ul, plain[3]);
+            Assert.AreEqual(5ul, plain[4]);
+            Assert.AreEqual(6ul, plain[5]);
+            Assert.AreEqual(0ul, plain[6]);
+            Assert.AreEqual(0ul, plain[7]);
+            Assert.AreEqual(0ul, plain[8]);
+            Assert.AreEqual(10ul, plain[9]);
+
+            plain[0] = 1;
+            plain[1] = 2;
+            plain[2] = 3;
+            plain[3] = 4;
+            plain[4] = 5;
+            plain[5] = 6;
+            plain[6] = 7;
+            plain[7] = 8;
+            plain[8] = 9;
+            plain[9] = 10;
+
+            plain.SetZero(4);
+
+            Assert.AreEqual(1ul, plain[0]);
+            Assert.AreEqual(2ul, plain[1]);
+            Assert.AreEqual(3ul, plain[2]);
+            Assert.AreEqual(4ul, plain[3]);
+            Assert.AreEqual(0ul, plain[4]);
+            Assert.AreEqual(0ul, plain[5]);
+            Assert.AreEqual(0ul, plain[6]);
+            Assert.AreEqual(0ul, plain[7]);
+            Assert.AreEqual(0ul, plain[8]);
+            Assert.AreEqual(0ul, plain[9]);
+
+            plain[0] = 1;
+            plain[1] = 2;
+            plain[2] = 3;
+            plain[3] = 4;
+            plain[4] = 5;
+            plain[5] = 6;
+            plain[6] = 7;
+            plain[7] = 8;
+            plain[8] = 9;
+            plain[9] = 10;
+
+            plain.SetZero();
+
+            Assert.AreEqual(0ul, plain[0]);
+            Assert.AreEqual(0ul, plain[1]);
+            Assert.AreEqual(0ul, plain[2]);
+            Assert.AreEqual(0ul, plain[3]);
+            Assert.AreEqual(0ul, plain[4]);
+            Assert.AreEqual(0ul, plain[5]);
+            Assert.AreEqual(0ul, plain[6]);
+            Assert.AreEqual(0ul, plain[7]);
+            Assert.AreEqual(0ul, plain[8]);
+            Assert.AreEqual(0ul, plain[9]);
+        }
+
+        [TestMethod]
+        public void ReserveResizeTest()
+        {
+            Plaintext plain = new Plaintext();
+            MemoryPoolHandle handle = plain.Pool;
+
+            Assert.AreEqual(0ul, plain.CoeffCount);
+            Assert.AreEqual(0ul, plain.NonZeroCoeffCount);
+            Assert.AreEqual(0ul, plain.Capacity);
+
+            plain.Reserve(capacity: 10);
+
+            ulong alloced = handle.AllocByteCount;
+            Assert.IsTrue(alloced > 0ul);
+
+            Assert.AreEqual(0ul, plain.CoeffCount);
+            Assert.AreEqual(0ul, plain.NonZeroCoeffCount);
+            Assert.AreEqual(10ul, plain.Capacity);
+
+            plain.Resize(coeffCount: 11);
+
+            Assert.AreEqual(11ul, plain.CoeffCount);
+            Assert.AreEqual(11ul, plain.Capacity);
+            Assert.AreEqual(0ul, plain.SignificantCoeffCount);
+            Assert.AreEqual(0ul, plain.NonZeroCoeffCount);
+            Assert.IsTrue(handle.AllocByteCount > 0ul);
+        }
+
+        [TestMethod]
+        public void ShrinkToFitTest()
+        {
+            Plaintext plain = new Plaintext();
+
+            plain.Reserve(10000);
+
+            Assert.AreEqual(10000ul, plain.Capacity);
+            Assert.AreEqual(0ul, plain.CoeffCount);
+            Assert.AreEqual(0ul, plain.NonZeroCoeffCount);
+
+            plain.Set("1");
+
+            Assert.AreEqual(10000ul, plain.Capacity);
+            Assert.AreEqual(1ul, plain.CoeffCount);
+            Assert.AreEqual(1ul, plain.NonZeroCoeffCount);
+            Assert.AreEqual(1ul, plain.SignificantCoeffCount);
+
+            plain.ShrinkToFit();
+
+            Assert.AreEqual(1ul, plain.Capacity);
+            Assert.AreEqual(1ul, plain.CoeffCount);
+            Assert.AreEqual(1ul, plain[0]);
+        }
+
+        [TestMethod]
+        public void ReleaseTest()
+        {
+            Plaintext plain = new Plaintext();
+            plain.Reserve(10000);
+
+            plain.Set("3x^2 + 4x^1");
+
+            Assert.AreEqual(10000ul, plain.Capacity);
+            Assert.AreEqual(3ul, plain.CoeffCount);
+            Assert.AreEqual(2ul, plain.NonZeroCoeffCount);
+
+            plain.Release();
+
+            Assert.AreEqual(0ul, plain.Capacity);
+            Assert.AreEqual(0ul, plain.CoeffCount);
+            Assert.AreEqual(0ul, plain.NonZeroCoeffCount);
+        }
+
+        [TestMethod]
+        public void EqualsTest()
+        {
+            Plaintext plain1 = new Plaintext();
+            Plaintext plain2 = new Plaintext();
+
+            plain1.Reserve(10000);
+            plain2.Reserve(500);
+
+            plain1.Set("4x^3 + 5x^2 + 6x^1 + 7");
+            plain2.Set("4x^3 + 5x^2 + 6x^1 + 7");
+
+            Assert.AreEqual(10000ul, plain1.Capacity);
+            Assert.AreEqual(500ul, plain2.Capacity);
+
+            Assert.AreNotSame(plain1, plain2);
+            Assert.AreEqual(plain1, plain2);
+
+            Assert.IsFalse(plain1.Equals(null));
+        }
+
+        [TestMethod]
+        public void SaveLoadTest()
+        {
+            SEALContext context = GlobalContext.BFVContext;
+            Plaintext plain = new Plaintext("6x^5 + 5x^4 + 4x^3 + 3x^2 + 2x^1 + 5");
+            Plaintext other = new Plaintext();
+
+            Assert.AreNotSame(plain, other);
+            Assert.AreNotEqual(plain, other);
+
+            using (MemoryStream stream = new MemoryStream())
+            {
+                plain.Save(stream);
+
+                stream.Seek(offset: 0, loc: SeekOrigin.Begin);
+
+                other.Load(context, stream);
+            }
+
+            Assert.AreNotSame(plain, other);
+            Assert.AreEqual(plain, other);
+            Assert.IsTrue(ValCheck.IsValidFor(other, context));
+        }
+
+        [TestMethod]
+        public void HashCodeTest()
+        {
+            Plaintext plain1 = new Plaintext("6x^40 + 5x^35 + 4x^30 + 3x^20 + 2x^10 + 5");
+            Plaintext plain2 = new Plaintext("1");
+            Plaintext plain3 = new Plaintext("0");
+            Plaintext plain4 = new Plaintext("6x^40 + 5x^35 + 4x^30 + 3x^20 + 2x^10 + 5");
+
+            Assert.AreNotEqual(plain1.GetHashCode(), plain2.GetHashCode());
+            Assert.AreNotEqual(plain1.GetHashCode(), plain3.GetHashCode());
+            Assert.AreNotEqual(plain2.GetHashCode(), plain3.GetHashCode());
+            Assert.AreNotEqual(plain2.GetHashCode(), plain4.GetHashCode());
+            Assert.AreNotEqual(plain3.GetHashCode(), plain4.GetHashCode());
+
+            Assert.AreEqual(plain1.GetHashCode(), plain4.GetHashCode());
+        }
+
+        [TestMethod]
+        public void ExceptionsTest()
+        {
+            SEALContext context = GlobalContext.BFVContext;
+            Plaintext plain = new Plaintext();
+            MemoryPoolHandle pool = MemoryManager.GetPool(MMProfOpt.ForceGlobal);
+            MemoryPoolHandle pool_uninit = new MemoryPoolHandle();
+
+            Utilities.AssertThrows<ArgumentException>(() => plain = new Plaintext(pool_uninit));
+            Utilities.AssertThrows<ArgumentNullException>(() => plain = new Plaintext((string)null, pool));
+
+            Utilities.AssertThrows<ArgumentNullException>(() => plain.Set((Plaintext)null));
+            Utilities.AssertThrows<ArgumentNullException>(() => plain.Set((string)null));
+
+            Utilities.AssertThrows<ArgumentOutOfRangeException>(() => plain.SetZero(100000));
+            Utilities.AssertThrows<ArgumentOutOfRangeException>(() => plain.SetZero(1, 100000));
+            Utilities.AssertThrows<ArgumentOutOfRangeException>(() => plain.SetZero(100000, 1));
+
+            Utilities.AssertThrows<ArgumentNullException>(() => ValCheck.IsValidFor(plain, null));
+
+            Utilities.AssertThrows<ArgumentNullException>(() => plain.Save(null));
+
+            Utilities.AssertThrows<ArgumentNullException>(() => plain.UnsafeLoad(null, new MemoryStream()));
+            Utilities.AssertThrows<ArgumentNullException>(() => plain.UnsafeLoad(context, null));
+            Utilities.AssertThrows<EndOfStreamException>(() => plain.UnsafeLoad(context, new MemoryStream()));
+
+            Utilities.AssertThrows<ArgumentNullException>(() => plain.Load(context, null));
+            Utilities.AssertThrows<ArgumentNullException>(() => plain.Load(null, new MemoryStream()));
+        }
+    }
+}

bigpiseal3.5.1/dotnet/tests/PublicKeyTests.cs

+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT license.
+
+using Microsoft.Research.SEAL;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using System;
+using System.Collections.Generic;
+using System.IO;
+
+namespace SEALNetTest
+{
+    [TestClass]
+    public class PublicKeyTests
+    {
+        [TestMethod]
+        public void CreateTest()
+        {
+            EncryptionParameters parms = new EncryptionParameters(SchemeType.BFV)
+            {
+                PolyModulusDegree = 64,
+                PlainModulus = new Modulus(1 << 6),
+                CoeffModulus = CoeffModulus.Create(64, new int[] { 40 })
+            };
+            SEALContext context = new SEALContext(parms,
+                expandModChain: false,
+                secLevel: SecLevelType.None);
+            KeyGenerator keygen = new KeyGenerator(context);
+
+            PublicKey pub = keygen.PublicKey;
+            PublicKey copy = new PublicKey(pub);
+
+            Assert.IsNotNull(copy);
+            Assert.AreEqual(2ul, copy.Data.Size);
+            Assert.IsTrue(copy.Data.IsNTTForm);
+
+            PublicKey copy2 = new PublicKey();
+            copy2.Set(copy);
+
+            Assert.AreEqual(2ul, copy2.Data.Size);
+            Assert.IsTrue(copy2.Data.IsNTTForm);
+        }
+
+        [TestMethod]
+        public void SaveLoadTest()
+        {
+            EncryptionParameters parms = new EncryptionParameters(SchemeType.BFV)
+            {
+                PolyModulusDegree = 64,
+                PlainModulus = new Modulus(1 << 6),
+                CoeffModulus = CoeffModulus.Create(64, new int[] { 40 })
+            };
+            SEALContext context = new SEALContext(parms,
+                expandModChain: false,
+                secLevel: SecLevelType.None);
+            KeyGenerator keygen = new KeyGenerator(context);
+
+            PublicKey pub = keygen.PublicKey;
+
+            Assert.IsNotNull(pub);
+            Assert.AreEqual(2ul, pub.Data.Size);
+            Assert.IsTrue(pub.Data.IsNTTForm);
+
+            PublicKey pub2 = new PublicKey();
+            MemoryPoolHandle handle = pub2.Pool;
+
+            Assert.AreEqual(0ul, pub2.Data.Size);
+            Assert.IsFalse(pub2.Data.IsNTTForm);
+            Assert.AreEqual(ParmsId.Zero, pub2.ParmsId);
+
+            using (MemoryStream stream = new MemoryStream())
+            {
+                pub.Save(stream);
+
+                stream.Seek(offset: 0, loc: SeekOrigin.Begin);
+
+                pub2.Load(context, stream);
+            }
+
+            Assert.AreNotSame(pub, pub2);
+            Assert.AreEqual(2ul, pub2.Data.Size);
+            Assert.IsTrue(pub2.Data.IsNTTForm);
+            Assert.AreEqual(pub.ParmsId, pub2.ParmsId);
+            Assert.AreNotEqual(ParmsId.Zero, pub2.ParmsId);
+            Assert.IsTrue(handle.AllocByteCount != 0ul);
+        }
+
+        [TestMethod]
+        public void ExceptionsTest()
+        {
+            SEALContext context = GlobalContext.BFVContext;
+            PublicKey key = new PublicKey();
+
+            Utilities.AssertThrows<ArgumentNullException>(() => key = new PublicKey(null));
+
+            Utilities.AssertThrows<ArgumentNullException>(() => key.Set(null));
+
+            Utilities.AssertThrows<ArgumentNullException>(() => key.Save(null));
+            Utilities.AssertThrows<ArgumentNullException>(() => key.UnsafeLoad(context, null));
+            Utilities.AssertThrows<ArgumentNullException>(() => key.UnsafeLoad(null, new MemoryStream()));
+
+            Utilities.AssertThrows<ArgumentNullException>(() => key.Load(context, null));
+            Utilities.AssertThrows<ArgumentNullException>(() => key.Load(null, new MemoryStream()));
+            Utilities.AssertThrows<EndOfStreamException>(() => key.Load(context, new MemoryStream()));
+
+            Utilities.AssertThrows<ArgumentNullException>(() => ValCheck.IsValidFor(key, null));
+        }
+    }
+}

bigpiseal3.5.1/dotnet/tests/RelinKeysTests.cs

+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT license.
+
+using Microsoft.Research.SEAL;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using System;
+using System.Collections.Generic;
+using System.IO;
+
+namespace SEALNetTest
+{
+    [TestClass]
+    public class RelinKeysTests
+    {
+        [TestMethod]
+        public void CreateRelinKeysTest()
+        {
+            RelinKeys keys = new RelinKeys();
+
+            Assert.IsNotNull(keys);
+            Assert.AreEqual(0ul, keys.Size);
+        }
+
+        [TestMethod]
+        public void CreateNonEmptyRelinKeysTest()
+        {
+            SEALContext context = GlobalContext.BFVContext;
+            KeyGenerator keygen = new KeyGenerator(context);
+
+            RelinKeys keys = keygen.RelinKeysLocal();
+
+            Assert.IsNotNull(keys);
+            Assert.AreEqual(1ul, keys.Size);
+
+            RelinKeys copy = new RelinKeys(keys);
+
+            Assert.IsNotNull(copy);
+            Assert.AreEqual(1ul, copy.Size);
+
+            RelinKeys copy2 = new RelinKeys();
+
+            copy2.Set(keys);
+            Assert.IsNotNull(copy2);
+            Assert.AreEqual(1ul, copy2.Size);
+        }
+
+        [TestMethod]
+        public void SaveLoadTest()
+        {
+            SEALContext context = GlobalContext.BFVContext;
+            KeyGenerator keygen = new KeyGenerator(context);
+
+            RelinKeys keys = keygen.RelinKeysLocal();
+
+            Assert.IsNotNull(keys);
+            Assert.AreEqual(1ul, keys.Size);
+
+            RelinKeys other = new RelinKeys();
+            MemoryPoolHandle handle = other.Pool;
+
+            Assert.AreEqual(0ul, other.Size);
+            ulong alloced = handle.AllocByteCount;
+
+            using (MemoryStream ms = new MemoryStream())
+            {
+                keys.Save(ms);
+                ms.Seek(offset: 0, loc: SeekOrigin.Begin);
+                other.Load(context, ms);
+            }
+
+            Assert.AreEqual(1ul, other.Size);
+            Assert.IsTrue(ValCheck.IsValidFor(other, context));
+            Assert.IsTrue(handle.AllocByteCount > 0ul);
+
+            List<IEnumerable<PublicKey>> keysData = new List<IEnumerable<PublicKey>>(keys.Data);
+            List<IEnumerable<PublicKey>> otherData = new List<IEnumerable<PublicKey>>(other.Data);
+
+            Assert.AreEqual(keysData.Count, otherData.Count);
+            for (int i = 0; i < keysData.Count; i++)
+            {
+                List<PublicKey> keysCiphers = new List<PublicKey>(keysData[i]);
+                List<PublicKey> otherCiphers = new List<PublicKey>(otherData[i]);
+
+                Assert.AreEqual(keysCiphers.Count, otherCiphers.Count);
+
+                for (int j = 0; j < keysCiphers.Count; j++)
+                {
+                    PublicKey keysCipher = keysCiphers[j];
+                    PublicKey otherCipher = otherCiphers[j];
+
+                    Assert.AreEqual(keysCipher.Data.Size, otherCipher.Data.Size);
+                    Assert.AreEqual(keysCipher.Data.PolyModulusDegree, otherCipher.Data.PolyModulusDegree);
+                    Assert.AreEqual(keysCipher.Data.CoeffModulusSize, otherCipher.Data.CoeffModulusSize);
+
+                    ulong coeffCount = keysCipher.Data.Size * keysCipher.Data.PolyModulusDegree * keysCipher.Data.CoeffModulusSize;
+                    for (ulong k = 0; k < coeffCount; k++)
+                    {
+                        Assert.AreEqual(keysCipher.Data[k], otherCipher.Data[k]);
+                    }
+                }
+            }
+        }
+
+        [TestMethod]
+        public void SeededKeyTest()
+        {
+            EncryptionParameters parms = new EncryptionParameters(SchemeType.BFV)
+            {
+                PolyModulusDegree = 128,
+                PlainModulus = new Modulus(1 << 6),
+                CoeffModulus = CoeffModulus.Create(128, new int[] { 40, 40, 40 })
+            };
+            SEALContext context = new SEALContext(parms,
+                expandModChain: false,
+                secLevel: SecLevelType.None);
+            KeyGenerator keygen = new KeyGenerator(context);
+
+            RelinKeys relinKeys = new RelinKeys();
+            using (MemoryStream stream = new MemoryStream())
+            {
+                keygen.RelinKeys().Save(stream);
+                stream.Seek(0, SeekOrigin.Begin);
+                relinKeys.Load(context, stream);
+            }
+
+            Encryptor encryptor = new Encryptor(context, keygen.PublicKey);
+            Decryptor decryptor = new Decryptor(context, keygen.SecretKey);
+            Evaluator evaluator = new Evaluator(context);
+
+            Ciphertext encrypted1 = new Ciphertext(context);
+            Ciphertext encrypted2 = new Ciphertext(context);
+            Plaintext plain1 = new Plaintext();
+            Plaintext plain2 = new Plaintext();
+
+            plain1.Set(0);
+            encryptor.Encrypt(plain1, encrypted1);
+            evaluator.SquareInplace(encrypted1);
+            evaluator.RelinearizeInplace(encrypted1, relinKeys);
+            decryptor.Decrypt(encrypted1, plain2);
+
+            Assert.AreEqual(1ul, plain2.CoeffCount);
+            Assert.AreEqual(0ul, plain2[0]);
+
+            plain1.Set("1x^10 + 2");
+            encryptor.Encrypt(plain1, encrypted1);
+            evaluator.SquareInplace(encrypted1);
+            evaluator.RelinearizeInplace(encrypted1, relinKeys);
+            evaluator.SquareInplace(encrypted1);
+            evaluator.Relinearize(encrypted1, relinKeys, encrypted2);
+            decryptor.Decrypt(encrypted2, plain2);
+
+            // {1x^40 + 8x^30 + 18x^20 + 20x^10 + 10}
+            Assert.AreEqual(41ul, plain2.CoeffCount);
+            Assert.AreEqual(16ul, plain2[0]);
+            Assert.AreEqual(32ul, plain2[10]);
+            Assert.AreEqual(24ul, plain2[20]);
+            Assert.AreEqual(8ul,  plain2[30]);
+            Assert.AreEqual(1ul,  plain2[40]);
+        }
+
+        [TestMethod]
+        public void GetKeyTest()
+        {
+            SEALContext context = GlobalContext.BFVContext;
+            KeyGenerator keygen = new KeyGenerator(context);
+            RelinKeys relinKeys = keygen.RelinKeysLocal();
+
+            Assert.IsTrue(relinKeys.HasKey(2));
+            Assert.IsFalse(relinKeys.HasKey(3));
+
+            Utilities.AssertThrows<ArgumentException>(() => relinKeys.Key(0));
+            Utilities.AssertThrows<ArgumentException>(() => relinKeys.Key(1));
+
+            List<PublicKey> key1 = new List<PublicKey>(relinKeys.Key(2));
+            Assert.AreEqual(4, key1.Count);
+            Assert.AreEqual(5ul, key1[0].Data.CoeffModulusSize);
+        }
+
+        [TestMethod]
+        public void ExceptionsTest()
+        {
+            RelinKeys keys = new RelinKeys();
+            SEALContext context = GlobalContext.BFVContext;
+
+            Utilities.AssertThrows<ArgumentNullException>(() => keys = new RelinKeys(null));
+            Utilities.AssertThrows<ArgumentNullException>(() => keys.Set(null));
+
+            Utilities.AssertThrows<ArgumentNullException>(() => ValCheck.IsValidFor(keys, null));
+
+            Utilities.AssertThrows<ArgumentNullException>(() => keys.Save(null));
+
+            Utilities.AssertThrows<ArgumentNullException>(() => keys.Load(context, null));
+            Utilities.AssertThrows<ArgumentNullException>(() => keys.Load(null, new MemoryStream()));
+            Utilities.AssertThrows<EndOfStreamException>(() => keys.Load(context, new MemoryStream()));
+            Utilities.AssertThrows<ArgumentNullException>(() => keys.UnsafeLoad(null, new MemoryStream()));
+            Utilities.AssertThrows<ArgumentNullException>(() => keys.UnsafeLoad(context, null));
+        }
+    }
+}

bigpiseal3.5.1/dotnet/tests/SEALContextTests.cs

+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT license.
+
+using Microsoft.Research.SEAL;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using System.Collections.Generic;
+
+namespace SEALNetTest
+{
+    [TestClass]
+    public class SEALContextTests
+    {
+        [TestMethod]
+        public void SEALContextCreateTest()
+        {
+            EncryptionParameters encParams1 = new EncryptionParameters(SchemeType.BFV);
+            EncryptionParameters encParams2 = new EncryptionParameters(SchemeType.CKKS);
+
+            SEALContext context1 = new SEALContext(encParams1);
+            SEALContext context2 = new SEALContext(encParams2);
+
+            Assert.IsNotNull(context1);
+            Assert.IsNotNull(context2);
+
+            Assert.IsFalse(context1.ParametersSet);
+            Assert.IsFalse(context2.ParametersSet);
+
+            Assert.AreNotSame(context1.FirstParmsId, context1.LastParmsId);
+            Assert.AreEqual(context1.FirstParmsId, context1.LastParmsId);
+
+            SEALContext.ContextData data1 = context2.FirstContextData;
+            SEALContext.ContextData data2 = context2.GetContextData(context2.FirstParmsId);
+
+            Assert.AreNotSame(data1, data2);
+            ulong[] totalCoeffMod1 = data1.TotalCoeffModulus;
+            ulong[] totalCoeffMod2 = data2.TotalCoeffModulus;
+
+            int bitCount1 = data1.TotalCoeffModulusBitCount;
+            int bitCount2 = data2.TotalCoeffModulusBitCount;
+
+            Assert.AreEqual(bitCount1, bitCount2);
+            Assert.AreEqual(totalCoeffMod1.Length, totalCoeffMod2.Length);
+
+            for (int i = 0; i < totalCoeffMod1.Length; i++)
+            {
+                Assert.AreEqual(totalCoeffMod1[i], totalCoeffMod2[i]);
+            }
+        }
+
+        [TestMethod]
+        public void SEALContextParamsTest()
+        {
+            EncryptionParameters parms = new EncryptionParameters(SchemeType.BFV)
+            {
+                PolyModulusDegree = 128,
+                PlainModulus = new Modulus(1 << 6),
+                CoeffModulus = CoeffModulus.Create(128, new int[] { 30, 30, 30 })
+            };
+            SEALContext context = new SEALContext(parms, expandModChain: true, secLevel: SecLevelType.None);
+
+            SEALContext.ContextData data = context.KeyContextData;
+            Assert.IsNotNull(data);
+
+            EncryptionParameters parms2 = data.Parms;
+            Assert.AreEqual(parms.PolyModulusDegree, parms2.PolyModulusDegree);
+
+            EncryptionParameterQualifiers qualifiers = data.Qualifiers;
+            Assert.IsNotNull(qualifiers);
+
+            Assert.IsTrue(qualifiers.ParametersSet);
+            Assert.IsFalse(qualifiers.UsingBatching);
+            Assert.IsTrue(qualifiers.UsingFastPlainLift);
+            Assert.IsTrue(qualifiers.UsingFFT);
+            Assert.IsTrue(qualifiers.UsingNTT);
+            Assert.AreEqual(SecLevelType.None, qualifiers.SecLevel);
+            Assert.IsFalse(qualifiers.UsingDescendingModulusChain);
+            Assert.IsTrue(context.UsingKeyswitching);
+
+            ulong[] cdpm = data.CoeffDivPlainModulus;
+            Assert.AreEqual(3, cdpm.Length);
+
+            Assert.AreEqual(32ul, data.PlainUpperHalfThreshold);
+
+            Assert.AreEqual(3, data.PlainUpperHalfIncrement.Length);
+            Assert.IsNull(data.UpperHalfThreshold);
+            Assert.IsNotNull(data.UpperHalfIncrement);
+            Assert.AreEqual(3, data.UpperHalfIncrement.Length);
+            Assert.AreEqual(2ul, data.ChainIndex);
+
+            Assert.IsNull(data.PrevContextData);
+            SEALContext.ContextData data2 = data.NextContextData;
+            Assert.IsNotNull(data2);
+            Assert.AreEqual(1ul, data2.ChainIndex);
+            Assert.AreEqual(2ul, data2.PrevContextData.ChainIndex);
+
+            SEALContext.ContextData data3 = data2.NextContextData;
+            Assert.IsNotNull(data3);
+            Assert.AreEqual(0ul, data3.ChainIndex);
+            Assert.AreEqual(1ul, data3.PrevContextData.ChainIndex);
+            Assert.IsNull(data3.NextContextData);
+
+            parms = new EncryptionParameters(SchemeType.BFV)
+            {
+                PolyModulusDegree = 127,
+                PlainModulus = new Modulus(1 << 6),
+                CoeffModulus = CoeffModulus.Create(128, new int[] { 30, 30, 30 })
+            };
+            context = new SEALContext(parms, expandModChain: true, secLevel: SecLevelType.None);
+            Assert.AreEqual(context.ParameterErrorName(), "invalid_poly_modulus_degree_non_power_of_two");
+            Assert.AreEqual(context.ParameterErrorMessage(), "poly_modulus_degree is not a power of two");
+        }
+
+        [TestMethod]
+        public void SEALContextCKKSParamsTest()
+        {
+            int slotSize = 4;
+            EncryptionParameters parms = new EncryptionParameters(SchemeType.CKKS)
+            {
+                PolyModulusDegree = 2 * (ulong)slotSize,
+                CoeffModulus = CoeffModulus.Create(2 * (ulong)slotSize, new int[] { 40, 40, 40, 40 })
+            };
+            SEALContext context = new SEALContext(parms,
+                expandModChain: true,
+                secLevel: SecLevelType.None);
+
+            SEALContext.ContextData data = context.KeyContextData;
+            Assert.IsNotNull(data);
+
+            // This should be available in CKKS
+            Assert.IsNotNull(data.UpperHalfThreshold);
+            Assert.AreEqual(4, data.UpperHalfThreshold.Length);
+            Assert.IsNull(data.UpperHalfIncrement);
+            Assert.AreEqual(3ul, data.ChainIndex);
+
+            Assert.IsNull(data.PrevContextData);
+            SEALContext.ContextData data2 = data.NextContextData;
+            Assert.IsNotNull(data2);
+            Assert.AreEqual(2ul, data2.ChainIndex);
+            Assert.AreEqual(3ul, data2.PrevContextData.ChainIndex);
+
+            SEALContext.ContextData data3 = data2.NextContextData;
+            Assert.IsNotNull(data3);
+            Assert.AreEqual(1ul, data3.ChainIndex);
+            Assert.AreEqual(2ul, data3.PrevContextData.ChainIndex);
+
+            SEALContext.ContextData data4 = data3.NextContextData;
+            Assert.IsNotNull(data4);
+            Assert.AreEqual(0ul, data4.ChainIndex);
+            Assert.AreEqual(1ul, data4.PrevContextData.ChainIndex);
+
+            Assert.IsNull(data4.NextContextData);
+        }
+
+        [TestMethod]
+        public void ExpandModChainTest()
+        {
+            EncryptionParameters parms = new EncryptionParameters(SchemeType.BFV)
+            {
+                PolyModulusDegree = 4096,
+                CoeffModulus = CoeffModulus.BFVDefault(polyModulusDegree: 4096),
+                PlainModulus = new Modulus(1 << 20)
+            };
+
+            SEALContext context1 = new SEALContext(parms,
+                expandModChain: true,
+                secLevel: SecLevelType.None);
+
+            // By default there is a chain
+            SEALContext.ContextData contextData = context1.KeyContextData;
+            Assert.IsNotNull(contextData);
+            Assert.IsNull(contextData.PrevContextData);
+            Assert.IsNotNull(contextData.NextContextData);
+            contextData = context1.FirstContextData;
+            Assert.IsNotNull(contextData);
+            Assert.IsNotNull(contextData.PrevContextData);
+            Assert.IsNotNull(contextData.NextContextData);
+
+            // This should not create a chain
+            SEALContext context2 = new SEALContext(parms, expandModChain: false);
+            contextData = context2.KeyContextData;
+            Assert.IsNotNull(contextData);
+            Assert.IsNull(contextData.PrevContextData);
+            Assert.IsNotNull(contextData.NextContextData);
+            contextData = context2.FirstContextData;
+            Assert.IsNotNull(contextData);
+            Assert.IsNotNull(contextData.PrevContextData);
+            Assert.IsNull(contextData.NextContextData);
+        }
+    }
+}

bigpiseal3.5.1/dotnet/tests/SEALNetTest.csproj

+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>netcoreapp3.1</TargetFramework>
+    <IsPackable>false</IsPackable>
+    <Authors>Microsoft Research</Authors>
+    <Company>Microsoft Corporation</Company>
+    <Description>.NET wrapper unit tests for Microsoft SEAL</Description>
+    <Copyright>Microsoft Corporation 2020</Copyright>
+  </PropertyGroup>
+
+  <PropertyGroup Condition="'$(Platform)'=='AnyCPU'">
+    <PlatformTarget>x64</PlatformTarget>
+    <OutputPath>$(ProjectDir)../../bin/dotnet/$(Configuration)</OutputPath>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.4.0" />
+    <PackageReference Include="MSTest.TestAdapter" Version="2.0.0" />
+    <PackageReference Include="MSTest.TestFramework" Version="2.0.0" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="$(ProjectDir)../src/SEALNet.csproj" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <SEALCBinaryFiles Condition="$([MSBuild]::IsOsPlatform(Windows))" Include="$(ProjectDir)..\..\lib\x64\$(Configuration)\sealc.dll" />
+    <SEALCBinaryFiles Condition="$([MSBuild]::IsOsPlatform(Linux))" Include="$(ProjectDir)../../lib/libsealc.so.*" />
+    <SEALCBinaryFiles Condition="$([MSBuild]::IsOsPlatform(OSX))" Include="$(ProjectDir)../../lib/libsealc*.dylib" />
+  </ItemGroup>
+
+  <Target Name="PostBuild" AfterTargets="PostBuildEvent">
+    <Copy SourceFiles="@(SEALCBinaryFiles)" DestinationFolder="$(TargetDir)" />
+  </Target>
+
+</Project>