public void VerifySubtractMethodReturnsCorrectDifferenceOfTwoNumbers()
{
CalculatorClass obj2 = new CalculatorClass();
int result = obj2.Subtract(4, 5);
Assert.That(result, Is.EqualTo(-1));
}
public void TestMultiplyMethod()
{
CalculatorClass obj3 = new CalculatorClass();
int result = obj3.Multiply(4, 5);
Assert.That(result, Is.EqualTo(20));
}
public void VerifyMultiplyMethodReturnsCorrectProductOfTwoNumbers()
{
CalculatorClass obj3 = new CalculatorClass();
int result = obj3.Multiply(4, 5);
Assert.That(result, Is.EqualTo(20));
}
public void ThenTheBalanceInMyAccountIs(int finalBalance)
{
CalculatorClass Cal = new CalculatorClass(AccountBalance, WithDrawAmount);
FinalBalance = Cal.Calculate();
Assert.AreEqual(FinalBalance, finalBalance);
}
public override void OnClick()
{
if (Yutai.ArcGIS.Common.Editor.Editor.CheckIsEdit(_menuStrip.TableView.FeatureLayer))
{
ITable pTable = _menuStrip.TableView.VirtualGridView.FeatureLayer.FeatureClass as ITable;
IField pField = pTable.Fields.Field[_menuStrip.ColumnIndex];
FieldCalculator frm = new FieldCalculator(_menuStrip.TableView.FeatureLayer.FeatureClass.Fields, pField);
if (frm.ShowDialog() == DialogResult.OK)
{
try
{
ICalculator pCalculator = new CalculatorClass();
ICursor pCursor = pTable.Search(null, false);
pCalculator.Cursor = pCursor;
pCalculator.Field = pField.Name;
pCalculator.Expression = frm.Expression;
pCalculator.Calculate();
Marshal.ReleaseComObject(pCursor);
}
catch (Exception exception)
{
MessageBox.Show(exception.Message);
}
_menuStrip.TableView.VirtualGridView.ShowTable(null);
}
}
else
{
MessageBox.Show(@"未启动编辑", Caption, MessageBoxButtons.OK, MessageBoxIcon.Warning);
}
}
public void TestMethodSubtraction()
{
Assert.AreEqual(CalculatorClass.Subtraction(0, 10), -10);
Assert.AreEqual(CalculatorClass.Subtraction(8, 8), 0);
Assert.AreEqual(CalculatorClass.Subtraction(05, 10), -5);
Assert.AreEqual(CalculatorClass.Subtraction(30, 10), 20);
}
public void TestMethodMultiplication()
{
Assert.AreEqual(CalculatorClass.Multiplication(8, 8), 8 * 8);
Assert.AreEqual(CalculatorClass.Multiplication(210, 210), 210 * 210);
Assert.AreEqual(CalculatorClass.Multiplication(0, 3), 0);
Assert.AreEqual(CalculatorClass.Multiplication(5, 0), 0);
}
public void VerifySubtractMethodReturnsCorrectDifferenceOfTwoNumbers(double num1, double num2)
{
CalculatorClass obj2 = new CalculatorClass();
double result = obj2.Subtract(num1, num2);
Assert.That(result, Is.EqualTo(result));
}
public void TestDivideMethod()
{
CalculatorClass obj4 = new CalculatorClass();
int result = obj4.Divide(8, 4);
Assert.That(result, Is.EqualTo(2));
}
public void TestSubtractMethod()
{
CalculatorClass obj2 = new CalculatorClass();
int result = obj2.Subtract(4, 5);
Assert.That(result, Is.EqualTo(-1));
}
// GET: Calculator
public ActionResult Index(double num1, double num2)
{
var clase = new CalculatorClass();
return(View(clase));
//return View(new CalculatorClass()); //son lo mismo
}
public void TestMethodAdd()
{
Assert.AreEqual(CalculatorClass.Add(2, 3), 5);
Assert.AreEqual(CalculatorClass.Add(-6, 6), 0);
Assert.AreEqual(CalculatorClass.Add(1, 3), 4);
Assert.AreEqual(CalculatorClass.Add(2, 1000000000), 1000000002);
}
public void VerifyDecimalNumbersReturnCorrectSum(double num1, double num2)
{
CalculatorClass obj6 = new CalculatorClass();
double result = obj6.Add(num1, num2);
Assert.That(result, Is.EqualTo(result));
}
public void VerifyDivideMethodReturnsCorrectDividend(double num1, double num2)
{
CalculatorClass obj4 = new CalculatorClass();
double result = obj4.Divide(num1, num2);
Assert.That(result, Is.EqualTo(result));
}
public void VerifyMultiplyMethodReturnsCorrectProduct(double num1, double num2)
{
CalculatorClass obj3 = new CalculatorClass();
double result = obj3.Multiply(num1, num2);
Assert.That(result, Is.EqualTo(result));
}
public void VerifyDivideMethodReturnsCorrectDividendOfTwoNumbers()
{
CalculatorClass obj4 = new CalculatorClass();
int result = obj4.Divide(8, 4);
Assert.That(result, Is.EqualTo(2));
}
public void TestMethodDivision()
{
Assert.AreEqual(CalculatorClass.Division(5, 5), 1);
Assert.AreEqual(CalculatorClass.Division(10, 5), 2);
Assert.AreEqual(CalculatorClass.Division(0, 5), 0);
//need write for exeption Method to this
//Assert.AreEqual(CalculatorClass.Division(5, 0), 0);
}
public void TestMethod1()
{
var calculator = new CalculatorClass();
int sumTest = calculator.Sum(4, 3);
Assert.AreEqual(7, sumTest);
}
public void DivideByZeroShouldThrowsAnDivideByZeroException()
{
// Arrange
var calculator = new CalculatorClass(x: 1, y: 0);
// Act
calculator.Divide();
}
public void Divide02()
{
ICalculator divide = new CalculatorClass();
double value1 = 5;
double value2 = 8.7;
double expectedResult = divide.Division(value1, value2);
Assert.That(expectedResult, Is.EqualTo(43.5));
}
public void Multiply02()
{
ICalculator multiply = new CalculatorClass();
double value1 = 125;
double value2 = 415;
double expectedResult = multiply.Multiplication(value1, value2);
Assert.That(expectedResult, Is.EqualTo(51875));
}
public void Subtract02()
{
ICalculator subtract = new CalculatorClass();
double value1 = 5;
double value2 = 14;
double expectedResult = subtract.Subtraction(value1, value2);
Assert.That(expectedResult, Is.EqualTo(-9));
}
public void Add02()
{
ICalculator add = new CalculatorClass();
double value1 = 5;
double value2 = 6;
double expectedResult = add.Addition(value1, value2);
Assert.That(expectedResult, Is.EqualTo(11));
}
public void VerifyAddMethodReturnsCorrectSumOfTwoNumbers()
{
//Arrange..set up the test
CalculatorClass obj = new CalculatorClass();
//Act...actionable event
int result = obj.Add(4, 5);
//Assert..expected result
Assert.That(result, Is.EqualTo(9));
}
public void Test_Calculator()
{
int a = 5;
int b = 5;
Assert.Equal(10, CalculatorClass.Sum(a, b));
Assert.Equal(0, CalculatorClass.Substract(a, b));
Assert.Equal(25, CalculatorClass.Multiply(a, b));
Assert.Equal(1, CalculatorClass.Divide(a, b));
}
public void TestAddMethod()
{
//Arrange..set up the test
CalculatorClass obj = new CalculatorClass();
//Act...actionable event
int result = obj.Add(4, 5);
//Assert..expected result
Assert.That(result, Is.EqualTo(9));
}
public void ExponentsTEST(double a, double b, double expected)
{ //Arrange
CalculatorClass calcInstance = new CalculatorClass();
//Act
double actual = calcInstance.Exponents(a, b);
//Assert
Assert.Equal(expected, actual);
}
public void MultiplyTEST(int a, int b, int expected)
{ //Arrange
CalculatorClass calcInstance = new CalculatorClass();
//Act
int actual = calcInstance.Multiply(a, b);
//Assert
Assert.Equal(expected, actual);
}
public void Factorial(int a, int expected)
{
//Arrange
CalculatorClass calcInstance = new CalculatorClass();
//Act
int actual = calcInstance.Factorial(a);
//Assert
Assert.Equal(expected, actual);
}
public void AddTest(int[] number, int expected)
{
//Arrange
CalculatorClass calcInstance = new CalculatorClass();
//Act
int actual = calcInstance.Addition(number);
//Assert
Assert.Equal(expected, actual);
}
static void Main(string[] args)
{
ICalculator calculator = new CalculatorClass();
while (true)
{
try
{
Console.Write("Enter first number: ");
int first = int.Parse(Console.ReadLine());
Console.Write("Enter first number: ");
int second = int.Parse(Console.ReadLine());
Console.WriteLine("Add result: " + calculator.Add(first, second));
}
catch (ArgumentException)
{
Console.WriteLine("Attempted to add two zeros, exiting. Last result was: " + calculator.LastResult);
break;
}
}
}
private void setDynamicDefaults(IObject inObject, string mode)
{
try
{
//Convert row to feature (test for feature is null before using - this could be a table update)
IFeature inFeature = inObject as IFeature;
// Skip Orphan Junctions (saves time)
if (inFeature != null)
{
INetworkFeature inNetFeat = inObject as INetworkFeature;
if ((inNetFeat != null) &&
(inFeature.Class.ObjectClassID == inNetFeat.GeometricNetwork.OrphanJunctionFeatureClass.ObjectClassID))
return;
}
//Get cursor to dynamic values table retriving only
ICursor tabCursor;
getDefaultRows(inObject, out tabCursor);
IRow row = null;
if (tabCursor != null)
row = tabCursor.NextRow();
//for each row in the matching rows (matched by table name or wildcard) returned from the config table
while (row != null)
{
//get fieldname
string fieldName = row.get_Value(dynTargetField).ToString();
//if this field is found in the feature/object being added or modified...
int fieldNum = inObject.Fields.FindField(fieldName);
if (fieldNum > -1)
{
// get requested method and any data parameters
string valMethod = row.get_Value(dynMethodField).ToString();
string valData = row.get_Value(dynDataField).ToString();
switch (mode)
{
case "OnCreate":
//Continue to next field in config table if create events were not requested
if (row.get_Value(dynCreateField).ToString() == "0")
{
row = tabCursor.NextRow();
continue;
}
break;
case "OnChange":
// Collect value for changed feature (stored for LAST VALUE method)
IRowChanges inChanges = inObject as IRowChanges;
bool changed = inChanges.get_ValueChanged(fieldNum);
if (changed)
lastValueProperties.SetProperty(fieldName, inObject.get_Value(fieldNum));
//Continue to next field in config table if change events were not requested
if (row.get_Value(dynChangeField).ToString() == "0")
{
row = tabCursor.NextRow();
continue;
}
break;
}
// set values as specified
switch (valMethod)
{
case "TIMESTAMP":
inObject.set_Value(fieldNum, DateTime.Now);
break;
case "LAST_VALUE":
if (mode == "OnCreate")
{
//if (inObject.get_Value(fieldNum) == null)
//{
object lastValue = lastValueProperties.GetProperty(fieldName);
if (lastValue != null)
inObject.set_Value(fieldNum, lastValue);
//}
}
break;
case "FIELD":
// verify that field to copy exists
int fieldCopy = inObject.Fields.FindField(valData as string);
if (fieldCopy > -1)
{
//copy value only if current field is empty
string currentValue = inObject.get_Value(fieldNum).ToString();
if (currentValue == "")
inObject.set_Value(fieldNum, inObject.get_Value(fieldCopy));
}
break;
case "CURRENT_USER":
if (lastEditorName == null)
lastEditorName = getCurrentUser();
inObject.set_Value(fieldNum, lastEditorName);
break;
case "GUID":
if (mode == "OnCreate") // SHould only set this once on create to give the object a unique value
{
object currentValue = inObject.get_Value(fieldNum);
if (DBNull.Value == currentValue) // Do not overwrite if someone else has already generated
{
Guid g = Guid.NewGuid();
inObject.set_Value(fieldNum, g.ToString("B").ToUpper());
}
}
break;
case "EXPRESSION":
if (mode == "OnCreate")
{
if (inFeature != null & valData != null)
{
try
{
int calcField = inFeature.Fields.FindField(fieldName);
//if (inFeature.get_Value(calcField) == null)
//{
int[] fids = { inFeature.OID };
IGeoDatabaseBridge gdbBridge = new GeoDatabaseHelperClass();
IFeatureCursor fCursor = (IFeatureCursor)gdbBridge.GetFeatures((IFeatureClass)inFeature.Class, ref fids, false);
ICalculator calc = new CalculatorClass();
calc.Expression = valData;
calc.Field = fieldName;
calc.Cursor = (ICursor)fCursor;
calc.ShowErrorPrompt = false;
ICalculatorCallback calculatorCallback = new CalculatorCallback();
calc.Callback = calculatorCallback;
calc.Calculate();
calculatorCallback = null;
//}
}
catch { }
}
}
break;
default:
break;
}
}
row = tabCursor.NextRow();
}
if (null != tabCursor)
{
System.Runtime.InteropServices.Marshal.ReleaseComObject(tabCursor);
}
}
catch (Exception ex)
{
_logHelper.addLogEntry(DateTime.Now.ToString(), "ERROR", "Error applying dynamic defaults.", ex.ToString());
MessageBox.Show("Error: \n" + ex.ToString());
}
}
