示例#1
0
        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);
        }
示例#2
0
        public void PlaintextBasicsNET()
        {
            var plain = new Plaintext(2);

            Assert.AreEqual(2, plain.Capacity);
            Assert.AreEqual(2, plain.CoeffCount);
            Assert.AreEqual(0, plain.SignificantCoeffCount());
            plain[0] = 1;
            plain[1] = 2;

            plain.Reserve(10);
            Assert.AreEqual(10, plain.Capacity);
            Assert.AreEqual(2, plain.CoeffCount);
            Assert.AreEqual(2, plain.SignificantCoeffCount());
            Assert.AreEqual(1UL, plain[0]);
            Assert.AreEqual(2UL, plain[1]);

            plain.Resize(5);
            Assert.AreEqual(10, plain.Capacity);
            Assert.AreEqual(5, plain.CoeffCount);
            Assert.AreEqual(2, plain.SignificantCoeffCount());
            Assert.AreEqual(1UL, plain[0]);
            Assert.AreEqual(2UL, plain[1]);
            Assert.AreEqual(0UL, plain[2]);
            Assert.AreEqual(0UL, plain[3]);
            Assert.AreEqual(0UL, plain[4]);
        }
示例#3
0
        public void SaveLoadPlaintextNET()
        {
            var stream = new MemoryStream();

            var plain  = new Plaintext();
            var plain2 = new Plaintext();

            plain.Save(stream);
            stream.Seek(0, SeekOrigin.Begin);
            plain2.Load(stream);
            Assert.AreEqual(0, plain2.Capacity);
            Assert.AreEqual(0, plain2.CoeffCount);

            plain.Reserve(20);
            plain.Resize(5);
            plain[0] = 1;
            plain[1] = 2;
            plain[2] = 3;
            stream.Seek(0, SeekOrigin.Begin);
            plain.Save(stream);
            stream.Seek(0, SeekOrigin.Begin);
            plain2.Load(stream);
            Assert.AreEqual(5, plain2.Capacity);
            Assert.AreEqual(5, plain2.CoeffCount);
            Assert.AreEqual(1UL, plain2[0]);
            Assert.AreEqual(2UL, plain2[1]);
            Assert.AreEqual(3UL, plain2[2]);
            Assert.AreEqual(0UL, plain2[3]);
            Assert.AreEqual(0UL, plain2[4]);
        }
示例#4
0
        public void ReleaseTest()
        {
            Plaintext plain = new Plaintext();

            plain.Reserve(10000);

            plain.Set("3x^2 + 4x^1 + 5");

            Assert.AreEqual(10000ul, plain.Capacity);
            Assert.AreEqual(3ul, plain.CoeffCount);

            plain.Release();

            Assert.AreEqual(0ul, plain.Capacity);
            Assert.AreEqual(0ul, plain.CoeffCount);
        }
示例#5
0
        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));
        }
示例#6
0
        public void ShrinkToFitTest()
        {
            Plaintext plain = new Plaintext();

            plain.Reserve(10000);

            Assert.AreEqual(10000ul, plain.Capacity);
            Assert.AreEqual(0ul, plain.CoeffCount);

            plain.Set("1");

            Assert.AreEqual(10000ul, plain.Capacity);
            Assert.AreEqual(1ul, plain.CoeffCount);
            Assert.AreEqual(1ul, plain.SignificantCoeffCount);

            plain.ShrinkToFit();

            Assert.AreEqual(1ul, plain.Capacity);
            Assert.AreEqual(1ul, plain.CoeffCount);
            Assert.AreEqual(1ul, plain[0]);
        }