11419862193

Committed 19 Oct 2024 06:35PM UTC coverage: 43.483%. First build

Build # 11419862193

Build Type

Pull #5

github

Committed by

web-flow

Commit Message

Merge f98209122 into 8e1b35867

Pull Request Pull Request #5: GitHub actions

Run Details

310 of 362 branches covered (85.64%)

Branch coverage included in aggregate %.

30 of 111 new or added lines in 18 files covered. (27.03%)

1895 of 4709 relevant lines covered (40.24%)

5887.58 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/CompactCryptoGroupAlgebra.Tests/RandomNumberGeneratorExtensionsTests.cs

﻿// CompactCryptoGroupAlgebra - C# implementation of abelian group algebra for experimental cryptography

// SPDX-FileCopyrightText: 2022 Lukas Prediger <lumip@lumip.de>
// SPDX-License-Identifier: GPL-3.0-or-later
// SPDX-FileType: SOURCE

// CompactCryptoGroupAlgebra is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// CompactCryptoGroupAlgebra is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <https://www.gnu.org/licenses/>.

using System;
using System.Numerics;
using System.Security.Cryptography;

using Moq;
using NUnit.Framework;

namespace CompactCryptoGroupAlgebra
{
    [TestFixture]
    public class RandomNumberGeneratorExtensionsTests
    {
        [Test]
        public void TestRandomBetween()
        {
            var lowerBound = new BigInteger(-10);
            var upperBound = new BigInteger(10);

            var expected = new BigInteger(-7);
            var rngDeltaBuffer = (expected - lowerBound).ToByteArray();

            var rngMock = new Mock<RandomNumberGenerator>(MockBehavior.Strict);
            rngMock.Setup(rng => rng.GetBytes(It.IsAny<byte[]>()))
                   .Callback<byte[]>(buffer =>
                        {
                            Buffer.BlockCopy(rngDeltaBuffer, 0, buffer, 0, rngDeltaBuffer.Length);
                        }
                    );

            var result = rngMock.Object.GetBigIntegerBetween(lowerBound, upperBound);
            Assert.AreEqual(expected, result);
            rngMock.Verify(rng => rng.GetBytes(It.IsAny<byte[]>()), Times.Once);
        }

        [Test]
        public void TestRandomBetweenDoesNotExceedUpperBound()
        {
            var lowerBound = new BigInteger(-10);
            var upperBound = new BigInteger(10);

            var expected = new BigInteger(-7);
            var invalidRngDeltaBuffer = (upperBound - lowerBound + 1).ToByteArray();
            var validRngDeltaBuffer = (expected - lowerBound).ToByteArray();

            bool firstCall = true;
            var rngMock = new Mock<RandomNumberGenerator>(MockBehavior.Strict);
            rngMock.Setup(rng => rng.GetBytes(It.IsAny<byte[]>()))
                   .Callback<byte[]>(buffer =>
                        {
                            if (firstCall)
                                Buffer.BlockCopy(invalidRngDeltaBuffer, 0, buffer, 0, invalidRngDeltaBuffer.Length);
                            else
                                Buffer.BlockCopy(validRngDeltaBuffer, 0, buffer, 0, validRngDeltaBuffer.Length);
                            firstCall = false;
                        }
                   );

            var result = rngMock.Object.GetBigIntegerBetween(lowerBound, upperBound);
            Assert.AreEqual(expected, result);
            rngMock.Verify(rng => rng.GetBytes(It.IsAny<byte[]>()), Times.Exactly(2));
        }

