public void VecU8EncodingTest()
{
var tc = new GenericTypeConverter <Vec <U8> >();
var actual = (Vec <U8>)tc.Create("0x200101020304050607");
Assert.AreEqual(actual.Bytes, actual.Encode());
var t1 = new U8(); t1.Create(actual.Value[0].Value);
var t2 = new U8(); t2.Create(actual.Value[1].Value);
var t3 = new U8(); t3.Create(actual.Value[2].Value);
var t4 = new U8(); t4.Create(actual.Value[3].Value);
var t5 = new U8(); t5.Create(actual.Value[4].Value);
var t6 = new U8(); t6.Create(actual.Value[5].Value);
var t7 = new U8(); t7.Create(actual.Value[6].Value);
var t8 = new U8(); t8.Create(actual.Value[7].Value);
List <U8> list = new List <U8>()
{
t1, t2, t3, t4, t5, t6, t7, t8
};
var vecU8 = new Vec <U8>();
vecU8.Create(list);
Assert.AreEqual("0x200101020304050607", Utils.Bytes2HexString(vecU8.Bytes));
}
public void MogwaiBiosTypeConverterTest()
{
var tc = new GenericTypeConverter <MogwaiBios>();
var actual =
tc.Create("0xe2d3965c287d92c7cf45dc3ff832e8060607cc8eb7f85ae598b4030338f59587" +
"00000000" +
"08" +
"f27a7c4788ef094b6e4d8d6eaa0732c4" +
"844cbb8fb0ab077a7aba7f7a7baba77a" +
"000000000000000000000000" +
"0000000001" +
"040c1f020000");
Assert.IsTrue(actual is MogwaiBios);
var mogwaiBios = actual as MogwaiBios;
Assert.AreEqual("0xe2d3965c287d92c7cf45dc3ff832e8060607cc8eb7f85ae598b4030338f59587",
mogwaiBios.Id.Value.ToLower());
Assert.AreEqual(0, mogwaiBios.State.Value);
Assert.AreEqual("0xf27a7c4788ef094b6e4d8d6eaa0732c4",
(mogwaiBios.MetaXy.Value[0].Value as string).ToLower());
Assert.AreEqual("0x844cbb8fb0ab077a7aba7f7a7baba77a",
(mogwaiBios.MetaXy.Value[1].Value as string).ToLower());
Assert.AreEqual(new BigInteger(0), mogwaiBios.Intrinsic.Value);
Assert.AreEqual(1, mogwaiBios.Level.Value);
Assert.AreEqual(139020, mogwaiBios.Phases.Value[0].Value);
Assert.AreEqual(0, mogwaiBios.Adaptations.Value.Count);
}
public void U64TypeConverterTest()
{
var tc = new GenericTypeConverter <U64>();
var actual = (U64)tc.Create("0x01de99faf142bca0");
Assert.AreEqual(0xa0bc42f1fa99de01, actual.Value);
}
public void U16TypeConverterTest()
{
var tc = new GenericTypeConverter <U16>();
var actual = (U16)tc.Create("0xf142");
Assert.AreEqual((short)0x42f1, actual.Value);
}
public void U32TypeConverterTest()
{
var tc = new GenericTypeConverter <U32>();
var actual = (U32)tc.Create("0xf142bca0");
Assert.AreEqual(0xa0bc42f1, actual.Value);
}
public void BoolTypeConverterTest()
{
var tc = new GenericTypeConverter <Bool>();
var actual = (Bool)tc.Create("0x00");
Assert.AreEqual(false, actual.Value);
actual = (Bool)tc.Create("0x01");
Assert.AreEqual(true, actual.Value);
}
public void MogwaiStructTypeConverterTest()
{
var tc = new GenericTypeConverter <MogwaiStruct>();
var actual =
tc.Create(
"0x89ab510f57802886c16922685a376edb536f762584dda569cda67381c4e4dec889ab510f57802886c16922685a376edb536f762584dda569cda67381c4e4dec871000000000000000000000000000000000000000000000000");
Assert.IsTrue(actual is MogwaiStruct);
var hash = new Hash();
hash.Create("0x89ab510f57802886c16922685a376edb536f762584dda569cda67381c4e4dec8");
Assert.AreEqual(hash.Value, (actual as MogwaiStruct).Id.Value);
}
public void CollectionAsExpected()
{
var input = typeof(List <string>);
var nullableStringConverter = new GenericTypeConverter(x => x == typeof(string), x => "string | null");
var propertySettings = CreatePropertySettings();
propertySettings.TypeConverters.Add(nullableStringConverter);
var sut = new TypeDeterminer(propertySettings, enumSettings, namespaceSettings);
var actual = sut.Determine(input);
Assert.That(actual.FormattedType, Is.EqualTo("(string | null)[]"));
Assert.That(actual.Dependencies, Is.Empty);
}
public void VecU8TypeConverterTest()
{
var tc = new GenericTypeConverter <Vec <U8> >();
var actual = (Vec <U8>)tc.Create("0x200101020304050607");
Assert.AreEqual(1, actual.Value[0].Value);
Assert.AreEqual(1, actual.Value[1].Value);
Assert.AreEqual(2, actual.Value[2].Value);
Assert.AreEqual(3, actual.Value[3].Value);
Assert.AreEqual(4, actual.Value[4].Value);
Assert.AreEqual(5, actual.Value[5].Value);
Assert.AreEqual(6, actual.Value[6].Value);
Assert.AreEqual(7, actual.Value[7].Value);
}
public override object ProvideValue(IServiceProvider serviceProvider)
{
if (ServiceProvider.IsTargetTemplate(serviceProvider))
{
return(this);
}
if (!PathFormat.IsNullOrEmpty())
{
Converter = new GenericTypeConverter()
{
StringFormat = ThemeFile.GetFilePath(PathFormat, false)
};
}
return(base.ProvideValue(serviceProvider));
}
/// <summary>
/// Initializes a new instance of the <see cref="MorestachioFormatterService" /> class.
/// </summary>
public MorestachioFormatterService()
{
Formatters = new List <MorestachioFormatterModel>();
ValueConverter = new List <IFormatterValueConverter>();
DefaultConverter = new GenericTypeConverter();
}
public static T GetElementOrNull <T>(this XmlElement xmlElement)
{
return(GenericTypeConverter.ConvertElement <T>(xmlElement));
}
public static T GetValueOrNull <T>(this XmlElement xmlElement)
{
return(GenericTypeConverter.ConvertValue <T>(xmlElement?.InnerText?.Trim(), xmlElement));
}
public static T GetValueOrNull <T>(this XmlAttribute xmlAttribute)
{
return(GenericTypeConverter.ConvertValue <T>(xmlAttribute?.Value, xmlAttribute));
}
