integer-arithmetic_rsa-encryption/BigInt_Tests.cs at master · AdIVIuH/integer-arithmetic_rsa-encryption · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
using NUnit.Framework;
using System;

namespace IntegerArithmeticRsaEncryption {
	internal class BigIntTests {
		[TestCase("256", "256", true, TestName = "WhenSamePositiveNumbersEquals")]
		[TestCase("256", "26", false, TestName = "WhenPositiveNumbersEquals")]
		[TestCase("-256", "-256", true, TestName = "WhenSameNegativeNumbersEquals")]
		[TestCase("-256", "-26", false, TestName = "WhenNegativeNumbersEquals")]
		[TestCase("256", "-26", false, TestName = "WhenPositiveAndNegativeNumbersEquals")]
		public void CorrectEqual(string value1, string value2, bool isEqual) {
			Assert.AreEqual(isEqual, new BigInt(value1) == new BigInt(value2));
		}

		[TestCase("256", "256", false, TestName = "WhenSamePositiveNumbersMore")]
		[TestCase("256", "26", true, TestName = "WhenPositiveNumbersMore")]
		[TestCase("-256", "-256", false, TestName = "WhenSameNegativeNumbersMore")]
		[TestCase("-26", "-256", true, TestName = "WhenNegativeNumbersMore")]
		[TestCase("26", "-256", true, TestName = "WhenPositiveAndNegativeNumbersMore")]
		public void CorrectCompare_GreaterThan(string value1, string value2, bool isEqual) {
			Assert.AreEqual(isEqual, new BigInt(value1) > new BigInt(value2));
		}

		[TestCase("264", "264", false, TestName = "WhenSamePositiveNumbersLess")]
		[TestCase("25", "26", true, TestName = "WhenPositiveNumbersLess")]
		[TestCase("-256", "-256", false, TestName = "WhenSameNegativeNumbersLess")]
		[TestCase("-257", "-256", true, TestName = "WhenNegativeNumbersLess")]
		[TestCase("-26", "26", true, TestName = "WhenPositiveAndNegativeNumbersLess")]
		public void CorrectCompare_LessThan(string value1, string value2, bool isEqual) {
			var first = new BigInt(value1);
			Assert.AreEqual(isEqual, first < new BigInt(value2));
		}

		[TestCase("847", "178", "1025", TestName = "WhenNumbersHaveSameLengthPositiveAddition")]
		[TestCase("95841", "177478", "273319", TestName = "WhenLeftNumberIsShorterPositiveAddition")]
		[TestCase("177478", "95841", "273319", TestName = "WhenRightNumberIsShorterPositiveAddition")]
		[TestCase("17747984891984498489498489", "494981874984984894984984", "18242966766969483384483473",
			TestName = "WhenBigNumbersPositiveAddition")]
		public void CorrectAddition_WhenBothNumberArePositive(string value1, string value2, string expectedValue) {
			var number1 = new BigInt(value1);
			var number2 = new BigInt(value2);

			var actual = number1 + number2;

			Assert.AreEqual(new BigInt(expectedValue).Value, actual.Value);
		}

		[TestCase("-847", "-178", "-1025", TestName = "WhenNumbersHaveSameLengthNegativeAddition")]
		[TestCase("-95841", "-177478", "-273319", TestName = "WhenLeftNumberIsShorterNegativeAddition")]
		[TestCase("-177478", "-95841", "-273319", TestName = "WhenRightNumberIsShorterNegativeAddition")]
		[TestCase("-17747984891984498489498489", "-494981874984984894984984", "-18242966766969483384483473",
			TestName = "WhenBigNumbersNegativeAddition")]
		public void CorrectAddition_WhenBothNumberAreNegative(string value1, string value2, string expectedValue) {
			var number1 = new BigInt(value1);
			var number2 = new BigInt(value2);

			var actual = number1 + number2;

			Assert.AreEqual(new BigInt(expectedValue).Value, actual.Value);
		}

		[TestCase("-847", "178", "-669", TestName = "WhenNumbersHaveSameLengthPositiveAndNegativeAddition")]
		[TestCase("-95841", "177478", "81637", TestName = "WhenLeftNumberIsNegativeAddition")]
		[TestCase("177478", "-95841", "81637", TestName = "WhenRightNumberIsNegativeAddition")]
		[TestCase("17747984891984498489498489", "-41949818749849848949840984", "-24201833857865350460342495",
			TestName = "WhenBigNumbersRightNumberIsNegativeAddition")]
		public void CorrectAddition_WhenPositiveAndNegativeNumbers(string value1, string value2, string expectedValue) {
			var number1 = new BigInt(value1);
			var number2 = new BigInt(value2);

			var actual = number1 + number2;

			Assert.AreEqual(new BigInt(expectedValue).Value, actual.Value);
		}

		[TestCase("847", "178", "669", TestName = "WhenNumbersHaveSameLengthPositiveSubtraction")]
		[TestCase("95841", "177478", "-81637", TestName = "WhenLeftNumberIsShorterPositiveSubtraction")]
		[TestCase("177478", "95841", "81637", TestName = "WhenRightNumberIsShorterPositiveSubtraction")]
		[TestCase("17747984891984498489498489", "41949818749849848949840984", "-24201833857865350460342495",
			TestName = "WhenBigNumbersPositiveSubtraction")]
		public void CorrectSubtraction_WhenBothNumberArePositive(string value1, string value2, string expectedValue) {
			var number1 = new BigInt(value1);
			var number2 = new BigInt(value2);

			var actual = number1 - number2;

			Assert.AreEqual(new BigInt(expectedValue).Value, actual.Value);
		}

