public void TestResistanceCalculatorBadInput()
{
IOhmValueCalculator calc = new ResistanceCalculator();
var result = calc.CalculateResistance("this", "is", "not", "right");
Assert.AreEqual(result, "Incorrect Color Given");
}
public void TestCalculateOhmValueBadInput()
{
IOhmValueCalculator calc = new ResistanceCalculator();
var result = calc.CalculateOhmValue("this", "is", "not", "right");
Assert.AreEqual(result, (-1M, -1M));
}
public void TestCalculateOhmValueManualSpotCheck()
{
IOhmValueCalculator calc = new ResistanceCalculator();
var result = calc.CalculateOhmValue("Red", "Red", "Blue", "None");
Assert.AreEqual(result, (22000000M, 20M));
result = calc.CalculateOhmValue("Black", "Gray", "Orange", "Brown");
Assert.AreEqual(result, (8000, 1));
result = calc.CalculateOhmValue("Violet", "White", "Yellow", "Gold");
Assert.AreEqual(result, (790000, 5));
}
public void TestLargeValue()
{
//Arrange
IOhmValueCalculator ohmValueCalculator = new ResistanceCalculator();
//Act
int result = ohmValueCalculator.CalculateOhmValue("white", "white", "blue", "silver");
//Assert
Assert.AreEqual(99000000, result);
}
public void TestResistor_IsTrue()
{
//Arrange
IOhmValueCalculator ohmCalc = new ResistanceCalculator();
//Act
ResistorCaculatedValue r = ohmCalc.CalculateOhmValue("orange", "yellow", "red", "green");
//Assert
Assert.AreEqual("3400 Ohms", r.GetSetResistor);
}
public void TestResistor3()
{
//Arrange
IOhmValueCalculator ohmValueCalculator = new ResistanceCalculator();
//Act
ColorCodeResult result = ohmValueCalculator.CalculateOhmValue("green", "black", "pink", "blue");
//Assert
Assert.AreEqual("0.050125", result.MaximumResistance);
}
public void CalculateOhmValueTest()
{
////Arrange
IOhmValueCalculator ohmValueCalculator = new ResistanceCalculator();
////Act
ColorCodeResult result = ohmValueCalculator.CalculateOhmValue("brown", "black", "black", "brown");
////Assert
Assert.AreEqual("10.1", result.MaximumResistance);
}
public void TestFourBandCalculation()
{
//Arrange
IOhmValueCalculator ohmValueCalculator = new ResistanceCalculator();
//Act
int result = ohmValueCalculator.CalculateOhmValue("yellow", "violet", "brown", "gold");
//Assert
Assert.AreEqual(470, result);
}
public void TestSmallValue()
{
//Arrange
IOhmValueCalculator ohmValueCalculator = new ResistanceCalculator();
//Act
int result = ohmValueCalculator.CalculateOhmValue("brown", "black", "black", "brown");
//Assert
Assert.AreEqual(10, result);
}
public void TestResistanceCalculatorManualSpotCheck()
{
IOhmValueCalculator calc = new ResistanceCalculator();
var result = calc.CalculateResistance("Red", "Red", "Blue", "None");
Assert.AreEqual(result, "22000000Ω ±20%");
result = calc.CalculateResistance("Black", "Gray", "Orange", "Brown");
Assert.AreEqual(result, "8000Ω ±1%");
result = calc.CalculateResistance("Violet", "White", "Yellow", "Gold");
Assert.AreEqual(result, "790000Ω ±5%");
}
public void TestVeryLargeResistance()
{
//Arrange
IOhmValueCalculator ohmValueCalculator = new ResistanceCalculator();
//Act
ColorCodeResult result = ohmValueCalculator.CalculateOhmValue("white", "white", "white", "brown");
//Assert
Assert.AreEqual("99,990M", result.MaximumResistance);
}
public void TestResistor1()
{
//Arrange
IOhmValueCalculator ohmValueCalculator = new ResistanceCalculator();
//Act
ColorCodeResult result = ohmValueCalculator.CalculateOhmValue("yellow", "red", "red", "gold");
//Assert
Assert.AreEqual("4410", result.MaximumResistance);
}
public void TestLargeResistance()
{
//Arrange
IOhmValueCalculator ohmValueCalculator = new ResistanceCalculator();
//Act
ColorCodeResult result = ohmValueCalculator.CalculateOhmValue("white", "white", "white", "silver");
//Assert
Assert.AreEqual("108,900M", result.MaximumResistance);
}
public ActionResult getResistanceValue(string bandAColor, string bandBColor, string bandCColor, string bandDColor)
{
try
{
ColorCodeCalculator.IOhmValueCalculator objResistance = new ResistanceCalculator();
ColorCodeResult resultObject = objResistance.CalculateOhmValue(bandAColor, bandBColor, bandCColor, bandDColor);
return(Json(new { min = resultObject.MinimumResistance, max = resultObject.MaximumResistance }));
}
catch (Exception ex)
{
return(Json(new { error = "Exception ocurred while calculating resistance value: " + ex.Message }));
}
}
public ActionResult getResistanceValue(string bandAColor, string bandBColor, string bandCColor, string bandDColor)
{
try
{
////Initialize interface object
IOhmValueCalculator objResistance = new ResistanceCalculator();
//// Call the method that calculates resistance value in ColorCodeCalculator class library
ColorCodeResult resultObject = objResistance.CalculateOhmValue(bandAColor, bandBColor, bandCColor, bandDColor);
//// return JSON response
return(Json(new { min = resultObject.MinimumResistance, max = resultObject.MaximumResistance }));
}
catch (Exception ex)
{
//// if exception then return error as response
return(Json(new { error = "Exception ocurred while calculating resistance value: " + ex.Message }));
}
}
public ActionResult getResistanceValue(string bandAColor, string bandBColor, string bandCColor, string bandDColor)
{
try
{
// Initializing the Object
IOhmValueCalculator objResistance = new ResistanceCalculator();
// Calling the method that calculates the resistor value
ResistorCaculatedValue resultObject = objResistance.CalculateOhmValue(bandAColor, bandBColor, bandCColor, bandDColor);
/// Returning the JSON response
return(Json(new { min = resultObject.ResistMin, max = resultObject.ResistMax, main = resultObject.GetSetResistor }));
}
catch (Exception ex)
{
// Return an error if there's an exception
return(Json(new { error = "Exception ocurred while calculating resistance value: " + ex.Message }));
}
}
public void TestIOhmValueCalculatorInputs()
{
IOhmValueCalculator calc = new ResistanceCalculator();
foreach (var colorA in ResistanceCalculator.ResistanceValueMap)
{
foreach (var colorB in ResistanceCalculator.ResistanceValueMap)
{
foreach (var colorC in ResistanceCalculator.ResistanceMagnitudeMap)
{
foreach (var colorD in ResistanceCalculator.ResistanceToleranceMap)
{
var result = calc.CalculateOhmValue(colorA.Key, colorB.Key, colorC.Key, colorD.Key);
Assert.AreNotEqual(result, (decimal.MinusOne, decimal.MinusOne));
}
}
}
}
}
public ActionResult GetResistanceValue(string bandAColor, string bandBColor, string bandCColor, string bandDColor)
{
try
{
// initialize interface object
IOhmValueCalculator objResistance = new ResistanceCalculator();
// Call the method that calculates resistance value
int resultResistance = objResistance.CalculateOhmValue(bandAColor, bandBColor, bandCColor, bandDColor);
/// return JSON response
return(Json(new { resistance = resultResistance }));
}
catch (Exception ex)
{
// if exception then return error as response
return(Json(new { error = "Exception ocurred while calculating resistance value: " + ex.Message }));
}
}
public void TestResistanceCalculatorInputs()
{
IOhmValueCalculator calc = new ResistanceCalculator();
string result = null;
foreach (var colorA in ResistanceCalculator.ResistanceValueMap)
{
foreach (var colorB in ResistanceCalculator.ResistanceValueMap)
{
foreach (var colorC in ResistanceCalculator.ResistanceMagnitudeMap)
{
foreach (var colorD in ResistanceCalculator.ResistanceToleranceMap)
{
result = calc.CalculateResistance(colorA.Key, colorB.Key, colorC.Key, colorD.Key);
Assert.IsFalse(result == null);
}
}
}
}
}
public void ZeroBandResistorTest()
{
Exception exceptionResult = null;
try
{ // Arrange
IOhmValueCalculator ohmValueCalculator = new ResistanceCalculator();
// Act
ohmValueCalculator.CalculateOhmValue(null, null, null, null);
}
catch (Exception exception)
{
exceptionResult = exception;
}
// Assert
Assert.IsNotNull(exceptionResult);
Assert.IsInstanceOfType(exceptionResult, typeof(ArgumentException));
}
public void TestIOhmValueCalculatorOutputs()
{
IOhmValueCalculator calc = new ResistanceCalculator();
foreach (var colorA in ResistanceCalculator.ResistanceValueMap)
{
foreach (var colorB in ResistanceCalculator.ResistanceValueMap)
{
foreach (var colorC in ResistanceCalculator.ResistanceMagnitudeMap)
{
foreach (var colorD in ResistanceCalculator.ResistanceToleranceMap)
{
var result = calc.CalculateOhmValue(colorA.Key, colorB.Key, colorC.Key, colorD.Key);
decimal resistance = (ResistanceCalculator.ResistanceValueMap[colorA.Key] * 10 + ResistanceCalculator.ResistanceValueMap[colorB.Key]) * ResistanceCalculator.ResistanceMagnitudeMap[colorC.Key];
var expected = (resistance, ResistanceCalculator.ResistanceToleranceMap[colorD.Key]);
Assert.AreEqual(result, expected);
}
}
}
}
}
public void TestResistanceCalculatorOutput()
{
IOhmValueCalculator calc = new ResistanceCalculator();
foreach (var colorA in ResistanceCalculator.ResistanceValueMap)
{
foreach (var colorB in ResistanceCalculator.ResistanceValueMap)
{
foreach (var colorC in ResistanceCalculator.ResistanceMagnitudeMap)
{
foreach (var colorD in ResistanceCalculator.ResistanceToleranceMap)
{
string result = calc.CalculateResistance(colorA.Key, colorB.Key, colorC.Key, colorD.Key);
decimal value = (ResistanceCalculator.ResistanceValueMap[colorA.Key] * 10 + ResistanceCalculator.ResistanceValueMap[colorB.Key]) * ResistanceCalculator.ResistanceMagnitudeMap[colorC.Key];
string expectedResult = $"{value}Ω ±{ResistanceCalculator.ResistanceToleranceMap[colorD.Key]}%";
Assert.AreEqual(expectedResult, result);
}
}
}
}
}
public void Series()
{
Assert.Equal(1089, ResistanceCalculator.Series(TestValues));
}
public void Parallel()
{
Assert.Equal(20.3416690826416, ResistanceCalculator.Parallel(TestValues));
}
