public void CalculatesCorrectly()
{
var adder = new Adder();
adder.Add(1);
adder.Add(2);
var result = adder.Calculate();
Assert.Equal(3, result);
}
public static float TestDuckTypeStruct()
{
var adder = new Adder <float>();
adder.Add(3);
adder.Add(1.5f);
return(adder.Total);
}
public void AdderAddTest()
{
int expectedValue = 5;
Adder adder = new Adder();
adder.Add(3);
adder.Add(2);
Assert.Equal(expectedValue, adder.Total);
}
static void Main()
{
Adder a = new Adder();
a.OnMultipleOfFiveReached += a_MultipleOfFiveReached;
int iAnswer = a.Add(4, 3);
Console.WriteLine("iAnswer = {0}", iAnswer);
iAnswer = a.Add(4, 6);
Console.WriteLine("iAnswer = {0}", iAnswer);
Console.ReadKey();
}
static void Main()
{
Adder a = new Adder();
//a.OnMultipleOfFiveReached += a_MultipleOfFiveReached;
a.OnMultipleOfFiveReached += new EventHandler <MultipleOfFiveEventArgs>(a_MultipleOfFiveReached);
int iAnswer = a.Add(4, 3);
Console.WriteLine("iAnswer = {0}", iAnswer);
iAnswer = a.Add(4, 6);
Console.WriteLine("iAnswer = {0}", iAnswer);
Console.ReadKey();
}
public void Overflow_test(string test_data_file)
{
//Given: 创建一个新的加法器
var testTable = Table.Parse(test_data_file);
var adder = new Adder();
foreach (var row in testTable)
{
int a;
int b;
if (!int.TryParse(row["a"], out a))
{
throw new FormatException("无效参数数据:" + row);
}
if (!int.TryParse(row["b"], out b))
{
throw new FormatException("无效参数数据:" + row);
}
Assert.Throws(typeof(OverflowException), () => adder.Add(a, b));
}
}
public void TestMethod1()
{
var expected = 3;
var actual = _adder.Add(1, 2);
Assert.AreEqual(expected, actual);
}
public void NormalTest()
{
//Given: 创建一个新的加法器
var adder = new Adder();
var testTable = Table.Parse(@"Specs\Adder\Adder.txt");
foreach (var row in testTable)
{
int a;
int b;
if (!int.TryParse(row["a"], out a))
{
throw new FormatException("无效参数数据:" + row);
}
if (!int.TryParse(row["b"], out b))
{
throw new FormatException("无效参数数据:" + row);
}
//When : 当向加法器的加法方法中传入两个参数
var strExpected = row["result"].Trim();
//Then ：那么加法器应当自动正确的计算出这两个数的和并返回
var actual = adder.Add(a, b);
var expected = int.Parse(row[2]);
Assert.AreEqual(expected, actual);
}
}
public void Add_SpecifiedInput_ExpectedOutput(int a, int b, int expected)
{
Adder adder = new Adder();
int actual = adder.Add(a, b);
Assert.AreEqual(expected, actual);
}
public static OmgNum Add(OmgNum left, OmgNum right)
{
if (left.IsNegative && right.IsNegative)
{
return(_Negative(m_adder.Add(left.Raw, right.Raw)));
}
if (!left.IsNegative && right.IsNegative)
{
return(m_subtracter.Subtract(left, _AbsShell(right)));
}
if (left.IsNegative && !right.IsNegative)
{
m_subtracter.Subtract(right, _AbsShell(left));
}
return(_Positive(m_adder.Add(left.Raw, right.Raw)));
}
public void GivenTwoNumbersShouldReturnSumOfThem()
{
var calculator = new Adder();
var result = calculator.Add("2,1");
Assert.AreEqual(result, 3);
}
public void GivenOneNumberShouldReturnThatNumber()
{
var calculator = new Adder();
var result = calculator.Add("1");
Assert.AreEqual(result, 1);
}
public void ShouldReturnSumWithMoreComplicateStream()
{
var calculator = new Adder();
var input = "1\n2,3";
var result = calculator.Add(input);
Assert.AreEqual(6, result);
}
public void GivenEmptyStringShouldReturnZero()
{
var calculator = new Adder();
var result = calculator.Add("");
Assert.AreEqual(result, 0);
}
public int Subtract(int a, int b)
{
Console.WriteLine("METHOD CALL - DefaultCalculator.Subtract({0}, {1})", a, b);
// User IAdder provided contract to fulfill the "Subtract"
// request, from ICalculator contract.
return(Adder.Add(a, -b));
}
public int Add(int a, int b)
{
if (Verbose)
{
Console.WriteLine("METHOD CALL - DefaultCalculator.Add({0}, {1})", a, b);
}
return(Adder.Add(a, b));
}
public static void FinalizeBundleHash(this IEnumerable <TransactionItem> transactionItems)
{
var validBundle = false;
while (!validBundle)
{
var kerl = new Kerl();
kerl.Reset();
var transactionCount = transactionItems.Count();
for (int i = 0; i < transactionCount; i++)
{
var transaction = transactionItems.ElementAt(i);
var valueTrits = Converter.GetTrits(transaction.Value).ToLength(81);
var timestampTrits = Converter.GetTrits(transaction.Timestamp).ToLength(27);
var currentIndexTrits = Converter.GetTrits(transaction.CurrentIndex = ("" + i)).ToLength(27);
var lastIndexTrits = Converter.GetTrits(
transaction.LastIndex = ("" + (transactionCount - 1))).ToLength(27);
string stringToConvert = transaction.Address
+ Converter.GetTrytes(valueTrits)
+ transaction.Tag +
Converter.GetTrytes(timestampTrits)
+ Converter.GetTrytes(currentIndexTrits) +
Converter.GetTrytes(lastIndexTrits);
var t = Converter.GetTrits(stringToConvert);
kerl.Absorb(t, 0, t.Length);
}
sbyte[] hash = new sbyte[Curl.HASH_LENGTH];
kerl.Squeeze(hash, 0, hash.Length);
string hashInTrytes = Converter.GetTrytes(hash);
foreach (var transaction in transactionItems)
{
transaction.Bundle = hashInTrytes;
}
var normalizedHash = NormalizedBundle(hashInTrytes);
if (normalizedHash.Contains(13))
{
// Insecure bundle. Increment Tag and recompute bundle hash.
var firstTransaction = transactionItems.ElementAt(0);
var increasedTag = Adder.Add(Converter.GetTrits(firstTransaction.Tag), new sbyte[1]);
firstTransaction.Tag = Converter.GetTrytes(increasedTag);
}
else
{
validBundle = true;
}
}
}
public void Add_For1Plus1_Returns2()
{
const int expected = 2;
var sut = new Adder();
var actual = sut.Add(1, 1);
Assert.Equal(expected, actual);
}
public void AdderResetTest()
{
int expectedValue = 0;
Adder adder = new Adder();
adder.Add(4);
adder.Reset();
Assert.Equal(expectedValue, adder.Total);
}
public void ShouldReturnSumOfMoreNumbers()
{
var calculator = new Adder();
var input = "1,2,3,4,5";
var result = calculator.Add(input);
Assert.AreEqual(15, result);
}
public void NewlineShouldBeAValidDelimiter()
{
var calculator = new Adder();
var input = "1\n2";
var result = calculator.Add(input);
Assert.AreEqual(3, result);
}
public AdderSpec()
{
Describe <Adder>(() =>
{
It("can add a positive number to a negative number", () =>
{
var adder = new Adder();
Expect(adder.Add(-1, 1)).ToEqual(0M);
});
});
Describe <Adder>(() =>
{
List <decimal[]> specs = new List <decimal[]>
{ // n1, n2, expected
new[] { -7M, 3M, -4M },
new[] { 0M, 0M, 0M },
new[] { 999999999M, 1M, 1000000000M }
};
foreach (var spec in specs)
{
It($"can add 2 numbers ({spec[0]}, {spec[1]})", () =>
{
var adder = new Adder();
Expect(adder.Add(spec[0], spec[1])).ToEqual(spec[2]);
});
}
});
Describe <Adder>(() =>
{
It("appends to history", () =>
{
OperationHistory history = new OperationHistory();
Spy historySpy = Jaz.SpyOn(history, nameof(history.Append));
var adder = new Adder(history);
adder.Add(-1, 1);
Expect(historySpy).ToHaveBeenCalled();
});
});
Describe <Adder>(() =>
{
Describe(nameof(Adder.Add), () =>
{
It("can add a positive number to a negative number", () =>
{
var adder = new Adder();
Expect(adder.Add(-1, 1)).ToEqual(0M);
});
});
});
}
public void add_test()
{
const int a = 1;
const int b = 2;
var adder = new Adder();
var c = adder.Add(a, b);
Assert.AreEqual(3, c);
}
public void Adder_Simple()
{
var adder = new Adder();
const int expected = 10;
var result = adder.Add(2, 8);
Assert.Equal(expected, result);
}
public void ItShouldAddTwoNumbers()
{
var number1 = 7;
var number2 = 10;
var expectedResult = 17;
var target = new Adder();
var actualResult = target.Add(number1, number2);
actualResult.Should().Be(expectedResult);
}
public void TestAdd(AdderTestCaseSetup setup, string s)
{
//Arrange
var adder = new Adder();
//Act
var result = adder.Add(setup.LHS, setup.RHS);
//Assert
Assert.AreEqual(setup.Expected, result);
}
private static void EventsAndHandlers()
{
Adder a = new Adder();
a.OnMultipleOfFiveReached += ThingsToDo.ProcessMultipleOfFiveReached;
// same event to process several actions
a.OnMultipleOfTenReached += ThingsToDo.ProcessMultipleOfTenReached;
// anonymous (no need to refer to a method to be executed with parameters)
a.OnMultipleOfTenReached += (s, e) => ThingsToDo.ProcessSourceLambda(e, "TEN");
a.OnMultipleOfTenReached += (s, e) => ThingsToDo.ProcessSourceLambda("MARK LANEGAN");
// below several examples to attach an action to be performed on an event:
// (actually here, 1 event raises several actions)
a.OnMultipleOfOtherReached += ThingsToDo.ProcessMultipleOfOtherReached;
a.OnMultipleOfOtherReached += new EventHandler <MultipleOfOtherEventArgs>(ThingsToDo.ProcessMultipleOfOtherReached);
// anonymous --> here is "live attachment"...
a.OnMultipleOfOtherReached += delegate(object sender, MultipleOfOtherEventArgs e) {
Console.WriteLine($"ANONYMOUS METHOD --> {e.Value} is a multiple of {e.Text} reached! ");
};
// lambda --> here is "live attachment"...
a.OnMultipleOfOtherReached += (s, e) => {
Console.WriteLine($"LAMBDA METHOD --> {e.Value} is a multiple of {e.Text} reached! ");
};
int iAnswer = a.Add(4, 3);
Console.WriteLine("------------------------");
iAnswer = a.Add(4, 6);
Console.WriteLine("------------------------");
iAnswer = a.Add(5, 20);
Console.WriteLine("------------------------");
iAnswer = a.Add(5, 25);
Console.WriteLine("------------------------");
iAnswer = a.Add(1, 1);
Console.WriteLine("------------------------");
}
public static void Add()
{
// Arrange
var x = 3;
var y = 6;
// Act
var result = Adder.Add(x, y);
// Assert
Assert.That(result, Is.EqualTo(9));
}
public void Adder_Add_NegativeAugendLessThanAddend_ShouldTrowException()
{
// Arrange
var adder = new Adder();
var addend = 1;
var augend = -1;
// Act
Action actual = () => adder.Add(addend, augend);
// Assert
Assert.That(actual, Throws.ArgumentException);
}
public void Adder_Add_ZeroPlusZero_ShouldReturnZero()
{
// Arrange
var adder = new Adder();
var addend = 0;
var augend = 0;
// Act
int actual = adder.Add(addend, augend);
// Assert
Assert.That(actual, Is.EqualTo(0));
}
public void ProvideTheSUT(Adder adder, int first, int second)
{
Assert.Equal(first + second, adder.Add(first, second));
}
public void MixAndMatchSpecificallyProvidedAndAutoCreatedInput(int first, int second, Adder adder)
{
Assert.Equal(first + second, adder.Add(first, second));
}