        [Test]
        public void TestRandomWithLengthNonByteBoundary()
        {
            var length = NumberLength.FromBitLength(17);

            var leadingOneRngBuffer = ((BigInteger.One << (3 * 8)) - 1).ToByteArray(); // 3 bytes of ones
            var leadingZeroRngBuffer = ((BigInteger.One << (length.InBits - 2))).ToByteArray(); // only bit 16 set
            var expectedFirst = (BigInteger.One << length.InBits) - 1;
            var expectedSecond = ((BigInteger.One << (length.InBits - 2)) ^ (BigInteger.One << (length.InBits - 1)));

            bool firstCall = true;
            var rngMock = new Mock<RandomNumberGenerator>(MockBehavior.Strict);
            rngMock.Setup(rng => rng.GetBytes(It.IsAny<byte[]>()))
                   .Callback<byte[]>(buffer =>
                        {
                            if (firstCall)
                                Buffer.BlockCopy(leadingOneRngBuffer, 0, buffer, 0, Math.Min(leadingOneRngBuffer.Length, buffer.Length));
                            else
                                Buffer.BlockCopy(leadingZeroRngBuffer, 0, buffer, 0, Math.Min(leadingZeroRngBuffer.Length, buffer.Length));
                            firstCall = false;
                        }
                    );

            var firstResult = rngMock.Object.GetBigIntegerWithLength(length);
            Assert.AreEqual(1, firstResult.Sign, "GetBigIntegerWithLength returned negative number");
            Assert.AreEqual(length, NumberLength.GetLength(firstResult));
            Assert.AreEqual(expectedFirst, firstResult);

            var secondResult = rngMock.Object.GetBigIntegerWithLength(length); ;
            Assert.AreEqual(1, secondResult.Sign, "GetBigIntegerWithLength returned negative number");
            Assert.AreEqual(length, NumberLength.GetLength(secondResult));
            Assert.AreEqual(expectedSecond, secondResult);

            rngMock.Verify(rng => rng.GetBytes(It.IsAny<byte[]>()), Times.Exactly(2));
        }


        [Test]
        public void TestRandomWithLengthByteBoundary()
        {
            var length = NumberLength.FromBitLength(16);

            var leadingOneRngBuffer = ((BigInteger.One << (3 * 8)) - 1).ToByteArray(); // 3 bytes of ones
            var leadingZeroRngBuffer = ((BigInteger.One << (length.InBits - 2))).ToByteArray(); // only bit 15 set
            var expectedFirst = (BigInteger.One << length.InBits) - 1;
            var expectedSecond = ((BigInteger.One << (length.InBits - 2)) ^ (BigInteger.One << (length.InBits - 1)));

            bool firstCall = true;
            var rngMock = new Mock<RandomNumberGenerator>(MockBehavior.Strict);
            rngMock.Setup(rng => rng.GetBytes(It.IsAny<byte[]>()))
                   .Callback<byte[]>(buffer =>
                        {
                            if (firstCall)
                                Buffer.BlockCopy(leadingOneRngBuffer, 0, buffer, 0, Math.Min(leadingOneRngBuffer.Length, buffer.Length));
                            else
                                Buffer.BlockCopy(leadingZeroRngBuffer, 0, buffer, 0, Math.Min(leadingZeroRngBuffer.Length, buffer.Length));
                            firstCall = false;
                        }
                   );

            var firstResult = rngMock.Object.GetBigIntegerWithLength(length);
            Assert.AreEqual(1, firstResult.Sign, "GetBigIntegerWithLength returned negative number");
            Assert.AreEqual(length, NumberLength.GetLength(firstResult));
            Assert.AreEqual(expectedFirst, firstResult);

            var secondResult = rngMock.Object.GetBigIntegerWithLength(length); ;
            Assert.AreEqual(1, secondResult.Sign, "GetBigIntegerWithLength returned negative number");
            Assert.AreEqual(length, NumberLength.GetLength(secondResult));
            Assert.AreEqual(expectedSecond, secondResult);

            rngMock.Verify(rng => rng.GetBytes(It.IsAny<byte[]>()), Times.Exactly(2));
        }
    }
}

