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); }