public void Add() { Arithmetic a = new Arithmetic(); int res = a.Add(1, 2); Assert.Equal(3, res); }
public void AddMultiple(int parmaA, int parmaB) { Arithmetic a = new Arithmetic(); int res = a.Add(parmaA, parmaB); Assert.Equal(parmaA + parmaB, res); }
public void Add_Ok() { Arithmetic arithmetic = new Arithmetic(); var sum = arithmetic.Add(1, 2); Assert.True(sum == 3); }
//tests if display isnt empty, tests for which sign was pressed to calculate accordingly // or displays an error for missing number private void Equals() { if (!String.IsNullOrEmpty(txtboxDisplay.Text)) { if (plusClick == true) { calcNumTwo = Arithmetic.Add(calcNumOne, DoubleParse(txtboxDisplay.Text)); } else if (minusClick == true) { calcNumTwo = Arithmetic.Sub(calcNumOne, DoubleParse(txtboxDisplay.Text)); } else if (divideClick == true) { calcNumTwo = Arithmetic.Div(calcNumOne, DoubleParse(txtboxDisplay.Text)); } else if (multiplyClick == true) { calcNumTwo = Arithmetic.Mult(calcNumOne, DoubleParse(txtboxDisplay.Text)); } } else { MessageBox.Show("Missing number", "Error Message"); } }
public void Add_No(int nb1, int nb2, int result) { Arithmetic arithmetic = new Arithmetic(); var sum = arithmetic.Add(nb1, nb2); Assert.False(sum == result); }
public void Add_Ok_Two(int num1, int num2, int result) { Arithmetic arithmetic = new Arithmetic(); var sum = arithmetic.Add(num1, num2); Assert.True(sum == result); }
public void AddTest() { Arithmetic a = new Arithmetic(); int c = a.Add(-10, -20); Assert.AreEqual(c, 30); }
public void TestMethod1() { int H = 10; int F = 20; int K = Arithmetic.Add(H, F); Assert.AreEqual(30, K); }
public void TestMethod1() { int a = 10; int b = 20; int c = Arithmetic.Add(a, b); Assert.AreEqual(30, c); }
public void TestMethod1() { int W = 25; int Z = 30; int H = Arithmetic.Add(W, Z); Assert.AreEqual(30, H); }
public void TestAddIntMaxValue() { var maxint = int.MaxValue; var increment = 1; var result = Arithmetic.Add(int.MaxValue, increment); Assert.AreEqual(increment + maxint, result); }
public void Add_GivenTheories(decimal left, decimal right, decimal expected) { // arrange - done by theories // act decimal actual = Arithmetic.Add(left, right); // assert Assert.Equal(expected, actual); }
static void Main(string[] args) { int a = 10, b = 6; Console.WriteLine(Arithmetic.Add(a, b)); Console.WriteLine(Arithmetic.Subtract(a, b)); Console.WriteLine(Arithmetic.Multiply(a, b)); Console.WriteLine(Arithmetic.Divide(a, b)); }
private void btnEquals_Click(object sender, EventArgs e) { input = Parser(txtboxInputOutput.Text); if (btnPlusClicked == true) { output = Arithmetic.Add(temp, input); } else if (btnMinusClicked == true) { output = Arithmetic.Subtract(temp, input); } else if (btnDivideClicked == true) { output = Arithmetic.Divide(temp, input); } else if (btnMultiplyClicked == true) { output = Arithmetic.Multiply(temp, input); } else if (btnInverseClicked == true) { output = Algebraic.Inverse(input); } else if (btnSquareRootClicked == true) { output = Algebraic.SquareRoot(input); } else if (btnCubeRootClicked == true) { output = Algebraic.CubeRoot(input); } else if (btnTanClicked == true) { output = Trigonometric.Tan(input); } else if (btnSinClicked == true) { output = Trigonometric.Sine(input); } else if (btnCosClicked == true) { output = Trigonometric.Cosine(input); } txtboxInputOutput.Text = output.ToString(); }
public static void CompiledOperationsTest() { Assert.Equal(3, Arithmetic.Add(1, 2)); Assert.Equal(1, Arithmetic.Subtract(2, 1)); Assert.Equal(8, Arithmetic.Multiply(2, 4)); Assert.Equal(4, Arithmetic.Divide(8, 2)); Assert.Equal(2, Arithmetic.Increment(1)); Assert.Equal(1UL, Arithmetic.Decrement(2UL)); Assert.Throws <NotSupportedException>(() => Arithmetic <string> .Subtract("1", "2")); }
public void TestAdd() { Assert.AreEqual(-97, Arithmetic.Add(-49, -48)); Assert.AreEqual(-3, Arithmetic.Add(-1, -2)); Assert.AreEqual(0, Arithmetic.Add(-1, 1)); Assert.AreEqual(97, Arithmetic.Add(49, 48)); try { Arithmetic.Add(-49, -50); Assert.Fail("Add should have thrown an exceptin"); } catch (Exception) { } }
public void Add_2_Plus_2_Equals_4() { //Arrange //Nothing to arrange //Act int result = Arithmetic.Add(2, 2); //Assert Assert.Equal(4, result); }
public void GivenTwoIntegers_WhenAddIsCall_ThenIntegerIsReturned() { // var mockArithmetic = new Mock<Arithmetic>(); var target = new Arithmetic(); // Act var actual = target.Add(1, 2); // Assert Assert.AreEqual(actual, 3); }
public void Add_GivenData(decimal left, decimal right, decimal expected) { // arrange - done by data rows // act decimal actual = Arithmetic.Add(left, right); // assert Assert.AreEqual(expected, actual); // CollectionAssert. // StringAssert. }
static void Main(string[] args) { Arithmetic proxy = new Arithmetic(); proxy.Url = "http://localhost/server/arithmetic.asmx"; Add add = new Add(); add.n1 = 10; add.n2 = 20; AddResponse resp = proxy.Add(add); Console.WriteLine("10 + 20 = " + resp.sum); }
public void TestValidAdd() { var actual = Arithmetic.Add(-50, -50); Assert.AreEqual(-50 + -50, actual, "n50 fail"); actual = Arithmetic.Add(-49, -49); Assert.AreEqual(-49 + -49, actual, "n49 fail"); actual = Arithmetic.Add(0, 0); Assert.AreEqual(0 + 0, actual, "0 fail"); actual = Arithmetic.Add(49, 49); Assert.AreEqual(49 + 49, actual, "49 fail"); actual = Arithmetic.Add(50, 50); Assert.AreEqual(50 + 50, actual, "50 fail"); }
public static void Run() { var arith = new Arithmetic(); double a = 5; double b = 15; double sum = arith.Add(a, b); double sub = arith.Substract(a, b); double diff = arith.Difference(a, b); Console.WriteLine("Numbers: {0} and {1}\r\n", a, b); Console.WriteLine("Sum: " + sum); Console.WriteLine("Substraction: " + sub); Console.WriteLine("Difference: " + diff); Console.WriteLine("Absolute value of -3: " + Arithmetic.MathAbs(-3)); }
private void PerfTestInternal <T>(int count) { // Random random = RandomManager.CreateRandom(SeedVariatorType.CallingMethod); IInstanceGenerator <T> generator = InstanceGeneratorProvider.Default.GetInstanceGenerator <T>(); T instance1 = generator.GetInstance(random); T instance2 = generator.GetInstance(random); Arithmetic <T> arithmetic = Arithmetic <T> .Default; using (new Measurement(typeof(T).Name, count)) { for (int i = 0; i < count; i++) { arithmetic.Add(instance1, instance2); } } }
public void AddRegistersWithCarry(byte a, byte b) { var registerFile = InitialRegisterFile.WithRegister(0, a).WithRegister(1, b).WithStatusRegister(sr => sr.WithCarry(true)); byte c = (byte)(a + b + 1); registerFile = Arithmetic.Add(registerFile, 0, 1, new object[] { true }); Assert.AreEqual(a + b + 1 > 255, registerFile.StatusRegister.C, "Carry"); Assert.AreEqual(c == 0, registerFile.StatusRegister.Z, "Zero"); Assert.AreEqual((a & 0xf) + (b & 0xf) > 0xf, registerFile.StatusRegister.H, "Half carry"); Assert.AreEqual((a >= 128 && b >= 128 && c < 128) || (a < 128 && b < 128 && c >= 128), registerFile.StatusRegister.V, "Two's complement overflow"); Assert.AreEqual(registerFile.StatusRegister.N ^ registerFile.StatusRegister.V, registerFile.StatusRegister.S, "Sign"); Assert.AreEqual(c >= 128, registerFile.StatusRegister.N, "Negative"); Assert.AreEqual(c, registerFile[0], "Result"); }
public void Add() { void Test(int x, int y) => Assert.AreEqual(x + y, Arithmetic.Add(x, y)); foreach (var i in ExtremeValues) { foreach (var j in ExtremeValues) { Test(i, j); } } for (int i = 0; i < 1000; i++) { Test(NextInt32(), NextInt32()); } }
public void Test() { const int count = 100; Assert.IsNull(Arithmetic <string> .Default); Arithmetic <long> longArithmetic = Arithmetic <long> .Default; Arithmetic <double> doubleArithmetic = Arithmetic <double> .Default; Arithmetic <int> intArithmetic = Arithmetic <int> .Default; Assert.IsNotNull(longArithmetic); Assert.IsNotNull(doubleArithmetic); Assert.IsNotNull(intArithmetic); Assert.AreEqual(longArithmetic.Implementation.GetType().Name, "Int64Arithmetic"); Assert.AreEqual(intArithmetic.Implementation.GetType().Name, "Int32Arithmetic"); Assert.AreEqual(doubleArithmetic.Implementation.GetType().Name, "DoubleArithmetic"); checked { IEnumerable <long> longValues = InstanceGeneratorProvider.Default.GetInstanceGenerator <long>().GetInstances(random, count); foreach (long longValue in longValues) { AssertEx.ResultsAreEqual <long>(() => (long)(longValue / 12.34d), () => longArithmetic.Divide(longValue, 12.34d)); AssertEx.ResultsAreEqual <long>(() => (long)(longValue * 12.34d), () => longArithmetic.Multiply(longValue, 12.34d)); AssertEx.ResultsAreEqual <long>(() => longValue + longValue, () => longArithmetic.Add(longValue, longValue)); AssertEx.ResultsAreEqual <long>(() => longValue - longValue, () => longArithmetic.Subtract(longValue, longValue)); AssertEx.ResultsAreEqual <long>(() => - longValue, () => longArithmetic.Negation(longValue)); } IEnumerable <int> intValues = InstanceGeneratorProvider.Default.GetInstanceGenerator <int>().GetInstances(random, count); foreach (int intValue in intValues) { AssertEx.ResultsAreEqual <int>(() => (int)(intValue / 12.34d), () => intArithmetic.Divide(intValue, 12.34d)); AssertEx.ResultsAreEqual <int>(() => (int)(intValue * 12.34d), () => intArithmetic.Multiply(intValue, 12.34d)); AssertEx.ResultsAreEqual <int>(() => intValue + intValue, () => intArithmetic.Add(intValue, intValue)); AssertEx.ResultsAreEqual <int>(() => intValue - intValue, () => intArithmetic.Subtract(intValue, intValue)); AssertEx.ResultsAreEqual <int>(() => - intValue, () => intArithmetic.Negation(intValue)); } IEnumerable <double> doubleValues = InstanceGeneratorProvider.Default.GetInstanceGenerator <double>().GetInstances(random, count); foreach (double doubleValue in doubleValues) { AssertEx.ResultsAreEqual <double>(() => doubleValue / 12.34d, () => doubleArithmetic.Divide(doubleValue, 12.34d)); AssertEx.ResultsAreEqual <double>(() => doubleValue * 12.34d, () => doubleArithmetic.Multiply(doubleValue, 12.34d)); AssertEx.ResultsAreEqual <double>(() => doubleValue + doubleValue, () => doubleArithmetic.Add(doubleValue, doubleValue)); AssertEx.ResultsAreEqual <double>(() => doubleValue - doubleValue, () => doubleArithmetic.Subtract(doubleValue, doubleValue)); AssertEx.ResultsAreEqual <double>(() => - doubleValue, () => doubleArithmetic.Negation(doubleValue)); } } }
public LinkFrequency <TLink> IncrementFrequency(ref Doublet <TLink> doublet) { if (_doubletsCache.TryGetValue(doublet, out LinkFrequency <TLink> data)) { data.IncrementFrequency(); } else { var link = _links.SearchOrDefault(doublet.Source, doublet.Target); data = new LinkFrequency <TLink>(_one, link); if (!_equalityComparer.Equals(link, default)) { data.Frequency = Arithmetic.Add(data.Frequency, _frequencyCounter.Count(link)); } _doubletsCache.Add(doublet, data); } return(data); }
static void Main(string[] args) { Arithmetic Art = new Arithmetic(); Console.WriteLine("Enter First Number :-"); double first = double.Parse(Console.ReadLine()); Console.WriteLine("Enter Second Number :-"); double second = double.Parse(Console.ReadLine()); Console.WriteLine("-----------------"); Console.WriteLine(" Enter 1 for ADDITION \n Enter 2 for SUBTRACTION \n Enter 3 for MULTIPLICATION \n ENTER 4 for DIVISION \n ENTER 5 for MODULUS \n ENTER 6 for exit"); Console.WriteLine("-----------------"); int no = int.Parse(Console.ReadLine()); switch (no) { case 1: Console.WriteLine("Addition is :-", Art.Add(first, second)); break; case 2: Console.WriteLine("Subtraction is :-" Art.Sub(first, second)); break; case 3: Console.WriteLine("Multiplication is :-" Art.Multi(first, second)); break; case 4: Console.WriteLine("Division is :-" Art.Divd(first, second)); break; case 5: Console.WriteLine("Modulus is :-" Art.Mod(first, second)); break; case 6: Console.WriteLine("You selected exit"); break; } Console.ReadKey(); }
public static TLink CountUsages <TLink>(this ILinks <TLink> links, TLink link) { var constants = links.Constants; var values = links.GetLink(link); TLink usagesAsSource = links.Count(new Link <TLink>(constants.Any, link, constants.Any)); var equalityComparer = EqualityComparer <TLink> .Default; if (equalityComparer.Equals(values[constants.SourcePart], link)) { usagesAsSource = Arithmetic <TLink> .Decrement(usagesAsSource); } TLink usagesAsTarget = links.Count(new Link <TLink>(constants.Any, constants.Any, link)); if (equalityComparer.Equals(values[constants.TargetPart], link)) { usagesAsTarget = Arithmetic <TLink> .Decrement(usagesAsTarget); } return(Arithmetic <TLink> .Add(usagesAsSource, usagesAsTarget)); }
public AtomicActionRendererTest() { _record = new RecordingActionRenderer <Arithmetic>(); _renderer = new AtomicActionRenderer <Arithmetic>(_record); _fx = new IntegerSet(new BigInteger?[] { 0 }, null, new[] { _renderer }); (_successTx, _) = _fx.Sign( 0, Arithmetic.Add(1), Arithmetic.Mul(2), Arithmetic.Add(3) ); // failing transaction; should not be rendered: _fx.Sign( 0, Arithmetic.Add(1), new Arithmetic(), Arithmetic.Add(3) ); _record.ResetRecords(); }