public void CalculateOhmValueForAllBlackIsZero()
{
int result = _OhmValueCalculator.CalculateOhmValue(Convert.ToString((int)BandColor.Black),
Convert.ToString((int)BandColor.Black),
Convert.ToString((int)BandColor.Black),
Convert.ToString((int)BandColor.Black));
Assert.True(result.Equals(0));
}
public void TestCalculateOhmValueSuccess()
{
string bandAColor = "Yellow";
string bandBColor = "Violet";
string bandCColor = "Red";
string bandDColor = "Gold";
int ohmValue = _ohmValCalculator.CalculateOhmValue(bandAColor, bandBColor, bandCColor, bandDColor);
Assert.AreEqual(4700, ohmValue);
}
public void CalculateOhmValuePositiveTest()
{
string bandAClr = "Yellow";
string bandBclr = "Voilet";
string bandCclr = "Red";
string bandDclr = "Gold";
ResistanceValues actualValue = ohmCalcService.CalculateOhmValue(bandAClr, bandBclr, bandCclr, bandDclr);
Assert.AreEqual(4465, actualValue.minValue);
Assert.AreEqual(4935, actualValue.maxValue);
}
public void Test0Bands()
{
var bands = new[] { string.Empty, null, null, null };
var ex = null as Exception;
try { var result = calculator.CalculateOhmValue(bands[0], bands[1], bands[2], bands[3]); }
catch (Exception e) { ex = e; }
Assert.IsNotNull(ex);
}
// GET: ResistanceColorDecoder
public ActionResult Index()
{
if (null != _IOhmValueCalculator)
{
// Calculate the resistance value
var results = _IOhmValueCalculator.CalculateOhmValue(
_ResistorModel.ColorBandA, _ResistorModel.ColorBandB, _ResistorModel.ColorBandC, _ResistorModel.ColorBandD);
if (results[0] > 0 && results[1] > 0)
{
_ResistorModel.SetResistanceValue(results[0]);
_ResistorModel.SetToleranceValue(results[1]);
}
}
return(View(_ResistorModel));
}
public CalculatedOhmForResistor Get(string bandACode, string bandDCode, string bandBCode = "", string bandCCode = "")
{
CalculatedOhmForResistor returnValue;
try
{
returnValue = _ohmValueCalculatorService.CalculateOhmValue(bandACode, bandDCode, bandBCode, bandCCode);
}
catch (BandNotFoundException ex)
{
var resp = new HttpResponseMessage(HttpStatusCode.NoContent)
{
Content = new StringContent(ex.ExceptionMessage),
ReasonPhrase = "Color band not found."
};
throw new HttpResponseException(resp);
}
catch (WrongColorBandSelectedException ex)
{
var resp = new HttpResponseMessage(HttpStatusCode.NoContent)
{
Content = new StringContent(ex.ExceptionMessage),
ReasonPhrase = "Wrong Color band selected. We can't rate the resistor."
};
throw new HttpResponseException(resp);
}
return(returnValue);
}
public override void CalculatorTest(string bandA, string bandB, string bandC, string bandD, int ohms)
{
IOhmValueCalculator instance = CreateInstance();
int sutOhms = instance.CalculateOhmValue(bandA, bandB, bandC, bandD);
Assert.AreEqual(sutOhms, ohms);
}
public async Task <ActionResult> Index(IndexViewModel indexVM)
{
var response = new IndexResponseModel();
try
{
ValidateJsonAntiForgeryToken(indexVM.__RequestVerificationToken);
if (ModelState.IsValid)
{
response.OhmValue = await Task.Run(() => ohmCalculator.CalculateOhmValue(indexVM.BandAColor, indexVM.BandBColor, indexVM.BandCColor, indexVM.BandDColor));
}
else
{
throw new ECCException("Invalid parameters");
}
}
catch (ECCException ec)
{
response.IsError = true;
response.ErrorMessage = ec.Message;
}
catch
{
response.IsError = true;
response.ErrorMessage = "Unexpected Error has occurred";
}
return(Json(response));
}
public int GetOhmValue(OhmRequest request)
{
return(_OhmValueCalculator.CalculateOhmValue(Convert.ToString((int)request.bandAColor),
Convert.ToString((int)request.bandBColor),
Convert.ToString((int)request.bandCColor),
Convert.ToString((int)request.bandDColor)));
}
public String Calculate(string model)
{
//Color[] selectedColors = JsonConvert.DeserializeObject<Color[]>("[{Name: \"Yellow\"}, {Name: \"Violet\"}, {Name: \"Red\"}, {Name: \"Gold\"}]");
Color[] selectedColors = JsonConvert.DeserializeObject <Color[]>(Convert.ToString(model));
int resistance = _calculator.CalculateOhmValue(selectedColors[0].Name, selectedColors[1].Name, selectedColors[2].Name, selectedColors[3].Name);
return(resistance.ToString() + " ohms");
}
public int CalculateOhmValue(
[FromQuery] string a,
[FromQuery] string b,
[FromQuery] string c,
[FromQuery] string d
)
{
return(calculator.CalculateOhmValue(a, b, c, d));
}
public string Get(string colorA, string colorB, string multiplier, string percent)
{
return(_ohm.CalculateOhmValue(
colorA,
colorB,
multiplier,
percent,
_rt).ToString());
}
/// <summary>
/// Calulate the resistance value based on band selected band colors
/// </summary>
/// <param name="BandA"></param>
/// <param name="BandB"></param>
/// <param name="BandC"></param>
/// <param name="BandD"></param>
/// <returns>Returns a Json result to populate on the view</returns>
public JsonResult Calculate(string BandA, string BandB, string BandC, string BandD)
{
//Calculate OhmValue here
var ohmValueRange = bandEntities.CalculateOhmValue(BandA, BandB, BandC, BandD);
//return OhmValue as range
return(Json(new { maxValue = ohmValueRange["maxValue"].ToString(),
minValue = ohmValueRange["minValue"].ToString() }, JsonRequestBehavior.AllowGet));
}
public JsonResult LookupOhmValue(LookupOhmModel model)
{
//if (!ModelState.IsValid)
int ohmValue = _ohmValCalculator.CalculateOhmValue(model.BandAColor, model.BandBColor, model.BandCColor, model.BandDColor);
return(Json(new LookupOhmValueResponse {
Status = true,
OhmValue = ohmValue
}));
}
public IActionResult Get(string bandAColor, string bandBColor, string bandCColor, string bandDColor)
{
OhmValue value = _ohmValueCalculator.CalculateOhmValue(bandAColor, bandBColor, bandCColor, bandDColor);
if (value == null)
{
return(BadRequest());
}
return(Ok(value));
}
/// <summary>
/// Calculates the Ohm value of a resistor based on the band colors and the tolerance value band.
/// </summary>
/// <param name="bandAColor">The color of the first figure of component value band.</param>
/// <param name="bandBColor">The color of the second significant figure band.</param>
/// <param name="bandCColor">The color of the decimal multiplier band.</param>
/// <param name="bandDColor">The color of the tolerance value band.</param>
/// <returns>Json Result</returns>
public JsonResult GetOhmValue(string bandAValue, string bandBValue, string bandCValue, string bandDValue)
{
Regex regex = new Regex(@"^[0-9]\d*(\.\d+)?$");
if (regex.IsMatch(bandAValue) && regex.IsMatch(bandBValue) && regex.IsMatch(bandCValue) && regex.IsMatch(bandDValue))
{
int retVal = 0;
//_ohmCalculator.FinalValue = _ohmValueCalculator.CalculateOhmValue(bandAValue, bandBValue, bandCValue, bandDValue);
retVal = _ohmValueCalculator.CalculateOhmValue(bandAValue, bandBValue, bandCValue, bandDValue);
_ohmCalculator.FinalValue = retVal * Convert.ToDecimal(bandCValue);
_ohmCalculator.Tolerance = "ohms and " + bandDValue + "% tolerance";
}
return(Json(_ohmCalculator, JsonRequestBehavior.AllowGet));
}
public void CalculateOhmValueTest()
{
IOhmValueCalculator target = CreateIOhmValueCalculator(); // TODO: Initialize to an appropriate value
string bandAColor = string.Empty; // TODO: Initialize to an appropriate value
string bandBColor = string.Empty; // TODO: Initialize to an appropriate value
string bandCColor = string.Empty; // TODO: Initialize to an appropriate value
string bandDColor = string.Empty; // TODO: Initialize to an appropriate value
int expected = 0; // TODO: Initialize to an appropriate value
int actual;
actual = target.CalculateOhmValue(bandAColor, bandBColor, bandCColor, bandDColor);
Assert.AreEqual(expected, actual);
Assert.Inconclusive("Verify the correctness of this test method.");
}
public JsonResult CalculateOhmValue(string bandAColor, string bandBColor, string bandCColor, string bandDColor)
{
int ohmValue = ohmCalculator.CalculateOhmValue(bandAColor, bandBColor, bandCColor, bandDColor);
string result;
if (ohmValue != 0)
{
result = ohmCalculator.DecodeOhmValue(ohmValue);
}
else
{
result = "An unexpected input was received, please try again";
}
return(Json(result));
}
public IActionResult Get(string bandAColor, string bandBColor, string bandCColor, string bandDColor)
{
if (string.IsNullOrEmpty(bandAColor) || string.IsNullOrEmpty(bandBColor) || string.IsNullOrEmpty(bandCColor))
{
return(BadRequest("All colors must be filled."));
}
try
{
var result = calculator.CalculateOhmValue(bandAColor, bandBColor, bandCColor, bandDColor);
return(Ok(new ResistantResult(result, calculator.ResistanceValue.Tolorance,
calculator.ResistanceValue.Minimum, calculator.ResistanceValue.Maximum)));
}catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
public ActionResult ResistanceValue([FromBody] FourBands bandcolors)
{
try
{
if (bandcolors == null)
{
throw new ArgumentNullException();
}
CalculatorResult resultObject = _ohmValueCalculator.CalculateOhmValue(bandcolors.bandAColor,
bandcolors.bandBColor, bandcolors.bandCColor, bandcolors.bandDColor);
return(Json(new { min = resultObject.MinResistance, max = resultObject.MaxResistance }));
}
catch (Exception ex)
{
return(Json("Exception ocurred while calculating resistance value: " + ex.Message));
}
}
public ActionResult Index(RingColorModel model)
{
var response = new ResultModel();
try
{
ValidateJsonAntiForgeryToken(model.__RequestVerificationToken);
if (ModelState.IsValid)
{
response.OhmValue = calc.CalculateOhmValue(model.BandAColor, model.BandBColor, model.BandCColor, model.BandDColor);
}
}
catch (Exception ex)
{
response.IsError = true;
response.ErrorMessage = ex.Message;
}
return(Json(response));
}
public void TestOhmValueCalculation()
{
string color_band_A = ResistanceColorCode.ValueToString(ResistanceColorCode.ColorValueCode.Brown);
string color_band_B = ResistanceColorCode.ValueToString(ResistanceColorCode.ColorValueCode.Green);
string color_band_C = ResistanceColorCode.ValueToString(ResistanceColorCode.ColorValueCode.Red);
string color_band_D = ResistanceColorCode.ToleranceValueToString(ResistanceColorCode.ColorPercentToleranceCode.Silver);
double[] results = calculator.CalculateOhmValue(
color_band_A, color_band_B, color_band_C, color_band_D);
// Check value = 1500
double expectedVal = 1500;
Assert.IsTrue(results[0] == expectedVal);
// check tolerance = 10
double expectedTol = 10;
Assert.IsTrue(results[1] == expectedTol);
}
public ActionResult GetResistanceValue(string bandAColor, string bandBColor, string bandCColor, string bandDColor)
{
try
{
ColorCodes colorCodes = new ColorCodes();
// Call library method to calculcate the resistance value.
double ohmValue = _ohmCalculator.CalculateOhmValue(bandAColor, bandBColor, bandCColor, bandDColor);
var tolerance = colorCodes.Tolerance[bandDColor].Item2;
string resistance = Formatters.FormatResistance(ohmValue, tolerance);
/// return JSON response
return(Json(new { resistance = resistance }, JsonRequestBehavior.AllowGet));
}
catch (Exception ex)
{
Trace.TraceError(ex.Message);
throw ex;
}
}
private void buttonCalculate_Click(object sender, RoutedEventArgs e)
{
if ((comboBandA.SelectedItem == null) || (comboBandA.SelectedItem == null) || (comboBandA.SelectedItem == null))
{
MessageBox.Show("Please select colors for Bands A, B and C");
return;
}
string bandAColor = ((KeyValuePair <string, int>)comboBandA.SelectedItem).Key;
string bandBColor = ((KeyValuePair <string, int>)comboBandB.SelectedItem).Key;
string bandCColor = ((KeyValuePair <string, string>)comboBandC.SelectedItem).Key;
string bandDColor = ((KeyValuePair <string, double>)comboBandD.SelectedItem).Key;
_ohmValue = _ohmValueCalculator.CalculateOhmValue(bandAColor, bandBColor, bandCColor, bandDColor);
double tolValue = ((KeyValuePair <string, double>)comboBandD.SelectedItem).Value;
string unitValue = ((OhmValueCalculator)_ohmValueCalculator).UnitValue;
textBoxOhmValue.Text = string.Format("{0} {1}. Tolerance: +/- {2}. ", (((KeyValuePair <string, string>)comboBandC.SelectedItem).Value.Contains(".")) ? ((OhmValueCalculator)_ohmValueCalculator).ActualValue:_ohmValue,
(string.IsNullOrEmpty(unitValue)? "ohms" : unitValue + " ohms"), tolValue);
}
public void MinLimitTest()
{
var val = ohmValueCalculator.CalculateOhmValue("Black", "Black", "Black", "Black");
Assert.AreEqual(0, val);
}
public void MinLimitTest()
{
var result = ObjOhmValueCalculator.CalculateOhmValue("BK", "BK", "BK", "BK");
Assert.AreEqual(0, result);
}
public void CalculateOhmValueTest()
{
Assert.AreEqual(calculator.CalculateOhmValue("YE", "VT", "RD"), 4700);
}
public async Task <OhmValueResponse> CalculateOhmValue([FromBody] InputColorCodesModel inputColorCodes)
{
return(await _ohmValueCalculator.CalculateOhmValue(inputColorCodes.BandAColor, inputColorCodes.BandBColor,
inputColorCodes.BandCColor, inputColorCodes.BandDColor));
}
public IActionResult Calculate(string bandAColor, string bandBColor, string bandCColor, string bandDColor
, [FromServices] IOhmValueCalculator fourBandResistorCalculator
, [FromServices] IFourColorCodeBandsViewModel fourColorCodeBandsViewModel) =>
Json(fourBandResistorCalculator.CalculateOhmValue(bandAColor, bandBColor, bandCColor, bandDColor)
.ToFormattedOhms(bandDColor, fourColorCodeBandsViewModel));
public IActionResult CalculateOhmValue(string bandAColor, string bandBColor, string bandCColor, string bandDColor)
{
return(ProcessRequest(() => {
return Ok(_calculator.CalculateOhmValue(bandAColor, bandBColor, bandCColor, bandDColor));
}));
}
