public void TestParseParameters_TypedVariantNotAccepted()
{
var basicLocalizedItems = new ReswItem[0];
var res = FormatTag.ParseParameters("test", new[] { "Variant Int var1", "Variant var2" }, basicLocalizedItems, "test", null);
Assert.Null(res);
}
public void TestParseParameters_Multi()
{
var strings = new[] {
"",
" ",
" ",
"lkryweiuf rysiu",
"Lorem Ipsum",
"Int Plural Short",
"LONG_TEXT_AAAAAABBBBBBBBBBBBBBBBBBBBBBB"
};
foreach (var literal1 in strings)
{
foreach (var literal2 in strings)
{
var basicLocalizedItems = new ReswItem[0];
var res = FormatTag.ParseParameters("test", new[] {
$"\"{literal1}\"",
$"\"{literal2}\"",
}, basicLocalizedItems, "test", null);
Assert.NotNull(res);
Assert.True(res.Parameters.Count == 2);
for (int i = 0; i < 2; ++i)
{
Assert.IsType <LiteralStringFormatTagParameter>(res.Parameters[i]);
var literalParam = (LiteralStringFormatTagParameter)res.Parameters[i];
Assert.Equal(i == 0 ? literal1 : literal2, literalParam.Value);
Assert.Null(res.PluralizationParameter);
Assert.Null(res.VariantParameter);
}
}
}
}
public void TestParseParameters_LiteralMixed()
{
foreach (var literal in new[] {
"",
" ",
" ",
"lkryweiuf rysiu",
"Lorem Ipsum",
"Int Plural Short",
"LONG_TEXT_AAAAAABBBBBBBBBBBBBBBBBBBBBBB"
})
{
var basicLocalizedItems = new ReswItem[0];
var res = FormatTag.ParseParameters("test", new[] {
$"\"{literal}\"",
"Int test"
}, basicLocalizedItems, "test", null);
Assert.NotNull(res);
Assert.True(res.Parameters.Count == 2);
Assert.IsType <LiteralStringFormatTagParameter>(res.Parameters[0]);
Assert.IsType <FunctionFormatTagParameter>(res.Parameters[1]);
var literalParam = (LiteralStringFormatTagParameter)res.Parameters[0];
Assert.Equal(literal, literalParam.Value);
Assert.Null(res.PluralizationParameter);
Assert.Null(res.VariantParameter);
}
}
public void TestParseParameters_OneLiteral()
{
foreach (var literal in new[] {
"",
" ",
" ",
"test",
"Plural",
"Int",
"LONG_TEXT_AAAAAAAAAAAAAAAAAAAAAAAAA",
"TEXT WITH ] CHAR",
"TEXT WITH \\\" CHAR"
})
{
var basicLocalizedItems = new ReswItem[0];
var res = FormatTag.ParseParameters("test", new[] { $"\"{literal}\"" }, basicLocalizedItems, "test", null);
Assert.NotNull(res);
Assert.True(res.Parameters.Count == 1);
Assert.IsType <LiteralStringFormatTagParameter>(res.Parameters[0]);
var literalParam = (LiteralStringFormatTagParameter)res.Parameters[0];
Assert.Equal(literal, literalParam.Value);
Assert.Null(res.PluralizationParameter);
Assert.Null(res.VariantParameter);
}
}
public void TestParseParameters_OneValidNamedPluralParameter()
{
foreach (var type in FormatTag.AcceptedTypes.Where(t => t.Value.CanBeQuantifier))
{
var basicLocalizedItems = new ReswItem[0];
var res = FormatTag.ParseParameters("test", new[] { "Plural " + type.Key + " testParam" }, basicLocalizedItems, "test", null);
Assert.NotNull(res);
Assert.True(res.Parameters.Count == 1);
Assert.IsType <FunctionFormatTagParameter>(res.Parameters[0]);
var functionParam = (FunctionFormatTagParameter)res.Parameters[0];
Assert.Equal(functionParam.Type, type.Value.Type);
Assert.Equal("testParam", functionParam.Name);
Assert.Equal(res.PluralizationParameter, functionParam);
Assert.False(functionParam.IsVariantId);
if (type.Value.Type == ParameterType.Double)
{
Assert.Null(functionParam.TypeToCast);
}
else
{
Assert.Equal(ParameterType.Double, functionParam.TypeToCast);
}
Assert.Null(res.VariantParameter);
}
}
public void TestParseParameters_WrongTypePluralParameter()
{
foreach (var type in FormatTag.AcceptedTypes.Where(t => !t.Value.CanBeQuantifier))
{
var basicLocalizedItems = new ReswItem[0];
var res = FormatTag.ParseParameters("test", new[] { $"Plural {type}" }, basicLocalizedItems, "test", null);
Assert.Null(res);
}
}
public void TestParseParameters_OneValidParameter()
{
foreach (var type in FormatTag.AcceptedTypes)
{
var basicLocalizedItems = new ReswItem[0];
var res = FormatTag.ParseParameters("test", new[] { type.Key }, basicLocalizedItems, "test", null);
Assert.NotNull(res);
Assert.True(res.Parameters.Count == 1);
Assert.IsType <FunctionFormatTagParameter>(res.Parameters[0]);
Assert.Equal(((FunctionFormatTagParameter)res.Parameters[0]).Type, type.Value.Type);
Assert.Null(res.PluralizationParameter);
Assert.Null(res.VariantParameter);
}
}
public void TestParseParameters_OneLiteral()
{
foreach (var macro in FormatTag.MacrosAvailable)
{
var basicLocalizedItems = new ReswItem[0];
var res = FormatTag.ParseParameters("test", new[] { macro.Key }, basicLocalizedItems, "test", null);
Assert.NotNull(res);
Assert.True(res.Parameters.Count == 1);
Assert.IsType <MacroFormatTagParameter>(res.Parameters[0]);
var macroParam = (MacroFormatTagParameter)res.Parameters[0];
Assert.Equal(macro.Value, macroParam.Id);
Assert.Null(res.PluralizationParameter);
Assert.Null(res.VariantParameter);
}
}
public void TestParseParameters_OneValidNamelessVariantParameter()
{
var basicLocalizedItems = new ReswItem[0];
var res = FormatTag.ParseParameters("test", new[] { "Variant" }, basicLocalizedItems, "test", null);
Assert.NotNull(res);
Assert.True(res.Parameters.Count == 1);
Assert.IsType <FunctionFormatTagParameter>(res.Parameters[0]);
var functionParam = (FunctionFormatTagParameter)res.Parameters[0];
Assert.Equal(ParameterType.Long, functionParam.Type);
Assert.Null(res.PluralizationParameter);
Assert.True(functionParam.IsVariantId);
Assert.Equal(res.VariantParameter, functionParam);
}
public void TestParseParameters_TypeLessPlural()
{
var basicLocalizedItems = new ReswItem[0];
var res = FormatTag.ParseParameters("test", new[] { "Plural" }, basicLocalizedItems, "test", null);
Assert.NotNull(res);
Assert.True(res.Parameters.Count == 1);
Assert.IsType <FunctionFormatTagParameter>(res.Parameters[0]);
var functionParam = (FunctionFormatTagParameter)res.Parameters[0];
Assert.Equal(ParameterType.Double, functionParam.Type);
Assert.Equal(res.PluralizationParameter, functionParam);
Assert.Null(functionParam.TypeToCast);
Assert.Null(res.VariantParameter);
}
public void TestParseParameters_MultiValidParameter()
{
foreach (var type1 in FormatTag.AcceptedTypes)
{
foreach (var type2 in FormatTag.AcceptedTypes)
{
var basicLocalizedItems = new ReswItem[0];
var res = FormatTag.ParseParameters("test", new[] { type1.Key, type2.Key + " paramName" }, basicLocalizedItems, "test", null);
Assert.NotNull(res);
Assert.True(res.Parameters.Count == 2);
Assert.IsType <FunctionFormatTagParameter>(res.Parameters[0]);
Assert.Equal(((FunctionFormatTagParameter)res.Parameters[0]).Type, type1.Value.Type);
Assert.False(((FunctionFormatTagParameter)res.Parameters[0]).IsVariantId);
Assert.Null(res.PluralizationParameter);
Assert.Null(res.VariantParameter);
Assert.IsType <FunctionFormatTagParameter>(res.Parameters[1]);
Assert.Equal(((FunctionFormatTagParameter)res.Parameters[1]).Type, type2.Value.Type);
Assert.False(((FunctionFormatTagParameter)res.Parameters[1]).IsVariantId);
Assert.Equal("paramName", ((FunctionFormatTagParameter)res.Parameters[1]).Name);
Assert.Null(res.PluralizationParameter);
Assert.Null(res.VariantParameter);
}
}
}
public void TestParseParameters_Multi()
{
foreach (var macro1 in FormatTag.MacrosAvailable)
{
foreach (var macro2 in FormatTag.MacrosAvailable)
{
var basicLocalizedItems = new ReswItem[0];
var res = FormatTag.ParseParameters("test", new[] {
macro1.Key,
macro2.Key,
}, basicLocalizedItems, "test", null);
Assert.NotNull(res);
Assert.True(res.Parameters.Count == 2);
for (int i = 0; i < 2; ++i)
{
Assert.IsType <MacroFormatTagParameter>(res.Parameters[i]);
var macroParam = (MacroFormatTagParameter)res.Parameters[i];
Assert.Equal(i == 0 ? macro1.Value : macro2.Value, macroParam.Id);
Assert.Null(res.PluralizationParameter);
Assert.Null(res.VariantParameter);
}
}
}
}
