Commit 9904413f: initial commit

AvailabilityExtensionsTest.cs

+58

/UnitTest/AvailabilityExtensionsTest.cs

View

using Infsoft.WPE.App.Shared.Utils;

using Infsoft.WPE.App.Shared.Utils.Models;

using NUnit.Framework;

namespace UnitTest

{

internal class AvailabilityExtensionsTest

{

[TestCase(null, Availability.None)]

[TestCase(true, Availability.Available)]

[TestCase(false, Availability.Busy)]

public void BoolParsingTest(bool? input, Availability expected)

{

// Arrange

// Act

var availability = input.GetAvailability();

// Assert

Assert.That(availability, Is.EqualTo(expected));

}

[TestCase(null, Availability.None)]

[TestCase("Available", Availability.Available)]

[TestCase("BUSY", Availability.Busy)]

[TestCase("OfflINE", Availability.Offline)]

[TestCase("BeRightBack", Availability.BeRightBack)]

[TestCase("AwaY", Availability.Away)]

[TestCase("DoNotDisturb", Availability.DoNotDisturb)]

[TestCase("invalid", Availability.None)]

[TestCase("", Availability.None)]

public void StringParsingTest(string input, Availability expected)

{

// Arrange

// Act

var availability = input.GetAvailability();

// Assert

Assert.That(availability, Is.EqualTo(expected));

}

[TestCase(Availability.None, Availability.Available, Availability.Available)]

[TestCase(Availability.Busy, Availability.Available, Availability.Busy)]

[TestCase(Availability.DoNotDisturb, Availability.None, Availability.DoNotDisturb)]

public void MergeAvailabilityTest(Availability one, Availability two, Availability expected)

{

// Arrange

// Act

var availability = one.MergeAvailability(two);

// Assert

Assert.That(availability, Is.EqualTo(expected));

}

ColorExtensionsTest.cs

+68

/UnitTest/ColorExtensionsTest.cs

View

using Infsoft.WPE.App.Shared.Utils;

using Infsoft.WPE.App.Shared.Utils.Models;

using NUnit.Framework;

namespace UnitTest

{

public class ColorExtensionsTest

{

[TestCase(StateColor.Red, "#D80000")]

[TestCase(StateColor.Green, "#1ABA00")]

[TestCase(StateColor.Yellow, "#FFB115")]

[TestCase(StateColor.Blue, "#808080")]

[TestCase(StateColor.Gray, "#808080")]

public void StatusColorTest(StateColor colorIn, string expectedColor)

{

// Arrange

// Act

var color = colorIn.GetStatusColor();

// Assert

Assert.That(color, Is.EqualTo(expectedColor));

}

[TestCase(Availability.None, "#D80000")]

[TestCase(Availability.Busy, "#D80000")]

[TestCase(Availability.DoNotDisturb, "#D80000")]

[TestCase(Availability.Available, "#1ABA00")]

[TestCase(Availability.BeRightBack, "#FDB913")]

[TestCase(Availability.Away, "#FDB913")]

[TestCase(Availability.Offline, "#808080")]

[TestCase(Availability.None, "#D80000")]

public void StatusColorAvailabilityTest(Availability availability, string expectedColor)

{

// Arrange

// Act

var color = availability.GetStatusColor();

// Assert

Assert.That(color, Is.EqualTo(expectedColor));

}

[TestCase("#FF0000", "255, 0, 0")]

[TestCase("#00FF00", "0, 255, 0")]

[TestCase("#0000FF", "0, 0, 255")]

[TestCase("#FFFFFF", "255, 255, 255")]

[TestCase("#000000", "0, 0, 0")]

[TestCase("#808080", "128, 128, 128")]

[TestCase("#D80000", "216, 0, 0")]

[TestCase("#1ABA00", "26, 186, 0")]

[TestCase("#FDB913", "253, 185, 19")]

[TestCase("invalid", "0, 0, 0")]

[TestCase("#invalid", "0, 0, 0")]

[TestCase("#DRTEDG", "0, 0, 0")]

[TestCase(null, "0, 0, 0")]

public void HexToRGBTest(string hex, string expectedRGB)

{

// Arrange

// Act

var rgb = hex.HexToRgb();

// Assert

Assert.That(rgb, Is.EqualTo(expectedRGB));

}

DateTimeExtensionsTest.cs

+186

/UnitTest/DateTimeExtensionsTest.cs

View

using Infsoft.WPE.App.Shared.Utils;

using NUnit.Framework;

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

namespace UnitTest

{

internal class DateTimeExtensionsTest

{

[TestCase(2023, 1, 1, 0, 0, 0, 1672531200)]

[TestCase(2023, 10, 20, 0, 0, 0, 1697760000)]

[TestCase(2023, 10, 20, 0, 1, 1, 1697760061)]

public void TestIntervalSince1970(int year, int month, int day, int hour, int minute, int second, double expected)

{

// Arrange

var dt = new DateTime(year, month, day, hour, minute, second);

// Act

var elapsed = dt.GetTimeIntervalSince1970();

// Assert

Assert.That(elapsed, Is.EqualTo(expected));

}

[TestCase(2023, 1, 1, 0, 0, 0, "20230101")]

[TestCase(2023, 10, 20, 0, 0, 0, "20231020")]

[TestCase(2023, 10, 20, 0, 1, 1, "20231020")]

[TestCase(2023, 10, 20, 1, 1, 1, "20231020")]

public void TestDayID(int year, int month, int day, int hour, int minute, int second, string expected)

{

// Arrange

var dt = new DateTime(year, month, day, hour, minute, second);

// Act

var dayID = dt.ToDayID();

// Assert

Assert.That(dayID, Is.EqualTo(expected));

}

[TestCase(2023, 1, 1, 0, 0, 0, "2023010100")]

[TestCase(2023, 10, 20, 0, 0, 0, "2023102000")]

[TestCase(2023, 10, 20, 0, 1, 1, "2023102000")]

[TestCase(2023, 10, 20, 1, 1, 1, "2023102001")]

public void TestHourID(int year, int month, int day, int hour, int minute, int second, string expected)

{

// Arrange

var dt = new DateTime(year, month, day, hour, minute, second);

// Act

var hourID = dt.ToHourID();

// Assert

Assert.That(hourID, Is.EqualTo(expected));

}

[TestCase(1672527600, 2023, 1, 1, 0, 0, 0)]

[TestCase(1672531261, 2023, 1, 1, 1, 1, 1)]

[TestCase(1697752800, 2023, 10, 20, 0, 0, 0)]

public void TestLocalDatetimeFromUnix(double unixTimestamp, int year, int month, int day, int hour, int minute, int second)

{

// Arrange

var expected = new DateTime(year, month, day, hour, minute, second);

// Act

var dt = unixTimestamp.ToLocalDT();

// Assert

Assert.That(dt, Is.EqualTo(expected));

Assert.That(dt.Kind, Is.EqualTo(DateTimeKind.Local));

}

[TestCase(1672527600, 2022, 12, 31, 23, 0, 0)]

[TestCase(1672531261, 2023, 1, 1, 0, 1, 1)]

[TestCase(1697752800, 2023, 10, 19, 22, 0, 0)]

public void TestDatetimeFromUnix(double unixTimestamp, int year, int month, int day, int hour, int minute, int second)

{

// Arrange

var expected = new DateTime(year, month, day, hour, minute, second);

// Act

var dt = unixTimestamp.ToDT();

// Assert

Assert.That(dt, Is.EqualTo(expected));

Assert.That(dt.Kind, Is.EqualTo(DateTimeKind.Utc));

}

[TestCase(1696401757, 8700)]

[TestCase(1672531261, 1016)]

public void TestTimeDouble(double unixTimestamp, int expected)

{

// Arrange

// Act

var time = unixTimestamp.ToTimeDouble();

// Assert

Assert.That((int) (time * 1000), Is.EqualTo(expected));

}

[TestCase(2022, 12, 31, 23, 0, 0, 1672527600)]

[TestCase(2023, 1, 1, 0, 1, 1, 1672531261)]

[TestCase(2023, 10, 19, 22, 0, 0, 1697752800)]

public void TestUtcUnixTimestamp(int year, int month, int day, int hour, int minute, int second, double expected)

{

// Arrange

var dt = new DateTime(year, month, day, hour, minute, second, DateTimeKind.Utc);

// Act

var unix = dt.ToUtcTimeStamp();

// Assert

Assert.That(unix, Is.EqualTo(expected));

}

[TestCase(2022, 12, 31, 23, 0, 0, 2)]

[TestCase(2023, 1, 1, 0, 1, 1, 2)]

[TestCase(2023, 10, 19, 22, 0, 0, 3)]

[TestCase(-1, 0, 0, 0, 0, 0, 3)]

public void TestUtcToLocal(int year, int month, int day, int hour, int minute, int second, int offset)

{

// Arrange

DateTime? input = year < 0 ? null : new DateTime(year, month, day, hour, minute, second);

var expected = year < 0 ? new() : new DateTime(year, month, day, hour, minute, second).AddHours(offset);

// Act

var dt = input.UtcToLocal(offset);

// Assert

Assert.That(dt, Is.EqualTo(expected));

}

[TestCase(2022, 12, 31, 23, 0, 0, 2024, 1, 1)]

[TestCase(2023, 1, 1, 0, 1, 1, 2020, 1, 1)]

[TestCase(2023, 10, 19, 22, 0, 0, 2022, 5, 4)]

public void TestChangeDate(int year, int month, int day, int hour, int minute, int second, int newYear, int newMonth, int newDay)

{

// Arrange

var dt = new DateTime(year, month, day, hour, minute, second);

var dt2 = new DateTime(newYear, newMonth, newDay);

// Act

var changed = dt.ChangeDate(dt2);

// Assert

Assert.Multiple(() =>

{

Assert.That(changed.Year, Is.EqualTo(newYear));

Assert.That(changed.Month, Is.EqualTo(newMonth));

Assert.That(changed.Day, Is.EqualTo(newDay));

Assert.That(changed.Hour, Is.EqualTo(hour));

Assert.That(changed.Minute, Is.EqualTo(minute));

Assert.That(changed.Second, Is.EqualTo(second));

});

}

[TestCase(2022, 12, 31, 23, 0, 0, 13, 34, 58)]

[TestCase(2023, 1, 1, 0, 1, 1, 4, 22, 43)]

[TestCase(2023, 10, 19, 22, 0, 0, 8, 46, 0)]

public void TestChangeTime(int year, int month, int day, int hour, int minute, int second, int newHour, int newMinute, int newSecond)

{

// Arrange

var dt = new DateTime(year, month, day, hour, minute, second);

var dt2 = new DateTime(1, 1, 1, newHour, newMinute, newSecond);

// Act

var changed = dt.ChangeTime(dt2);

// Assert

Assert.Multiple(() =>

{

Assert.That(changed.Year, Is.EqualTo(year));

Assert.That(changed.Month, Is.EqualTo(month));

Assert.That(changed.Day, Is.EqualTo(day));

Assert.That(changed.Hour, Is.EqualTo(newHour));

Assert.That(changed.Minute, Is.EqualTo(newMinute));

Assert.That(changed.Second, Is.EqualTo(newSecond));

});

}

StringExtensionsTest.cs

/UnitTest/StringExtensionsTest.cs

View

TemperatureExtensionsTest.cs

+49

/UnitTest/TemperatureExtensionsTest.cs

View

using Infsoft.WPE.App.Shared.Utils;

using Infsoft.WPE.App.Shared.Utils.Models;

using NUnit.Framework;

using System.Globalization;

namespace UnitTest

{

internal class TemperatureExtensionsTest

{

[TestCase(null, TemperatureUnit.Celsius)]

[TestCase("de-de", TemperatureUnit.Celsius)]

[TestCase("en-us", TemperatureUnit.Fahrenheit)]

[TestCase("en-US", TemperatureUnit.Fahrenheit)]

[TestCase("fr", TemperatureUnit.Celsius)]

[TestCase("invariant", TemperatureUnit.Kelvin)]

public void TestUnitForCulture(string cultureName, TemperatureUnit expected)

{

// Arrange

var culture = cultureName == null ? null : cultureName == "invariant" ? CultureInfo.InvariantCulture : CultureInfo.CreateSpecificCulture(cultureName);

// Act

var unit = culture.GetUnit();

// Assert

Assert.That(unit, Is.EqualTo(expected));

}

[TestCase(null, -12.4, "-12,4 °C")]

[TestCase("en-gb", -12.4, "-12.4 °C")]

[TestCase("en-us", -12.4, "9.68 °F")]

[TestCase("en-us", -22.4, "-8.32 °F")]

[TestCase("invariant", -12.4, "260.75 °K")]

[TestCase(null, 30.1, "30,1 °C")]

[TestCase("en-us", 30.1, "86.18 °F")]

[TestCase("invariant", 30.1, "303.25 °K")]

public void TestConversion(string cultureName, double celsiusTemp, string expected)

{

// Arrange

var culture = cultureName == null ? null : cultureName == "invariant" ? CultureInfo.InvariantCulture : CultureInfo.CreateSpecificCulture(cultureName);

// Act

var converted = celsiusTemp.GetLocalizedRepresentation(culture);

// Assert

Assert.That(converted, Is.EqualTo(expected));

}

UnitTest.csproj

+25

/UnitTest/UnitTest.csproj

View

<ImplicitUsings>enable</ImplicitUsings>

<Nullable>enable</Nullable>

<IsPackable>false</IsPackable>

</PropertyGroup>

</ItemGroup>

</ItemGroup>

</Project>

Availability.cs

/WPE.App.Shared.Utils/Models/Availability.cs

View

StateColor.cs

/WPE.App.Shared.Utils/Models/StateColor.cs

View

TemperatureUnit.cs

/WPE.App.Shared.Utils/Models/TemperatureUnit.cs

View

AvailabilityExtensions.cs

/WPE.App.Shared.Utils/AvailabilityExtensions.cs

View

ColorExtensions.cs

/WPE.App.Shared.Utils/ColorExtensions.cs

View

DateTimeExtensions.cs

/WPE.App.Shared.Utils/DateTimeExtensions.cs

View

StringExtensions.cs

/WPE.App.Shared.Utils/StringExtensions.cs

View

TemperatureExtensions.cs

/WPE.App.Shared.Utils/TemperatureExtensions.cs

View

WPE.App.Shared.Utils.csproj

/WPE.App.Shared.Utils/WPE.App.Shared.Utils.csproj

View

.gitignore

/.gitignore

View

azure-pipelines.yml

/azure-pipelines.yml

View

LICENSE

/LICENSE

View

ReadMe.md

/ReadMe.md

View

WPE.App.Shared.Utils.sln

/WPE.App.Shared.Utils.sln

View



	UnitTest
	AvailabilityExtensionsTest.cs +
	ColorExtensionsTest.cs +
	DateTimeExtensionsTest.cs +
	StringExtensionsTest.cs +
	TemperatureExtensionsTest.cs +
	UnitTest.csproj +
	WPE.App.Shared.Utils
	Models
	Availability.cs +
	StateColor.cs +
	TemperatureUnit.cs +
	AvailabilityExtensions.cs +
	ColorExtensions.cs +
	DateTimeExtensions.cs +
	StringExtensions.cs +
	TemperatureExtensions.cs +
	WPE.App.Shared.Utils.csproj +
	.gitignore +
	azure-pipelines.yml +
	LICENSE +
	ReadMe.md +
	WPE.App.Shared.Utils.sln +