public void OpenType()
{
int count = 0;
var cm = new ConverterManager();
// Register a converter builder.
// Builder runs once; converter runs each time.
// Uses open type to match.
cm.AddConverter <TypeWrapperIsString, int, Attribute>(
(typeSrc, typeDest) =>
{
count++;
Assert.Equal(typeof(String), typeSrc);
Assert.Equal(typeof(int), typeDest);
return((input) =>
{
string s = (string)input;
return int.Parse(s);
});
});
var converter = cm.GetConverter <string, int, Attribute>();
Assert.NotNull(converter);
Assert.Equal(12, converter("12", new TestAttribute(null), null));
Assert.Equal(34, converter("34", new TestAttribute(null), null));
Assert.Equal(1, count); // converterBuilder is only called once.
// 'char' as src parameter doesn't match the type predicate.
Assert.Null(cm.GetConverter <char, int, Attribute>());
}
public void AttributeOverloads()
{
var cm = new ConverterManager(); // empty
cm.AddConverter <Wrapper, string, TestAttribute>((x, attr) => string.Format("[t1:{0}-{1}]", x.Value, attr.Flag));
cm.AddConverter <Wrapper, string, TestAttribute2>((x, attr) => string.Format("[t2:{0}-{1}]", x.Value, attr.Flag));
// Since converter was registered for a specific attribute, it must be queried by that attribute.
var funcMiss = cm.GetConverter <Wrapper, string, Attribute>();
Assert.Null(funcMiss);
// Each attribute type has its own conversion function
var func1 = cm.GetConverter <Wrapper, string, TestAttribute>();
Assert.NotNull(func1);
var x1 = func1(new Wrapper {
Value = "x"
}, new TestAttribute("y"));
Assert.Equal("[t1:x-y]", x1);
var func2 = cm.GetConverter <Wrapper, string, TestAttribute2>();
Assert.NotNull(func2);
var x2 = func2(new Wrapper {
Value = "x"
}, new TestAttribute2("y"));
Assert.Equal("[t2:x-y]", x2);
}
public void AttributeOverloads2()
{
var cm = new ConverterManager(); // empty
cm.AddConverter <Wrapper, string, TestAttribute>((x, attr) => string.Format("[t1:{0}-{1}]", x.Value, attr.Flag));
cm.AddConverter <Wrapper, string>(x => string.Format("[common:{0}]", x.Value));
// This has an exact match on attribute and gives the specific function we registered.
var func1 = cm.GetConverter <Wrapper, string, TestAttribute>();
Assert.NotNull(func1);
var x1 = func1(new Wrapper {
Value = "x"
}, new TestAttribute("y"));
Assert.Equal("[t1:x-y]", x1);
// Nothing registered for this attribute, so we return the converter that didn't require any attribute.
var func2 = cm.GetConverter <Wrapper, string, TestAttribute2>();
Assert.NotNull(func2);
var x2 = func2(new Wrapper {
Value = "x"
}, new TestAttribute2("y"));
Assert.Equal("[common:x]", x2);
}
public void StringAndByteArray()
{
var cm = new ConverterManager(); // empty
// No default byte[]-->Wrapper conversion.
var fromBytes = cm.GetConverter<byte[], Wrapper, Attribute>();
Assert.Null(fromBytes);
// Add a string-->Wrapper conversion
cm.AddConverter<string, Wrapper>(str => new Wrapper { Value = str });
var fromString = cm.GetConverter<string, Wrapper, Attribute>();
Wrapper obj1 = fromString("abc", null);
Assert.Equal("abc", obj1.Value);
// Now we can get a byte-->string , composed from a default (byte[]-->string) + supplied (string-->Wrapper)
byte[] bytes = Encoding.UTF8.GetBytes("abc");
fromBytes = cm.GetConverter<byte[], Wrapper, Attribute>();
Assert.NotNull(fromBytes);
Wrapper obj2 = fromBytes(bytes, null);
Assert.Equal("abc", obj2.Value);
// Now override the default. Uppercase the string so we know it used our custom converter.
cm.AddConverter<byte[], string>(b => Encoding.UTF8.GetString(b).ToUpper());
fromBytes = cm.GetConverter<byte[], Wrapper, Attribute>();
Wrapper obj3 = fromBytes(bytes, null);
Assert.Equal("ABC", obj3.Value);
}
public void StringAndByteArray()
{
var cm = new ConverterManager(); // empty
// No default byte[]-->Wrapper conversion.
var fromBytes = cm.GetConverter <byte[], Wrapper, Attribute>();
Assert.Null(fromBytes);
// Add a string-->Wrapper conversion
cm.AddConverter <string, Wrapper>(str => new Wrapper {
Value = str
});
var fromString = cm.GetConverter <string, Wrapper, Attribute>();
Wrapper obj1 = fromString("abc", null);
Assert.Equal("abc", obj1.Value);
// Now we can get a byte-->string , composed from a default (byte[]-->string) + supplied (string-->Wrapper)
byte[] bytes = Encoding.UTF8.GetBytes("abc");
fromBytes = cm.GetConverter <byte[], Wrapper, Attribute>();
Assert.NotNull(fromBytes);
Wrapper obj2 = fromBytes(bytes, null);
Assert.Equal("abc", obj2.Value);
// Now override the default. Uppercase the string so we know it used our custom converter.
cm.AddConverter <byte[], string>(b => Encoding.UTF8.GetString(b).ToUpper());
fromBytes = cm.GetConverter <byte[], Wrapper, Attribute>();
Wrapper obj3 = fromBytes(bytes, null);
Assert.Equal("ABC", obj3.Value);
}
public void UseValueBindingContext()
{
var cm = new ConverterManager(); // empty
Guid instance = Guid.NewGuid();
var testContext = new ValueBindingContext(new FunctionBindingContext(instance, CancellationToken.None, null), CancellationToken.None);
cm.AddConverter((object obj, Attribute attr, ValueBindingContext ctx) => {
Assert.Same(ctx, testContext);
var result = JObject.FromObject(obj);
result["$"] = ctx.FunctionInstanceId;
return(result);
});
cm.AddConverter <string, Wrapper>(str => new Wrapper {
Value = str
});
// Expected:
// Other --> JObject,
// JObject --> string , (builtin)
// string --> Wrapper
var func = cm.GetConverter <Other, Wrapper, Attribute>();
var value = new Other {
Value2 = "abc"
};
Wrapper x1 = func(value, null, testContext);
Assert.Equal(@"{
""Value2"": ""abc"",
""$"": """ + instance.ToString() + @"""
}", x1.Value);
}
public void UseValueBindingContext()
{
var cm = new ConverterManager(); // empty
Guid instance = Guid.NewGuid();
var testContext = new ValueBindingContext(new FunctionBindingContext(instance, CancellationToken.None, null), CancellationToken.None);
cm.AddConverter((object obj, Attribute attr, ValueBindingContext ctx) => {
Assert.Same(ctx, testContext);
var result = JObject.FromObject(obj);
result["$"] = ctx.FunctionInstanceId;
return(result);
});
cm.AddConverter <string, Wrapper>(str => new Wrapper {
Value = str
});
// Expected:
// Other --> JObject,
// JObject --> string , (builtin)
// string --> Wrapper
var func = cm.GetConverter <Other, Wrapper, Attribute>();
var value = new Other {
Value2 = "abc"
};
Wrapper x1 = func(value, null, testContext);
// strip whitespace
string val = Regex.Replace(x1.Value, @"\s", "");
string expected = String.Format("{{\"Value2\":\"abc\",\"$\":\"{0}\"}}", instance);
Assert.Equal(expected, val);
}
public void Inheritence()
{
var cm = new ConverterManager(); // empty
var func = cm.GetConverter<DerivedWrapper, Wrapper, Attribute>();
var obj = new DerivedWrapper { Value = "x" };
Wrapper x1 = func(obj, null);
Assert.Same(x1, obj);
}
public void Identity()
{
var cm = new ConverterManager(); // empty
var identity = cm.GetConverter<string, string, Attribute>();
var value = "abc";
var x1 = identity(value, null);
Assert.Same(x1, value);
}
public void CatchAll()
{
var cm = new ConverterManager(); // empty
cm.AddConverter<object, Wrapper>(x => new Wrapper { Value = x.ToString() });
var func = cm.GetConverter<int, Wrapper, Attribute>();
var x1 = func(123, null);
Assert.Equal("123", x1.Value);
}
public void ExactMatchOverride()
{
var cm = new ConverterManager(); // empty
cm.AddConverter<string, string>(x => "*" + x + "*");
var func = cm.GetConverter<string, string, Attribute>();
var x1 = func("x", null);
Assert.Equal("*x*", x1);
}
public void UseGenericAsyncConverterTest()
{
var cm = new ConverterManager();
cm.AddConverter <int, string, Attribute>(typeof(UseGenericAsyncConverter <>));
var converter = cm.GetConverter <int, string, Attribute>();
Assert.Equal("12", converter(12, new TestAttribute(null), null));
}
public void OpenTypeSimpleConcreteConverter()
{
Assert.Equal(0, _counter);
var cm = new ConverterManager();
// Register a converter builder.
// Builder runs once; converter runs each time.
// Uses open type to match.
cm.AddConverter <TypeWrapperIsString, int, Attribute>(new ConverterInstanceMethod());
var converter = cm.GetConverter <string, int, Attribute>();
Assert.Equal(12, converter("12", new TestAttribute(null), null));
Assert.Equal(34, converter("34", new TestAttribute(null), null));
Assert.Equal(0, _counter); // passed in instantiated object; counter never incremented.
// 'char' as src parameter doesn't match the type predicate.
Assert.Null(cm.GetConverter <char, int, Attribute>());
}
public void ClosedTypeArray()
{
var cm = new ConverterManager();
cm.AddConverter <int[], string, Attribute>(new OpenArrayConverter <int>());
var attr = new TestAttribute(null);
var converter = cm.GetConverter <int[], string, Attribute>();
Assert.Equal("1,2,3", converter(new int[] { 1, 2, 3 }, attr, null));
}
public void OpenTypeConverterWithConcreteTypes()
{
Assert.Equal(0, _counter);
var cm = new ConverterManager();
// Register a converter builder.
// Builder runs once; converter runs each time.
// Uses open type to match.
cm.AddConverter <TypeWrapperIsString, int, Attribute>(typeof(TypeConverterWithConcreteTypes), this);
var converter = cm.GetConverter <string, int, Attribute>();
Assert.Equal(12, converter("12", new TestAttribute(null), null));
Assert.Equal(34, converter("34", new TestAttribute(null), null));
Assert.Equal(1, _counter); // converterBuilder is only called once.
// 'char' as src parameter doesn't match the type predicate.
Assert.Null(cm.GetConverter <char, int, Attribute>());
}
public void Identity()
{
var cm = new ConverterManager(); // empty
var identity = cm.GetConverter <string, string, Attribute>();
var value = "abc";
var x1 = identity(value, null);
Assert.Same(x1, value);
}
public void Inheritence()
{
var cm = new ConverterManager(); // empty
var func = cm.GetConverter <DerivedWrapper, Wrapper, Attribute>();
var obj = new DerivedWrapper {
Value = "x"
};
Wrapper x1 = func(obj, null);
Assert.Same(x1, obj);
}
public void ExactMatchOverride()
{
var cm = new ConverterManager(); // empty
cm.AddConverter <string, string>(x => "*" + x + "*");
var func = cm.GetConverter <string, string, Attribute>();
var x1 = func("x", null);
Assert.Equal("*x*", x1);
}
public void OpenTypeConverterWithOneGenericArg()
{
var cm = new ConverterManager();
// Register a converter builder.
// Builder runs once; converter runs each time.
// Uses open type to match.
// Also test the IEnumerable<OpenType> pattern.
cm.AddConverter <OpenType, IEnumerable <OpenType>, Attribute>(typeof(TypeConverterWithOneGenericArg <>));
var attr = new TestAttribute(null);
{
var converter = cm.GetConverter <int, IEnumerable <int>, Attribute>();
Assert.Equal(new int[] { 1, 1, 1 }, converter(1, attr, null));
}
{
var converter = cm.GetConverter <string, IEnumerable <string>, Attribute>();
Assert.Equal(new string[] { "a", "a", "a" }, converter("a", attr, null));
}
}
public void CatchAll()
{
var cm = new ConverterManager(); // empty
cm.AddConverter <object, Wrapper>(x => new Wrapper {
Value = x.ToString()
});
var func = cm.GetConverter <int, Wrapper, Attribute>();
var x1 = func(123, null);
Assert.Equal("123", x1.Value);
}
public void TestConvertFakeEntity()
{
var cm = new ConverterManager();
// Derived<ITableEntity> --> IFakeEntity [automatic]
// JObject --> IFakeEntity
// Poco --> IFakeEntity
cm.AddConverter <JObject, IFakeEntity, Attribute>(typeof(TestConverterFakeEntity));
cm.AddConverter <OpenType, IFakeEntity, Attribute>(typeof(TestConverterFakeEntity <>));
{
var converter = cm.GetConverter <IFakeEntity, IFakeEntity, Attribute>();
var src = new MyFakeEntity {
Property = "123"
};
var dest = converter(src, null, null);
Assert.Same(src, dest); // should be exact same instance - no conversion
}
{
var converter = cm.GetConverter <JObject, IFakeEntity, Attribute>();
JObject obj = new JObject();
obj["Property1"] = "456";
var dest = converter(obj, null, null);
Assert.Equal("456", dest.Property);
}
{
var converter = cm.GetConverter <PocoEntity, IFakeEntity, Attribute>();
var src = new PocoEntity {
Property2 = "789"
};
var dest = converter(src, null, null);
Assert.Equal("789", dest.Property);
}
}
public void JsonSerialization()
{
var cm = new ConverterManager(); // empty
cm.AddConverter <string, Wrapper>(str => new Wrapper {
Value = str
});
var objSrc = new Other {
Value2 = "abc"
};
// Json Serialize: (Other --> string)
// custom (string -->Wrapper)
var func = cm.GetConverter <Other, Wrapper, Attribute>();
Wrapper obj2 = func(objSrc, null);
string json = obj2.Value;
var objSrc2 = JsonConvert.DeserializeObject <Other>(json);
Assert.Equal(objSrc.Value2, objSrc2.Value2);
}
public void AttributeOverloads()
{
var cm = new ConverterManager(); // empty
cm.AddConverter<Wrapper, string, TestAttribute>((x, attr) => string.Format("[t1:{0}-{1}]", x.Value, attr.Flag));
cm.AddConverter<Wrapper, string, TestAttribute2>((x, attr) => string.Format("[t2:{0}-{1}]", x.Value, attr.Flag));
// Since converter was registered for a specific attribute, it must be queried by that attribute.
var funcMiss = cm.GetConverter<Wrapper, string, Attribute>();
Assert.Null(funcMiss);
// Each attribute type has its own conversion function
var func1 = cm.GetConverter<Wrapper, string, TestAttribute>();
Assert.NotNull(func1);
var x1 = func1(new Wrapper { Value = "x" } , new TestAttribute("y"));
Assert.Equal("[t1:x-y]", x1);
var func2 = cm.GetConverter<Wrapper, string, TestAttribute2>();
Assert.NotNull(func2);
var x2 = func2(new Wrapper { Value = "x" }, new TestAttribute2("y"));
Assert.Equal("[t2:x-y]", x2);
}
public void AttributeOverloads2()
{
var cm = new ConverterManager(); // empty
cm.AddConverter<Wrapper, string, TestAttribute>((x, attr) => string.Format("[t1:{0}-{1}]", x.Value, attr.Flag));
cm.AddConverter<Wrapper, string>(x => string.Format("[common:{0}]", x.Value));
// This has an exact match on attribute and gives the specific function we registered.
var func1 = cm.GetConverter<Wrapper, string, TestAttribute>();
Assert.NotNull(func1);
var x1 = func1(new Wrapper { Value = "x" }, new TestAttribute("y"));
Assert.Equal("[t1:x-y]", x1);
// Nothing registered for this attribute, so we return the converter that didn't require any attribute.
var func2 = cm.GetConverter<Wrapper, string, TestAttribute2>();
Assert.NotNull(func2);
var x2 = func2(new Wrapper { Value = "x" }, new TestAttribute2("y"));
Assert.Equal("[common:x]", x2);
}
public void JsonSerialization()
{
var cm = new ConverterManager(); // empty
cm.AddConverter<string, Wrapper>(str => new Wrapper { Value = str });
var objSrc = new Other { Value2 = "abc" };
// Json Serialize: (Other --> string)
// custom (string -->Wrapper)
var func = cm.GetConverter<Other, Wrapper, Attribute>();
Wrapper obj2 = func(objSrc, null);
string json = obj2.Value;
var objSrc2 = JsonConvert.DeserializeObject<Other>(json);
Assert.Equal(objSrc.Value2, objSrc2.Value2);
}
