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)); }