public void FillData_Test()
{
// Arrange
var returnValue1 = new LargeInteger(7);
var returnValue2 = new LargeInteger(14);
PropertyInfo propertyInfo1 = typeof(ClassWithStringAutoPrimaryKey).GetProperty("Key");
PropertyInfo propertyInfo2 = typeof(ClassWithIntAutoPrimaryKey).GetProperty("Key");
var data1 = new Data<LargeInteger>(null);
var data2 = new Data<LargeInteger>(null);
var dictionary = new Dictionary<PropertyInfo, Data<LargeInteger>>
{
{propertyInfo1, data1},
{propertyInfo2, data2},
};
WriterDelegate writer1 = writerPi => (decoderPi, input) => returnValue1;
WriterDelegate writer2 = writerPi => (decoderPi, input) => returnValue2;
this.writersMock.Setup(m => m[typeof(string)]).Returns(writer1);
this.writersMock.Setup(m => m[typeof(int)]).Returns(writer2);
this.writersMock.Setup(m => m.Execute()).Returns(new object[2]);
// Act
this.generator.FillData(dictionary);
// Assert
Assert.AreEqual(returnValue1 + 1, data1.Item);
Assert.AreEqual(returnValue2 + 1, data2.Item);
}
public void Cast_ToULong_Test()
{
var largeInteger = new LargeInteger(LargeIntegerTests.MaxValue);
var result = (ulong)largeInteger;
Assert.AreEqual(LargeIntegerTests.MaxValue, result);
}
public void Addition_Test()
{
var left = new LargeInteger(LargeIntegerTests.MaxValue);
var right = new LargeInteger(257);
LargeInteger result = left + right;
Assert.AreEqual(LargeIntegerTests.MaxValue + 257, (ulong)result);
}
public void Decrement_Test()
{
var largeInteger = new LargeInteger(LargeIntegerTests.MaxValue);
for (int i = (int)LargeIntegerTests.MaxValue - 1; i >= 0; i--)
{
largeInteger--;
Assert.AreEqual((ulong)i, (ulong)largeInteger);
}
}
public void Decode_Test()
{
var expected = new LargeInteger(5204);
var generator = new LetterEncoder();
LargeInteger result = generator.Decode("HSE");
Assert.AreEqual(expected, result);
}
public object GetValue(PropertyInfo propertyInfo, LargeInteger initialCount)
{
StandardPropertyValueAccumulator.Logger.Debug(
$"Entering GetValue. propertyInfo: {propertyInfo}, initialCount: {initialCount}");
this.countDictionary.AddOrUpdate(propertyInfo, pi => initialCount, (pi, value) => ++value);
object result = this.PrivateGetValue(propertyInfo);
StandardPropertyValueAccumulator.Logger.Debug("Exiting GetValue");
return result;
}
private static LargeInteger Ensure(ref LargeInteger largeInteger, object o)
{
if (largeInteger.data == null)
{
largeInteger.data = LargeInteger.GetInitialData();
}
else if (!largeInteger.data.Any())
{
largeInteger.data.Add(0);
}
return largeInteger;
}
public virtual LargeInteger Decode(string value)
{
LetterEncoder.Logger.Debug($"Entering Encode. value: {value}");
LargeInteger result = 0;
for (int i = 0; i < value.Length; i++)
{
var ascii = (ulong)value[value.Length - 1 - i];
result += new LargeInteger(26).Pow((ulong)i) * (ascii - 65);
}
LetterEncoder.Logger.Debug($"Exiting Encode. result: {result}");
return result;
}
public virtual string Encode(LargeInteger number, int maxStringLength)
{
LetterEncoder.Logger.Debug($"Entering Encode. number: {number}, maxStringLength: {maxStringLength}");
var sb = new StringBuilder();
int digitCount = 0;
LargeInteger whole = number;
while (digitCount++ < maxStringLength)
{
LargeInteger remainder = whole%26;
whole /= 26;
if (remainder == 0 && whole == 0)
{
if (digitCount == 1)
{
sb.Insert(0, "A");
}
break;
}
var ascii = (char)(remainder + 65);
sb.Insert(0, ascii);
}
if (digitCount > maxStringLength)
{
throw new OverflowException(string.Format(Messages.StringGeneratorOverflow, number, maxStringLength));
}
string result = sb.ToString();
LetterEncoder.Logger.Debug($"Exiting Encode. result : {result}");
return result;
}
public void Initializer_Test()
{
ulong value = LargeIntegerTests.MaxValue;
var result = new LargeInteger(value);
result--;
Assert.AreEqual(value - 1, (ulong)result);
}
public void Increment_Test()
{
var largeInteger = new LargeInteger();
for (ulong i = 1; i <= LargeIntegerTests.MaxValue; i++)
{
largeInteger++;
Assert.AreEqual(i, (ulong)largeInteger);
}
}
public void Exponent_Test()
{
LargeInteger exponent = new LargeInteger(ulong.MaxValue).Pow(3);
LargeInteger actual = exponent / new LargeInteger(ulong.MaxValue);
LargeInteger a = new LargeInteger(ulong.MaxValue)*new LargeInteger(ulong.MaxValue);
actual /= new LargeInteger(ulong.MaxValue);
LargeInteger expected = new LargeInteger(ulong.MaxValue);
Assert.AreEqual(expected, actual);
}
public void Division_Test2()
{
LargeInteger a = new LargeInteger(ulong.MaxValue);
LargeInteger b = a * (new LargeInteger(ulong.MaxValue) * 9000);
LargeInteger c = b / (a * 9000);
Assert.AreEqual(ulong.MaxValue, (ulong)c);
}
private static void Encode(ulong value, LargeInteger largeInteger)
{
var lower = (uint)(value & 0xffffffff);
var upper = (uint) (value >> 32);
largeInteger.data.Add(lower);
if (upper > 0)
{
largeInteger.data.Add(upper);
}
}
public void ToString_Test()
{
LargeInteger largeInteger = new LargeInteger(uint.MaxValue) * uint.MaxValue * uint.MaxValue;
string result = largeInteger.ToString();
const string expected = "79228162458924105385300197375";
Assert.AreEqual(expected, result);
}
public void Multiplication_Test()
{
LargeInteger a = new LargeInteger(ulong.MaxValue);
LargeInteger b = a * new LargeInteger(ulong.MaxValue);
LargeInteger c = b / a;
Assert.AreEqual(ulong.MaxValue, (ulong)c);
}
public void String_Test()
{
// Arrange
PropertyInfo propertyInfo = typeof(ClassWithStringAutoPrimaryKey).GetProperty("Key");
const string value = "X";
var expected = new LargeInteger(7);
const string command = "XXXX";
this.commandGeneratorMock.Setup(m => m.WriteString(propertyInfo)).Returns(command);
this.encoderMock.Setup(m => m.Decode(value)).Returns(expected);
// Act
WriterDelegate stringWriter = this.writerDictionary[value.GetType()];
DecoderDelegate stringDecoder = stringWriter(propertyInfo);
LargeInteger result = stringDecoder(propertyInfo, value);
// Assert
Assert.AreEqual(expected, result);
this.commandGeneratorMock.Verify(m => m.WriteString(propertyInfo), Times.Once);
this.primitivesMock.Verify(m => m.AddSqlCommand(command));
}
private static ulong Decode(LargeInteger largeInteger)
{
if (largeInteger.data.Count > 2)
{
throw new OverflowException();
}
ulong result = LargeInteger.GetULong(largeInteger.data);
return result;
}
public void LessThan_Test()
{
var lessThan = new LargeInteger(LargeIntegerTests.MaxValue- LargeIntegerTests.MaxValue/2);
var greaterThan = new LargeInteger(LargeIntegerTests.MaxValue);
Assert.IsTrue(lessThan < greaterThan);
}
private LargeInteger Ensure(ref LargeInteger largeInteger)
{
this.Ensure();
return LargeInteger.Ensure(ref largeInteger, null);
}
public void Modulus_Test()
{
var largeInteger = new LargeInteger(LargeIntegerTests.MaxValue);
LargeInteger result = largeInteger%23;
Assert.AreEqual(LargeIntegerTests.MaxValue % 23, (ulong)result);
}
public void DefaultInitialValue_Test()
{
var largeInteger = new LargeInteger();
Assert.AreEqual(0uL, (ulong)largeInteger);
}
public void Subtraction_Test()
{
var left = new LargeInteger(LargeIntegerTests.MaxValue);
var right = new LargeInteger(LargeIntegerTests.MaxValue / 2);
LargeInteger result = left - right;
Assert.AreEqual(LargeIntegerTests.MaxValue - LargeIntegerTests.MaxValue / 2, (ulong)result);
}
private static int CompareSameLength(LargeInteger left, LargeInteger right)
{
int i;
for (i = left.data.Count - 1; i >= 0; i--)
{
if (left.data[i] != right.data[i])
{
break;
}
}
if (i == -1)
{
return 0;
}
return left.data[i] < right.data[i] ? -1 : 1;
}
public void Division_OneElementDenominator_Test()
{
const ulong expected = (ulong)(ulong.MaxValue * (3m / 4));
LargeInteger largeInteger = new LargeInteger(ulong.MaxValue) * 3;
LargeInteger result = largeInteger / 4;
Assert.AreEqual(expected, (ulong)result);
}
public LargeInteger Pow(ulong power)
{
LargeInteger.Logger.Debug($"Entering Pow. this: {this}, power: {power}");
this.Ensure();
if (this == 0 && power == 0)
{
throw new DivideByZeroException("LargeInteger: divide by zero");
}
var result = new LargeInteger(1);
for (var i = 0uL; i < power; i++)
{
result *= this;
}
LargeInteger.Logger.Debug($"Exiting Pow. result: {result.PrintLargeInteger()}");
return result;
}
public void Division_OneElementNumerator_Test()
{
const ulong expected = (ulong)(48648);
LargeInteger largeInteger = new LargeInteger(48648 * 75);
LargeInteger result = largeInteger / 75;
Assert.AreEqual(expected, (ulong)result);
}
public void Division_Test()
{
LargeInteger numerator = new LargeInteger(ulong.MaxValue) * 35 * 14;
LargeInteger denominator = new LargeInteger(ulong.MaxValue) * 35;
LargeInteger quotient = numerator / denominator;
Assert.AreEqual((ulong)14, (ulong)quotient);
}
public void Division_LargeDenominator_Test()
{
LargeInteger a = new LargeInteger(ulong.MaxValue).Pow(7);
LargeInteger b = new LargeInteger(ulong.MaxValue).Pow(5);
LargeInteger result = a/b;
Assert.AreEqual(new LargeInteger(ulong.MaxValue).Pow(2), result);
}
private LargeInteger Clone()
{
var result = new LargeInteger {data = this.data.GetRange(0, this.data.Count) };
return result;
}