public override string ToString()
{
var converter = new EnumStringConverter <EncodeCompleteActionType>();
string actionDisplayString = converter.Convert(this.ActionType);
if (this.ActionType == EncodeCompleteActionType.EjectDisc)
{
actionDisplayString = string.Format(actionDisplayString, this.DriveLetter);
}
if (!this.ShowTriggerInDisplay)
{
return(actionDisplayString);
}
string displayFormat;
if (this.Trigger == EncodeCompleteTrigger.DoneWithQueue)
{
displayFormat = MainRes.WithQueueFormat;
}
else
{
displayFormat = MainRes.WithCurrentJobsFormat;
}
return(string.Format(CultureInfo.CurrentUICulture, displayFormat, actionDisplayString));
}
public void ReadKnownValuesTests()
{
// Arrange
var inputs = new Dictionary <string, TestEnum>
{
{ "\"with-enum-member\"", TestEnum.WithEnumMember },
{ "\"WITH-ENUM-MEMBER\"", TestEnum.WithEnumMember },
{ "\"With-Enum-Member\"", TestEnum.WithEnumMember },
{ "\"plain\"", TestEnum.Plain },
{ "\"PLAIN\"", TestEnum.Plain },
{ "\"Plain\"", TestEnum.Plain }
};
var factory = new EnumStringConverter();
// Act & Assert
foreach (var(json, expectedResult) in inputs)
{
var target = (JsonConverter <TestEnum>)factory.CreateConverter(typeof(TestEnum), new JsonSerializerOptions());
TestEnum?result = null;
var utf8JsonBytes = Encoding.UTF8.GetBytes(json);
var reader = new Utf8JsonReader(utf8JsonBytes, true, new JsonReaderState());
while (reader.Read())
{
result = target.Read(ref reader, typeof(TestEnum), new JsonSerializerOptions());
}
Assert.Equal(expectedResult, result);
}
}
private void WriteRow(IXLWorksheet sheet, Game game, int row)
{
var props = new CellValue[] {
new CellValue(game.Deck?.Name),
new CellValue(game.DeckVersion),
new CellValue(EnumStringConverter.ToTitleCase(game.PlayerClass)),
new CellValue(EnumStringConverter.ToTitleCase(game.Mode)),
new CellValue(EnumStringConverter.ToTitleCase(game.Format)),
new CellValue(game.Region),
new CellValue(game.Rank, XLCellValues.Number),
new CellValue(game.StartTime, XLCellValues.DateTime),
new CellValue(game.PlayerGotCoin ? "Yes" : "No"),
new CellValue(EnumStringConverter.ToTitleCase(game.OpponentClass)),
new CellValue(game.OpponentName),
new CellValue(game.Turns, XLCellValues.Number),
new CellValue(game.Minutes, XLCellValues.Number),
new CellValue(EnumStringConverter.ToTitleCase(game.Result)),
new CellValue(game.WasConceded ? "Yes" : "No"),
new CellValue(game.Note?.Text),
new CellValue(game.Note?.Archetype),
new CellValue(game.Id),
};
for (var i = 0; i < props.Length; i++)
{
sheet.Cell(row, i + 1).Value = props[i].Value;
sheet.Cell(row, i + 1).SetDataType(props[i].Type);
}
}
public void WriteTests()
{
// Arrange
var inputs = new Dictionary <string, TestEnum>
{
{ "\"with-enum-member\"", TestEnum.WithEnumMember },
{ "\"Plain\"", TestEnum.Plain }
};
var factory = new EnumStringConverter();
var target = (JsonConverter <TestEnum>)factory.CreateConverter(typeof(TestEnum), new JsonSerializerOptions());
// Act & Assert
foreach (var(expectedResult, input) in inputs)
{
using var memoryStream = new MemoryStream();
var writer = new Utf8JsonWriter(memoryStream);
target.Write(writer, input, new JsonSerializerOptions());
writer.Flush();
memoryStream.Position = 0;
using var reader = new StreamReader(memoryStream);
var result = reader.ReadToEnd();
Assert.Equal(expectedResult, result);
}
}
public static bool TryParse <T>(string?s, out T value) where T : struct, Enum
{
if (!(s is null) && EnumValues <T> .StringToValue.TryGetValue(s, out value))
{
return(true);
}
return(EnumStringConverter.TryParse(s, out value));
}
public static string ToString <T>(T value) where T : struct, Enum
{
if (EnumValues <T> .ValueToString.TryGetValue(value, out string s))
{
return(s);
}
return(EnumStringConverter.ToString(value));
}
public void Convert_NullEnum_ReturnsStringEmpty()
{
var converter = new EnumStringConverter();
var text = converter.Convert(null);
Assert.Equal(string.Empty, text);
}
public void Convert_AttributeTextForEnum_ReturnsEnumValue()
{
var converter = new EnumStringConverter();
var enumValue = converter.Convert <TestEnum>("first entry");
Assert.Equal(TestEnum.FirstEntry, enumValue);
}
public void Convert_EnumValueWithAttribute_ReturnsAttributeText()
{
var converter = new EnumStringConverter();
var text = converter.Convert(TestEnum.FirstEntry);
Assert.Equal("first entry", text);
}
public void EnumStringConvertFromStringTest()
{
var convert = new EnumStringConverter();
Assert.AreEqual(TestEnums.Hello, convert.ConvertFromString("TestEnums.Hello", typeof(TestEnums)));
Assert.AreEqual(TestEnums.World, convert.ConvertFromString("World", typeof(TestEnums)));
Assert.AreEqual(TestEnums.Hello, convert.ConvertFromString("1", typeof(TestEnums)));
}
public void Convert_ElementWithoutAttributeButDefaultValue_ReturnDefault()
{
var converter = new EnumStringConverter();
var convertedValue = converter.Convert(TestEnum.ElementWithoutAttribute);
Assert.Equal("DefaultText", convertedValue);
}
public void Convert_EnumValueWithoutAttribute_ReturnsEnumFieldName()
{
var converter = new EnumStringConverter();
var text = converter.Convert(ConsoleColor.Gray);
Assert.Equal("Gray", text);
}
public void Convert_ElementWithoutAttributeAndNoDefaultValue_ReturnFieldName()
{
var converter = new EnumStringConverter();
var convertedValue = converter.Convert(TestEnumWithInt.Ok);
Assert.Equal(nameof(TestEnumWithInt.Ok), convertedValue);
}
public void Convert_TextForEnum_ReturnsEnumValue()
{
var converter = new EnumStringConverter();
var enumValue = converter.Convert <ConsoleColor>("Gray");
Assert.Equal(ConsoleColor.Gray, enumValue);
}
public void Convert_NoneExistentText_ReturnsDefaultEnumValue()
{
var converter = new EnumStringConverter();
var enumValue = converter.Convert <TestEnum>("testing");
Assert.Equal(TestEnum.None, enumValue);
}
public void Convert_AttributeTextForEnumWithCacheUsage_ReturnsEnumValue()
{
var converter = new EnumStringConverter();
var _ = converter.Convert <TestEnum>("first entry");
var secondEnumValue = converter.Convert <TestEnum>("first entry");
Assert.Equal(TestEnum.FirstEntry, secondEnumValue);
}
void PrepareComboBoxes()
{
PositionPrimary.DataSource = Enums.Positions;
PositionSecondary.DataSource = Enums.PositionsIncludingNone;
GradePrimary.DataSource = Enums.Grades;
GradeSecondary.DataSource = Enums.GradesIncludingNone;
preferredTeamSizesDataGridViewTextBoxColumn.DataSource = Enums.TeamSizes;
EnumStringConverter.AddAttributesToEnumsAndStructs();
}
public void CanConvertTests(Type requestedType, bool expectedResult)
{
// Arrange
var target = new EnumStringConverter();
// Act
var result = target.CanConvert(requestedType);
// Assert
Assert.Equal(expectedResult, result);
}
public override string ToString()
{
var converter = new EnumStringConverter <EncodeCompleteActionType>();
string displayString = converter.Convert(this.ActionType);
if (this.ActionType == EncodeCompleteActionType.EjectDisc)
{
displayString = string.Format(displayString, this.DriveLetter);
}
return(displayString);
}
/// <summary>
/// Copy Game into a GameStats object.
/// Will cause existing properties to be overwritten.
/// </summary>
public static void CopyTo(this Game from, GameStats to)
{
// dont't overwrite game ids with empty
if (from.Id != Guid.Empty)
{
to.GameId = from.Id;
}
if (from.Deck == null || from.Deck.Name == null)
{
to.DeckName = Deck.Empty.Name;
to.DeckId = Deck.Empty.Id;
}
else
{
to.DeckName = from.Deck.Name;
to.DeckId = from.Deck.Id;
}
if (from.DeckVersion != null)
{
to.PlayerDeckVersion = new SerializableVersion(
from.DeckVersion.Major, from.DeckVersion.Minor);
}
to.StartTime = from.StartTime;
// set end time based on duration
if (from.Minutes >= 0 && from.StartTime > DateTime.MinValue)
{
to.EndTime = from.StartTime.AddMinutes(from.Minutes);
}
else
{
to.EndTime = from.EndTime;
}
to.GameMode = Convert(from.Mode);
to.Format = Convert(from.Format);
to.Note = from.Note?.ToString();
to.OpponentHero = EnumStringConverter.ToTitleCase(from.OpponentClass);
to.OpponentName = from.OpponentName;
to.PlayerHero = EnumStringConverter.ToTitleCase(from.PlayerClass);
to.PlayerName = from.PlayerName;
to.Coin = from.PlayerGotCoin;
to.Rank = from.Rank;
to.Region = Convert(from.Region);
to.Result = Convert(from.Result);
to.Turns = from.Turns;
to.WasConceded = from.WasConceded;
}
static string GetControlForTeamSize(Day day, int matchIndex, HTMLmode mode)
{
Match match = day.matches[matchIndex];
if (mode != HTMLmode.FixMatches)
{
return(EnumStringConverter.NameOfTeamSize(match.Size));
}
string controls = string.Format(dropDownTeamSizeStart, matchIndex);
for (int size = Team.MinSize; size <= Team.MaxSize; size++)
{
controls += string.Format(match.Size == size ? dropDownTeamSizeOptionSelected : dropDownTeamSizeOptionNotSelected, size, EnumStringConverter.NameOfTeamSize(size));
}
controls += dropDownTeamSizeEnd;
return(controls);
}
public void ReadUnknownValuesTests()
{
// Arrange
var factory = new EnumStringConverter();
var target = (JsonConverter <TestEnum>)factory.CreateConverter(typeof(TestEnum), new JsonSerializerOptions());
// Act & Assert
Assert.Throws <JsonException>(() =>
{
var utf8JsonBytes = Encoding.UTF8.GetBytes("\"UNKNOWN_VALUE\"");
var reader = new Utf8JsonReader(utf8JsonBytes, true, new JsonReaderState());
while (reader.Read())
{
target.Read(ref reader, typeof(TestEnum), new JsonSerializerOptions());
}
});
}
private void ScripterFixGames_SizeChanged(int matchIndex, int value)
{
Match match = fixedMatchesDay.matches[matchIndex];
match.SetTeamSize(new MatchSize(value));
foreach (Team team in match.teams)
{
for (int position = 0; position < Team.MaxSize; position++)
{
if (!team.PositionShouldBeFilled((Position)position))
{
team.players[position] = null;
}
}
}
swapPlayerIndexForFixing = -1;
toolStripStatusLabel1.Text = $"Changed a match to {EnumStringConverter.NameOfTeamSize(value)}";
DisplayFixedMatches();
}
public EnumTextConverter()
{
_converter = new EnumStringConverter();
}
public static void Setup(TestContext context)
{
_converter = new EnumStringConverter();
}
public override void HandleRow(string[] data)
{
// Identify:
Player player = null;
for (int i = 0; i < data.Length; i++)
{
switch (GetColumn(i).First())
{
case "Tag Number":
if (player == null && !string.IsNullOrEmpty(data[i]))
{
player = players.FirstOrDefault(p => p.TagNumber.Equals(data[i]));
}
break;
case "Name":
player = players.FirstOrDefault(p => p.Name.Equals(data[i]));
break;
}
}
if (player == null)
{
player = new Player {
ID = DataCreation.UniqueRandomInt(players)
};
players.Add(player);
}
// Import
for (int i = 0; i < data.Length; i++)
{
switch (GetColumn(i).First())
{
case "Tag Number":
if (string.IsNullOrEmpty(data[i]))
{
break;
}
player.TagNumber = data[i];
break;
case "Name":
if (string.IsNullOrEmpty(data[i]))
{
break;
}
player.Name = data[i];
break;
case "Primary Position":
player.PositionPrimary = EnumStringConverter.ParsePosition(data[i]);
break;
case "Primary Grade":
player.GradePrimary = EnumStringConverter.ParseGrade(data[i]);
break;
case "Secondary Position":
player.PositionSecondary = EnumStringConverter.ParsePosition(data[i]);
break;
case "Secondary Grade":
player.GradeSecondary = EnumStringConverter.ParseGrade(data[i]);
break;
case "Primary Position and Grade":
player.PreferencePrimary = EnumStringConverter.ParsePositionAndGrade(data[i]);
break;
case "Secondary Position and Grade":
player.PreferenceSecondary = EnumStringConverter.ParsePositionAndGrade(data[i]);
break;
case "Team Size":
player.PreferredTeamSizes = EnumStringConverter.TryParseTeamSize(data[i], out TeamSize ts) ? ts : TeamSize.Any;
break;
}
}
// Validate
if (player.PositionPrimary == Position.None)
{
player.PositionPrimary = Position.Lead;
}
if (player.GradePrimary == Grade.None)
{
player.GradePrimary = Grade.G2;
}
if (player.PositionSecondary != Position.None && player.GradeSecondary == Grade.None)
{
player.GradeSecondary = player.GradePrimary;
}
}
public void TestEnumStringConvertTo()
{
var converter = new EnumStringConverter();
Assert.AreEqual("Hello", converter.ConvertTo(TestEnums.Hello, typeof(string)));
}
public void EnumStringConvertToStringTest()
{
var convert = new EnumStringConverter();
Assert.AreEqual("World", convert.ConvertToString(TestEnums.World));
}
public void ClearCaches_Call_NoExceptions()
{
EnumStringConverter.ClearCaches();
}