		[TestCase("-847", "-178", "-669", TestName = "WhenNumbersHaveSameLengthNegativeSubtraction")]
		[TestCase("-95841", "-177478", "81637", TestName = "WhenLeftNumberIsShorterNegativeSubtraction")]
		[TestCase("-177478", "-95841", "-81637", TestName = "WhenRightNumberIsShorterNegativeSubtraction")]
		[TestCase("-17747984891984498489498489", "-41949818749849848949840984", "24201833857865350460342495",
			TestName = "WhenBigNumbersNegativeSubtraction")]
		public void CorrectSubtraction_WhenBothNumberAreNegative(string value1, string value2, string expectedValue) {
			var number1 = new BigInt(value1);
			var number2 = new BigInt(value2);

			var actual = number1 - number2;

			Assert.AreEqual(new BigInt(expectedValue).Value, actual.Value);
		}

		[TestCase("95841", "-177478", "273319", TestName = "WhenNumbersHaveSameLengthNegativeAndPositiveSubtraction")]
		[TestCase("-847", "178", "-1025", TestName = "WhenLeftNumberIsShorterNegativeAndPositiveSubtraction")]
		[TestCase("-177478", "95841", "-273319", TestName = "WhenRightNumberIsShorterNegativeAndPositiveSubtraction")]
		[TestCase("17747984891984498489498489", "-41949818749849848949840984", "59697803641834347439339473",
			TestName = "WhenBigNumbersNegativeAndPositiveSubtraction")]
		public void CorrectSubtraction_WhenPositiveAndNegativeNumbers(string value1, string value2, string expectedValue) {
			var number1 = new BigInt(value1);
			var number2 = new BigInt(value2);

			var actual = number1 - number2;

			Assert.AreEqual(new BigInt(expectedValue).Value, actual.Value);
		}

		[TestCase("847", "178", "150766", TestName = "WhenBothNumbersArePositive")]
		[TestCase("-1478", "-95841", "141652998", TestName = "WhenBothNumbersAreNegative")]
		[TestCase("-177478", "15841", "-2811428998", TestName = "WhenPositiveAndNegativeNumbers")]
		[TestCase("17747984891984498489498489", "-41949818749849848949840984",
			"-744524749393823160874372569351363330891430458273176",
			TestName = "WhenBigNumbersNegativeSubtraction")]
		public void CorrectMultiplication(string value1, string value2, string expectedValue) {
			var number1 = new BigInt(value1);
			var number2 = new BigInt(value2);

			var actual = number1 * number2;

			Assert.AreEqual(new BigInt(expectedValue).Value, actual.Value);
		}

		[TestCase("847", "178", "4", TestName = "WhenBothNumbersArePositive")]
		[TestCase("-1478", "-95841", "0", TestName = "WhenBothNumbersAreNegative")]
		[TestCase("177478", "-15841", "-11", TestName = "WhenPositiveAndNegativeNumbers")]
		[TestCase("17747984891984498489498489", "188840984", "93983755623644168",
			TestName = "WhenBigNumbers")]
		public void CorrectDivision(string value1, string value2, string expectedValue) {
			var number1 = new BigInt(value1);
			var number2 = new BigInt(value2);

			var actual = number1 / number2;

			Assert.AreEqual(new BigInt(expectedValue).Value, actual.Value);
		}

		[TestCase("847", "178", "135", TestName = "WhenBothNumbersArePositive")]
		[TestCase("-1478", "-95841", "-1478", TestName = "WhenBothNumbersAreNegative")]
		[TestCase("177478", "-15841", "3227", TestName = "WhenPositiveAndNegativeNumbers")]
		[TestCase("17747984891984498489498489", "188840984", "138517177",
			TestName = "WhenBigNumbers")]
		public void CorrectModulo(string value1, string value2, string expectedValue) {
			var number1 = new BigInt(value1);
			var number2 = new BigInt(value2);

			var actual = number1 % number2;

			Assert.AreEqual(new BigInt(expectedValue).Value, actual.Value);
		}

		[TestCase("7", "13", "2", TestName = "WhenUsualNumbers")]
		[TestCase("8948456163", "8942", "1605", TestName = "WhenBigNumbers")]
		public void CorrectInverseElementInModulo(string value, string modulo, string expectedValue) {
			var number1 = new BigInt(value);
			var number2 = new BigInt(modulo);

			var actual = BigInt.InverseElementOnModulo(number1, number2);

			Assert.AreEqual(new BigInt(expectedValue).Value, actual.Value);
		}

		[TestCase("4", "26", TestName = "WhenInverseElementDoesNotExist")]
		public void InverseElementInModulo_ThrowException(string value, string modulo) {
			var number1 = new BigInt(value);
			var number2 = new BigInt(modulo);

			Assert.Throws<InvalidOperationException>(() => BigInt.InverseElementOnModulo(number1, number2));
		}
	}
}