1	// CompactCryptoGroupAlgebra - C# implementation of abelian group algebra for experimental cryptography
2
3	// SPDX-FileCopyrightText: 2022 Lukas Prediger <lumip@lumip.de>
4	// SPDX-License-Identifier: GPL-3.0-or-later
5	// SPDX-FileType: SOURCE
6
7	// CompactCryptoGroupAlgebra is free software: you can redistribute it and/or modify
8	// it under the terms of the GNU General Public License as published by
9	// the Free Software Foundation, either version 3 of the License, or
10	// (at your option) any later version.
11	//
12	// CompactCryptoGroupAlgebra is distributed in the hope that it will be useful,
13	// but WITHOUT ANY WARRANTY; without even the implied warranty of
14	// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15	// GNU General Public License for more details.
16	//
17	// You should have received a copy of the GNU General Public License
18	// along with this program. If not, see <https://www.gnu.org/licenses/>.
19
20	using System;
21	using System.Numerics;
22	using System.Security.Cryptography;
23
24	using Moq;
25	using NUnit.Framework;
26
27	namespace CompactCryptoGroupAlgebra
28	{
29	[TestFixture]
30	public class RandomNumberGeneratorExtensionsTests
31	{
32	[Test]
33	public void TestRandomBetween()
34	{	×
35	var lowerBound = new BigInteger(-10);	×
36	var upperBound = new BigInteger(10);	×
37
38	var expected = new BigInteger(-7);	×
39	var rngDeltaBuffer = (expected - lowerBound).ToByteArray();	×
40
41	var rngMock = new Mock<RandomNumberGenerator>(MockBehavior.Strict);	×
42	rngMock.Setup(rng => rng.GetBytes(It.IsAny<byte[]>()))	×
NEW 43	.Callback<byte[]>(buffer =>	×
NEW 44	{	×
NEW 45	Buffer.BlockCopy(rngDeltaBuffer, 0, buffer, 0, rngDeltaBuffer.Length);	×
NEW 46	}	×
NEW 47	);	×
48
49	var result = rngMock.Object.GetBigIntegerBetween(lowerBound, upperBound);	×
50	Assert.AreEqual(expected, result);	×
51	rngMock.Verify(rng => rng.GetBytes(It.IsAny<byte[]>()), Times.Once);	×
52	}	×
53
54	[Test]
55	public void TestRandomBetweenDoesNotExceedUpperBound()
56	{	×
57	var lowerBound = new BigInteger(-10);	×
58	var upperBound = new BigInteger(10);	×
59
60	var expected = new BigInteger(-7);	×
61	var invalidRngDeltaBuffer = (upperBound - lowerBound + 1).ToByteArray();	×
62	var validRngDeltaBuffer = (expected - lowerBound).ToByteArray();	×
63
64	bool firstCall = true;	×
65	var rngMock = new Mock<RandomNumberGenerator>(MockBehavior.Strict);	×
66	rngMock.Setup(rng => rng.GetBytes(It.IsAny<byte[]>()))	×
NEW 67	.Callback<byte[]>(buffer =>	×
NEW 68	{	×
NEW 69	if (firstCall)	×
NEW 70	Buffer.BlockCopy(invalidRngDeltaBuffer, 0, buffer, 0, invalidRngDeltaBuffer.Length);	×
NEW 71	else	×
NEW 72	Buffer.BlockCopy(validRngDeltaBuffer, 0, buffer, 0, validRngDeltaBuffer.Length);	×
NEW 73	firstCall = false;	×
NEW 74	}	×
NEW 75	);	×
76
77	var result = rngMock.Object.GetBigIntegerBetween(lowerBound, upperBound);	×
78	Assert.AreEqual(expected, result);	×
79	rngMock.Verify(rng => rng.GetBytes(It.IsAny<byte[]>()), Times.Exactly(2));	×
80	}	×
81
82	[Test]
83	public void TestRandomWithLengthNonByteBoundary()
84	{	×
85	var length = NumberLength.FromBitLength(17);	×
86
87	var leadingOneRngBuffer = ((BigInteger.One << (3 * 8)) - 1).ToByteArray(); // 3 bytes of ones	×
88	var leadingZeroRngBuffer = ((BigInteger.One << (length.InBits - 2))).ToByteArray(); // only bit 16 set	×
89	var expectedFirst = (BigInteger.One << length.InBits) - 1;	×
90	var expectedSecond = ((BigInteger.One << (length.InBits - 2)) ^ (BigInteger.One << (length.InBits - 1)));	×
91
92	bool firstCall = true;	×
93	var rngMock = new Mock<RandomNumberGenerator>(MockBehavior.Strict);	×
94	rngMock.Setup(rng => rng.GetBytes(It.IsAny<byte[]>()))	×
NEW 95	.Callback<byte[]>(buffer =>	×
NEW 96	{	×
NEW 97	if (firstCall)	×
NEW 98	Buffer.BlockCopy(leadingOneRngBuffer, 0, buffer, 0, Math.Min(leadingOneRngBuffer.Length, buffer.Length));	×
NEW 99	else	×
NEW 100	Buffer.BlockCopy(leadingZeroRngBuffer, 0, buffer, 0, Math.Min(leadingZeroRngBuffer.Length, buffer.Length));	×
NEW 101	firstCall = false;	×
NEW 102	}	×
NEW 103	);	×
104
105	var firstResult = rngMock.Object.GetBigIntegerWithLength(length);	×
106	Assert.AreEqual(1, firstResult.Sign, "GetBigIntegerWithLength returned negative number");	×
107	Assert.AreEqual(length, NumberLength.GetLength(firstResult));	×
108	Assert.AreEqual(expectedFirst, firstResult);	×
109
NEW 110	var secondResult = rngMock.Object.GetBigIntegerWithLength(length); ;	×
111	Assert.AreEqual(1, secondResult.Sign, "GetBigIntegerWithLength returned negative number");	×
112	Assert.AreEqual(length, NumberLength.GetLength(secondResult));	×
113	Assert.AreEqual(expectedSecond, secondResult);	×
114
115	rngMock.Verify(rng => rng.GetBytes(It.IsAny<byte[]>()), Times.Exactly(2));	×
116	}	×
117
118
119	[Test]
120	public void TestRandomWithLengthByteBoundary()
121	{	×
122	var length = NumberLength.FromBitLength(16);	×
123
124	var leadingOneRngBuffer = ((BigInteger.One << (3 * 8)) - 1).ToByteArray(); // 3 bytes of ones	×
125	var leadingZeroRngBuffer = ((BigInteger.One << (length.InBits - 2))).ToByteArray(); // only bit 15 set	×
126	var expectedFirst = (BigInteger.One << length.InBits) - 1;	×
127	var expectedSecond = ((BigInteger.One << (length.InBits - 2)) ^ (BigInteger.One << (length.InBits - 1)));	×
128
129	bool firstCall = true;	×
130	var rngMock = new Mock<RandomNumberGenerator>(MockBehavior.Strict);	×
131	rngMock.Setup(rng => rng.GetBytes(It.IsAny<byte[]>()))	×
NEW 132	.Callback<byte[]>(buffer =>	×
NEW 133	{	×
NEW 134	if (firstCall)	×
NEW 135	Buffer.BlockCopy(leadingOneRngBuffer, 0, buffer, 0, Math.Min(leadingOneRngBuffer.Length, buffer.Length));	×
NEW 136	else	×
NEW 137	Buffer.BlockCopy(leadingZeroRngBuffer, 0, buffer, 0, Math.Min(leadingZeroRngBuffer.Length, buffer.Length));	×
NEW 138	firstCall = false;	×
NEW 139	}	×
NEW 140	);	×
141
142	var firstResult = rngMock.Object.GetBigIntegerWithLength(length);	×
143	Assert.AreEqual(1, firstResult.Sign, "GetBigIntegerWithLength returned negative number");	×
144	Assert.AreEqual(length, NumberLength.GetLength(firstResult));	×
145	Assert.AreEqual(expectedFirst, firstResult);	×
146
NEW 147	var secondResult = rngMock.Object.GetBigIntegerWithLength(length); ;	×
148	Assert.AreEqual(1, secondResult.Sign, "GetBigIntegerWithLength returned negative number");	×
149	Assert.AreEqual(length, NumberLength.GetLength(secondResult));	×
150	Assert.AreEqual(expectedSecond, secondResult);	×
151
152	rngMock.Verify(rng => rng.GetBytes(It.IsAny<byte[]>()), Times.Exactly(2));	×
153	}	×
154	}
155	}

lumip / CompactCryptoGroupAlgebra / 11419862193

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous