//Parametri prosleđeni u okviru [TestCase] dekoratora prihvataju se u potpisu same metode
//U ovom primeru, parametar sa vrednošću 4.5351473922902494d biće smešten u promenljivu expectedValue, dok će parametar sa vrednošću 10 biti smešten u promenljivu input
//Suština parametrizovanih testova je korišćenje tih parametara u daljem telu testne metode
//S obzirom na to da ova testna metoda void, ovaj tip parametrizovanih testova je bez povratne vrednosti
public void Convert_Success_Params(int input, double expectedValue)
{
MassConverter mass = new MassConverter();
double result = mass.Convert(input); //Umesto prosleđenog broja (kao u prvom testu u okviru ove klase), prosleđuje se promenljiva dobijena kroz potpis metode
Assert.AreEqual(expectedValue, result); //Koriščenje klase Assert i neke od njenih metoda jer je reč o parametrizovanim testovima bez povratne vrednosti
}
public void Convert_Success()
{
MassConverter mass = new MassConverter(); //Za testiranje metode Convert iz klase MassConvertor, potreban je objekat te klase s obzirom na to da metoda nije statička
double result = mass.Convert(10); //Metodi Convert prosleđuje se proizvoljan broj (u ovom primeru će biti broj 10)
Assert.AreEqual(4.5351473922902494d, result); //Klasa Assert omogućava pozivanje velikog broja statičkih metoda koje služe za testiranje. Metoda AreEqual prima dva parametra: očekivanu vrednost i stvarnu vrednost (dobijenu pozivom funkcije Convert).
}
[TestCase(0, 0)] // jos jedan test case omogucava nam da pozivamo dva razlicita testa nad istom jednom metodom!
public void Convert_TestSuccessParams(int input, double result)
{
MassConverter mass = new MassConverter();
double value = mass.Convert(input);
Assert.AreEqual(result, value);
}
// Testovi ce biti metode koje testiraju metode iz samog core projekta
// najosnovniji testovi ce biti bez return statmenta tj bice void
// naziv testa treba da bude jasan za onoga koji nije pisao program
public void Convert_TestSuccess()
{
MassConverter mass = new MassConverter();
double result = mass.Convert(10);
Assert.AreEqual(4.5351473922902494d, result);
}
public void Convert_ExpectedFormatException()
{
MassConverter mass = new MassConverter();
//Metoda Throws klase Assert, zahteva da se definiše tip Exceptiona koji se očekuje. U slučaju ovog primera, to je System.Format Exception.
//Throws metoda sastoji se iz dva dela: preambule - koja u ovom primeru predstavlja prazne zagrade pre strelice (=>) i u preambuli se mogu pozivati metode ili setovati promenljive koje će kasnije uticati na samo hvatanje Exceptiona
//Drugi deo Throws metode (sa desne strane strelice - =>) obuhvata poziv metode koja treba da podigne Exception. U ovom primeru, to je poziv metode Convert i prosleđivanje slova kao inputa metode
Assert.Throws <System.FormatException>(() => mass.Convert(double.Parse("s")));
}
public void MassConverter_Convert()
{
decimal result = MassConverter.Convert(MassUnit.Ounce, MassUnit.Pound, 12);
Assert.AreEqual(0.75m, result);
result = MassConverter.Convert(MassUnit.Pound, MassUnit.Ounce, 0.75m);
Assert.AreEqual(12m, result);
result = MassConverter.Convert(MassUnit.Kilogram, MassUnit.Pound, 1);
Assert.AreEqual(2.2046226218487758072297380135m, result);
result = MassConverter.Convert(MassUnit.Ton, MassUnit.Pound, 1);
Assert.AreEqual(2_000m, result);
}
/// <summary>Convert the numbers to the new unit.</summary>
/// <param name="numbers">The numbers used in the convertion.</param>
/// <returns>The result of the convertion execution.</returns>
/// <exception cref="ArgumentNullException">When numbers is null.</exception>
/// <exception cref="ArgumentException">When the length of numbers do not equal <see cref="ArgumentCount"/>.</exception>
public double Convert(double[] numbers)
{
base.Validate(numbers);
double fromValue = numbers[0];
switch (current.UnitType)
{
case UnitType.Length:
return(LengthConverter.Convert(
(LengthUnit)current.FromUnit,
(LengthUnit)current.ToUnit,
fromValue));
case UnitType.Mass:
return(MassConverter.Convert(
(MassUnit)current.FromUnit,
(MassUnit)current.ToUnit,
fromValue));
case UnitType.Speed:
return(SpeedConverter.Convert(
(SpeedUnit)current.FromUnit,
(SpeedUnit)current.ToUnit,
fromValue));
case UnitType.Temperature:
return(TemperatureConverter.Convert(
(TemperatureUnit)current.FromUnit,
(TemperatureUnit)current.ToUnit,
fromValue));
case UnitType.Time:
return(TimeConverter.Convert(
(TimeUnit)current.FromUnit,
(TimeUnit)current.ToUnit,
fromValue));
case UnitType.Volume:
return(VolumeConverter.Convert(
(VolumeUnit)current.FromUnit,
(VolumeUnit)current.ToUnit,
fromValue));
default:
throw new ArgumentOutOfRangeException("numbers");
}
}
public void Convert()
{
double result = MassConverter.Convert(
MassUnit.Ounce, MassUnit.Pound, 12);
Assert.AreEqual(0.75, result);
result = MassConverter.Convert(
MassUnit.Pound, MassUnit.Ounce, 0.75);
Assert.AreEqual(12, result);
result = MassConverter.Convert(
MassUnit.Kilogram, MassUnit.Pound, 1);
Assert.AreEqual(2.2046226218487757d, result);
result = MassConverter.Convert(
MassUnit.Ton, MassUnit.Pound, 1);
Assert.AreEqual(2000d, result);
}
/// <summary>
/// Calculate the Intensity of Gravity at the Surface of the object
/// I = (G*M)/(r^2)
/// </summary>
/// <param name="massOfObject">The mass of the object</param>
/// <param name="radiusOfObject">The radius of the object</param>
/// <returns></returns>
public static ExponentialNotation IntensityAtSurface(ExponentialNotation massOfObject, ExponentialNotation radiusOfObject)
{
ExponentialNotation intensity = null;
//Calculate the numerator: Graviational Constant * Mass (in kg)
ExponentialNotation massOfObjectInKilograms = MassConverter.Convert(massOfObject, SIUnit.Kilograms);
intensity = GravitationalConstantOfTheUniverse * massOfObjectInKilograms;
//Square the radius
ExponentialNotation radiusOfObjectInMeters = DistanceConverter.Convert(radiusOfObject, SIUnit.Meters);
radiusOfObjectInMeters = radiusOfObjectInMeters * radiusOfObjectInMeters;
//Divide the numerator by the radius squared
intensity = intensity / radiusOfObjectInMeters;
intensity.MeasurementUnits = SIUnit.MetersCubed_PerSecondsSquared_PerKilograms;
//I = (G*M)/(r^2)
return(intensity);
}
/// <summary>Convert the numbers to the new unit.</summary>
/// <param name="numbers">The numbers used in the conversion.</param>
/// <returns>The result of the conversion execution.</returns>
/// <exception cref="ArgumentNullException">When numbers is null.</exception>
/// <exception cref="ArgumentException">When the length of numbers do not equal <see cref="ArgumentCount"/>.</exception>
public PreciseNumber Evaluate(PreciseNumber[] operands)
{
((IExpression)this).Validate(operands);
PreciseNumber fromValue = operands[0];
if (!fromValue.HasValue)
{
return(fromValue);
}
return(_current.UnitType switch
{
UnitType.Length => new PreciseNumber(LengthConverter.Convert((LengthUnit)_current.FromUnit, (LengthUnit)_current.ToUnit, fromValue.Value)),
UnitType.Mass => new PreciseNumber(MassConverter.Convert((MassUnit)_current.FromUnit, (MassUnit)_current.ToUnit, fromValue.Value)),
UnitType.Speed => new PreciseNumber(SpeedConverter.Convert((SpeedUnit)_current.FromUnit, (SpeedUnit)_current.ToUnit, fromValue.Value)),
UnitType.Temperature => new PreciseNumber(TemperatureConverter.Convert((TemperatureUnit)_current.FromUnit, (TemperatureUnit)_current.ToUnit, fromValue.Value)),
UnitType.Time => new PreciseNumber(TimeConverter.Convert((TimeUnit)_current.FromUnit, (TimeUnit)_current.ToUnit, fromValue.Value)),
UnitType.Volume => new PreciseNumber(VolumeConverter.Convert((VolumeUnit)_current.FromUnit, (VolumeUnit)_current.ToUnit, fromValue.Value)),
_ => throw new ArgumentOutOfRangeException(nameof(operands)),
});
public void ConvertToSame()
{
var value = conv.Convert(12, MassUnits.Kilograms, MassUnits.Kilograms);
Assert.Equal(12, value);
}
public double Convert_Success_ParamsWithReturnStatement(int input)
{
MassConverter mass = new MassConverter();
return(mass.Convert(input)); //Povratna vrednost koja mora biti identična vrednosti u okviru property-a ExpectedResult da bi test prošao
}
private void Convert(double value)
{
switch (SelectedOp)
{
case "Length":
{
LengthunitConverter unit = new LengthunitConverter();
Result = unit.Convert(value, SelectedFrom, SelectedTo).ToString();
break;
}
case "Mass and Weight":
{
MassConverter unit = new MassConverter();
Result = unit.Convert(value, SelectedFrom, SelectedTo).ToString();
break;
}
case "Power":
{
PowerConverter unit = new PowerConverter();
Result = unit.Convert(value, SelectedFrom, SelectedTo).ToString();
break;
}
case "Pressure":
{
PressureConverter unit = new PressureConverter();
Result = unit.Convert(value, SelectedFrom, SelectedTo).ToString();
break;
}
case "Energy":
{
EnergyConveter unit = new EnergyConveter();
Result = unit.Convert(value, SelectedFrom, SelectedTo).ToString();
break;
}
case "Temperature":
{
TemperatureConverter unit = new TemperatureConverter();
Result = unit.Convert(value, SelectedFrom, SelectedTo).ToString();
break;
}
case "Volume":
{
VolumeConverter unit = new VolumeConverter();
Result = unit.Convert(value, SelectedFrom, SelectedTo).ToString();
break;
}
case "Angle":
{
AngleConverter unit = new AngleConverter();
Result = unit.Convert(value, SelectedFrom, SelectedTo).ToString();
break;
}
case "Area":
{
AreaConverter unit = new AreaConverter();
Result = unit.Convert(value, SelectedFrom, SelectedTo).ToString();
break;
}
case "Speed":
{
SpeedConverter unit = new SpeedConverter();
Result = unit.Convert(value, SelectedFrom, SelectedTo).ToString();
break;
}
case "Time":
{
TimeunitsConverter unit = new TimeunitsConverter();
Result = unit.Convert(value, SelectedFrom, SelectedTo).ToString();
break;
}
}
}
[TestCase(0, 0)] // opet za jednu metodu moze isto vise testova
public double Convert_TestSuccessParamsWithReturnStatment(int input)
{
MassConverter mass = new MassConverter();
return(mass.Convert(input));
}
public void Convert_CatchException()
{
MassConverter mass = new MassConverter();
Assert.Throws <System.FormatException>(() => mass.Convert(double.Parse(""))); // prvi deo metode preambula deo uslov koji sprecava omogucavnanje metode
} // primer passovanja nule ili range izvan double tipa