/// <summary>
/// Пытется найти подходящий resolver для указанного примитивного типа
/// </summary>
/// <returns><c>true</c>, if create primitive resolver was tryed, <c>false</c> otherwise.</returns>
/// <param name="type">Type.</param>
/// <param name="resolver">Resolver.</param>
private bool TryCreatePrimitiveResolver(Type type, out IResolver resolver)
{
if (TypeOf <Boolean> .Equals(type))
{
resolver = new BooleanResolver(); return(true);
}
if (TypeOf <Byte> .Equals(type))
{
resolver = new ByteResolver(); return(true);
}
if (TypeOf <Char> .Equals(type))
{
resolver = new CharResolver(); return(true);
}
if (TypeOf <Double> .Equals(type))
{
resolver = new DoubleResolver(); return(true);
}
if (TypeOf <Int16> .Equals(type))
{
resolver = new Int16Resolver(); return(true);
}
if (TypeOf <Int32> .Equals(type))
{
resolver = new Int32Resolver(); return(true);
}
if (TypeOf <Int64> .Equals(type))
{
resolver = new Int64Resolver(); return(true);
}
if (TypeOf <SByte> .Equals(type))
{
resolver = new SByteResolver(); return(true);
}
if (TypeOf <Single> .Equals(type))
{
resolver = new SingleResolver(); return(true);
}
if (TypeOf <UInt16> .Equals(type))
{
resolver = new UInt16Resolver(); return(true);
}
if (TypeOf <UInt32> .Equals(type))
{
resolver = new UInt32Resolver(); return(true);
}
if (TypeOf <UInt64> .Equals(type))
{
resolver = new UInt64Resolver(); return(true);
}
resolver = null;
return(false);
}
public void NotResolver()
{
var strs = new[] { "abc", "def", "ghi" };
var s1 = new SingleResolver("abc");
var s2 = new SingleResolver("xxx");
var n1 = new NotResolver(s1);
var n2 = new NotResolver(s2);
Assert.True(n2.Resolve(strs));
Assert.False(n1.Resolve(strs));
}
public void AndResolver()
{
var strs = new[] { "abc", "def", "ghi" };
var s1 = new SingleResolver("abc");
var s2 = new SingleResolver("def");
var s4 = new SingleResolver("xxx");
var andSuccess = new AndResolver(s1, s2);
var andFailuer = new AndResolver(s1, s4);
Assert.True(andSuccess.Resolve(strs));
Assert.False(andFailuer.Resolve(strs));
}
public void OrResolver()
{
var strs = new[] { "abc", "def", "ghi" };
var s1 = new SingleResolver("abc");
var s2 = new SingleResolver("def");
var s3 = new SingleResolver("yyy");
var s4 = new SingleResolver("xxx");
var orS1 = new OrResolver(s1, s2);
var orF1 = new OrResolver(s3, s4);
Assert.True(orS1.Resolve(strs));
Assert.False(orF1.Resolve(strs));
}
public void Combination()
{
var A = new SingleResolver("A");
var B = new SingleResolver("B");
var C = new SingleResolver("C");
var D = new SingleResolver("D");
// (A and B) or C
{
var r1 = new OrResolver(new AndResolver(A, B), C);
Assert.True(r1.Resolve("C"));
Assert.True(r1.Resolve("A", "B"));
Assert.True(r1.Resolve("A", "C"));
Assert.True(r1.Resolve("B", "C"));
Assert.True(r1.Resolve("A", "B", "C"));
Assert.False(r1.Resolve("A"));
Assert.False(r1.Resolve("B"));
Assert.False(r1.Resolve());
}
// A and ( B or C )
{
var r2 = new AndResolver(A, new OrResolver(B, C));
Assert.True(r2.Resolve(new[] { "A", "B" }));
Assert.True(r2.Resolve(new[] { "A", "C" }));
Assert.True(r2.Resolve(new[] { "A", "B", "C" }));
Assert.False(r2.Resolve(new[] { "B", "C" }));
Assert.False(r2.Resolve(new[] { "C" }));
Assert.False(r2.Resolve(new[] { "A" }));
Assert.False(r2.Resolve(new[] { "B" }));
Assert.False(r2.Resolve(new string[0]));
}
// A and !(B and C)
{
var r3 = new AndResolver(A, new NotResolver(new AndResolver(B, C)));
Assert.True(r3.Resolve(new[] { "A" }));
Assert.True(r3.Resolve(new[] { "A", "B" }));
Assert.True(r3.Resolve(new[] { "A", "C" }));
Assert.False(r3.Resolve(new[] { "A", "B", "C" }));
Assert.False(r3.Resolve(new[] { "B", "C" }));
Assert.False(r3.Resolve(new[] { "C" }));
Assert.False(r3.Resolve(new[] { "B" }));
Assert.False(r3.Resolve(new string[0]));
}
}
public void SingleResolverCanSetValueToNullIfCanBeNull()
{
var resolver = new SingleResolver(true);
resolver.Resolved = null;
}
public void SingleResolverCannotSetValueToNullIfCannotBeNull()
{
var resolver = new SingleResolver();
resolver.Resolved = null; // throws
}
[Test] // is this normal?
public void SingleResolverCanInitializeWithNullValueEvenIfCannotBeNull()
{
var resolver = new SingleResolver(null, false);
}
public void SingleResolverCanSetValueBeforeFreeze()
{
var resolver = new SingleResolver();
resolver.Resolved = new Resolved();
}
public void TearDown()
{
SingleResolver.Reset();
}
public void Setup()
{
TestHelper.SetupLog4NetForTests();
SingleResolver.Reset();
}
public void Setup()
{
SingleResolver.Reset();
}
