public void ToString_Default_Culture_EN()
{
var p = new P(2.5, 9.321);
string expectedStringEN = "2.500 m × 9.321 m × 0.100 m";
Assert.AreEqual(expectedStringEN, p.ToString());
}
public void Equals_ReturnsFalse(double a1, double a2, double b1, double b2, double c1, double c2, bool expectedResult)
{
var p1 = new P(a1, b1, c1);
var p2 = new P(a2, b2, c2);
Assert.AreEqual(expectedResult, p1.Equals(p2));
}
public void Equals_ReturnsTrue(double a1, double a2, double b1, double b2, double c1, double c2)
{
var p1 = new P(a1, b1, c1);
var p2 = new P(a2, b2, c2);
Assert.IsTrue(p1.Equals(p2));
}
1.0, 2.543, 3.1)] // dla metrów liczą się 3 miejsca po przecinku
public void Constructor_3params_DefaultMeters(double a, double b, double c,
double expectedA, double expectedB, double expectedC)
{
P p = new P(a, b, c);
AssertPudelko(p, expectedA, expectedB, expectedC);
}
public void NonEqualSignOverload_ChecksIfEquals(double a1, double a2, double b1, double b2, double c1, double c2, bool expectedResult)
{
var p1 = new P(a1, b1, c1);
var p2 = new P(a2, b2, c2);
Assert.AreEqual(expectedResult, p1 != p2);
}
1.0, 0.255, 0.031)] // dla centymertów liczy się tylko 1 miejsce po przecinku
public void Constructor_3params_InCentimeters(double a, double b, double c,
double expectedA, double expectedB, double expectedC)
{
P p = new P(a: a, b: b, c: c, unit: UnitOfMeasure.centimeter);
AssertPudelko(p, expectedA, expectedB, expectedC);
}
0.1, 0.025, 0.003)] // dla milimetrów nie liczą się miejsca po przecinku
public void Constructor_3params_InMilimeters(double a, double b, double c,
double expectedA, double expectedB, double expectedC)
{
P p = new P(unit: UnitOfMeasure.milimeter, a: a, b: b, c: c);
AssertPudelko(p, expectedA, expectedB, expectedC);
}
public void Indexer_ReadFrom()
{
var p = new P(1, 2.1, 3.231);
Assert.AreEqual(p.A, p[0]);
Assert.AreEqual(p.B, p[1]);
Assert.AreEqual(p.C, p[2]);
}
public void Constructor_1param_InMeters(double a)
{
P p = new P(a);
Assert.AreEqual(a, p.A);
Assert.AreEqual(0.1, p.B);
Assert.AreEqual(0.1, p.C);
}
public void Constructor_Default()
{
Pudelko.Lib.Pudelko p = new P();
Assert.AreEqual(defaultSize, p.A, delta: accuracy);
Assert.AreEqual(defaultSize, p.B, delta: accuracy);
Assert.AreEqual(defaultSize, p.C, delta: accuracy);
}
static void Main(string[] args)
{
var boxes = new List <P>();
var r = new Random();
for (int i = 0; i < 5; i++)
{
var p = new P(r.NextDouble() * 10, r.NextDouble() * 10, r.NextDouble() * 10);
Console.WriteLine($"Wymiary: {p.ToString()} Objetosc: {p.Objetosc} Pole powierzchni: {p.Pole}");
boxes.Add(p);
}
Console.WriteLine();
boxes.Sort((p1, p2) =>
{
if (p1.Objetosc < p2.Objetosc)
{
return(-1);
}
if (p1.Objetosc > p2.Objetosc)
{
return(1);
}
if (p1.Pole < p2.Pole)
{
return(-1);
}
if (p1.Pole > p2.Pole)
{
return(1);
}
if (p1.A + p1.B + p1.C < p2.A + p2.B + p2.C)
{
return(-1);
}
if (p1.A + p1.B + p1.C > p2.A + p2.B + p2.C)
{
return(1);
}
return(0);
});
foreach (var p in boxes)
{
Console.WriteLine($"Wymiary: {p.ToString()} Objetosc: {p.Objetosc} Pole powierzchni: {p.Pole}");
}
Console.WriteLine();
Console.WriteLine(P.Parse("5.2 m x 3.6 m x 2.5 m"));
var pudelko = new P(1, 2, 4);
Console.WriteLine(pudelko.Objetosc);
Console.WriteLine(pudelko.Kompresuj());
}
public void ImplicitConversion_FromAalueTuple_As_Pudelko_InMilimeters()
{
var(a, b, c) = (2500, 9321, 100); // in milimeters, ValueTuple
P p = (a, b, c);
Assert.AreEqual((int)(p.A * 1000), a);
Assert.AreEqual((int)(p.B * 1000), b);
Assert.AreEqual((int)(p.C * 1000), c);
}
public void ExplicitConversion_ToDoubleArray_AsMeters()
{
var p = new P(1, 2.1, 3.231);
double[] tab = (double[])p;
Assert.AreEqual(3, tab.Length);
Assert.AreEqual(p.A, tab[0]);
Assert.AreEqual(p.B, tab[1]);
Assert.AreEqual(p.C, tab[2]);
}
public void ForEach_Test()
{
var p = new P(1, 2.1, 3.231);
var tab = new[] { p.A, p.B, p.C };
int i = 0;
foreach (double x in p)
{
Assert.AreEqual(x, tab[i]);
i++;
}
}
public void ToString_Formattable_Culture_EN(string format, double a, double b, double c, string expectedStringRepresentation)
{
var p = new P(a, b, c, unit: UnitOfMeasure.meter);
Assert.AreEqual(expectedStringRepresentation, p.ToString(format));
}
public void Constructor_2params_InCentimeters(double a, double b, double expectedA, double expectedB)
{
P p = new P(unit: UnitOfMeasure.centimeter, a: a, b: b);
AssertPudelko(p, expectedA, expectedB, expectedC: 0.1);
}
public void Constructor_1param_InMilimeters(double a, double expectedA)
{
P p = new P(unit: UnitOfMeasure.milimeter, a: a);
AssertPudelko(p, expectedA, expectedB: 0.1, expectedC: 0.1);
}
private static double accuracy = 0.001; //dokładność 3 miejsca po przecinku
private void AssertPudelko(P p, double expectedA, double expectedB, double expectedC)
{
Assert.AreEqual(expectedA, p.A, delta: accuracy);
Assert.AreEqual(expectedB, p.B, delta: accuracy);
Assert.AreEqual(expectedC, p.C, delta: accuracy);
}
public void Constructor_2params_DefaultMeters_ArgumentOutOfRangeException(double a, double b)
{
P p = new P(a, b);
}
public void Constructor_3params_InMiliimeters_ArgumentOutOfRangeException(double a, double b, double c)
{
P p = new P(a, b, c, unit: UnitOfMeasure.milimeter);
}
public void Objetosc_Returns_Volume(double a, double b, double c, double expectedVolume)
{
var p = new P(a, b, c);
Assert.AreEqual(expectedVolume, p.Objetosc);
}
public void Constructor_2params_InCentimeters_ArgumentOutOfRangeException(double a, double b)
{
P p = new P(a, b, unit: UnitOfMeasure.centimeter);
}
public void Pole_ReturnsArea(double a, double b, double c, double expectedArea)
{
var p = new P(a, b, c);
Assert.AreEqual(expectedArea, p.Pole);
}
public void ToString_Formattable_WrongFormat_FormatException()
{
var p = new P(1);
var stringformatedrepreentation = p.ToString("wrong code");
}
public void Constructor_2params_DefaultMeters(double a, double b, double expectedA, double expectedB)
{
P p = new P(a, b);
AssertPudelko(p, expectedA, expectedB, expectedC: 0.1);
}
public void Constructor_1param_DefaultMeters_ArgumentOutOfRangeException(double a)
{
P p = new P(a);
}
public void Constructor_1param_InMilimeters_ArgumentOutOfRangeException(double a)
{
P p = new P(a, unit: UnitOfMeasure.milimeter);
}
