public void ComplexTest()
{
var instance = new TestClass
{
Bar = new TestClass1
{
Foo = "test"
}
};
var str = TypeSerializer.SerializeToString(instance);
var jsv = new JsvConverter();
var result = jsv.DeserializeFromString<TestClass>(str);
Assert.AreEqual("test", result.Bar.Foo);
var foo = new TestClass1
{
Foo = "test1"
};
var result1 = jsv.DeserializeFromString<TestClass1>(TypeSerializer.SerializeToString(foo));
Assert.AreEqual("test1", result1.Foo);
}
public void TestReset()
{
SimpleIoc.Default.Reset();
var instanceOriginal = new TestClass1();
SimpleIoc.Default.Register <ITestClass>(() => instanceOriginal);
var instance = SimpleIoc.Default.GetInstance <ITestClass>();
Assert.IsNotNull(instance);
SimpleIoc.Default.Reset();
try
{
SimpleIoc.Default.GetInstance <ITestClass>();
Assert.Fail("ActivationException was expected");
}
#if NETSTANDARD1_0
catch (InvalidOperationException ex)
#else
catch (ActivationException ex)
#endif
{
}
}
public void GetObjectType()
{
TestClass1 tc1 = new TestClass1();
MethodInvokingFactoryObject mcfo = new MethodInvokingFactoryObject();
mcfo.TargetObject = tc1;
mcfo.TargetMethod = "Method1";
mcfo.AfterPropertiesSet();
Assert.IsTrue(typeof(int).Equals(mcfo.ObjectType));
mcfo = new MethodInvokingFactoryObject();
mcfo.TargetType = typeof(TestClass1);
mcfo.TargetMethod = "VoidRetvalMethod";
mcfo.AfterPropertiesSet();
Type objType = mcfo.ObjectType;
Assert.IsTrue(objType.Equals(MethodInvokingFactoryObject.Void.GetType()));
// verify that we can call a method with args that are subtypes of the
// target method arg types
TestClass1._staticField1 = 0;
mcfo = new MethodInvokingFactoryObject();
mcfo.TargetType = typeof(TestClass1);
mcfo.TargetMethod = "Supertypes";
mcfo.Arguments = new Object[] { new ArrayList(), new ArrayList(), "hello" };
mcfo.AfterPropertiesSet();
objType = mcfo.ObjectType;
}
public void TestDictionaryConversion()
{
var x = new { Text = "Behold, an anonymous object", Number = 42 };
var y = new { Text = "Another anonymous object", Number = 69 };
var z = new TestClass0();
var w = new TestClass1(42);
var v = ReflectionUtilities.CreateEmpty <TestClass0>();
var dx = x.ToDictionary();
var dy = y.ToDictionary();
var dz = z.ToDictionary();
var dw = w.ToDictionary();
var dv = v.ToDictionary();
Assert.AreEqual(x.Text, dx["Text"]);
Assert.AreEqual(y.Text, dy["Text"]);
Assert.AreNotEqual(x.Text, dy["Text"]);
Assert.AreEqual(x.Number, dx["Number"]);
Assert.AreEqual(y.Number, dy["Number"]);
Assert.AreNotEqual(x.Number, dy["Number"]);
Assert.AreNotEqual(dx["Text"], dx["Number"]);
Assert.AreEqual(true, dz["IsInitialized"]);
Assert.AreEqual(43, dw["Value"]);
Assert.AreEqual(false, dv["IsInitialized"]);
}
public void TestUnregisterFactoryInstance()
{
SimpleIoc.Default.Reset();
var instance0 = new TestClass1();
SimpleIoc.Default.Register(() => instance0);
Assert.IsTrue(SimpleIoc.Default.IsRegistered <TestClass1>());
Assert.IsFalse(SimpleIoc.Default.ContainsCreated <TestClass1>());
var instance1 = SimpleIoc.Default.GetInstance <TestClass1>();
Assert.AreSame(instance0, instance1);
Assert.IsTrue(SimpleIoc.Default.IsRegistered <TestClass1>());
Assert.IsTrue(SimpleIoc.Default.ContainsCreated <TestClass1>());
var instance2 = SimpleIoc.Default.GetInstance <TestClass1>();
Assert.AreSame(instance0, instance2);
SimpleIoc.Default.Unregister(instance0);
Assert.IsTrue(SimpleIoc.Default.IsRegistered <TestClass1>());
Assert.IsFalse(SimpleIoc.Default.ContainsCreated <TestClass1>());
var instance3 = SimpleIoc.Default.GetInstance <TestClass1>();
Assert.AreSame(instance0, instance3);
}
public void Map_StateUnderTest_ExpectedBehavior9()
{
// Arrange
var unitUnderTest = this.CreateMapper();
TestClass1 source = new TestClass1()
{
Id = 1, Name = "John Doe"
};
TestClass2 destination = new TestClass2();
Action <IMappingOperationOptions> opts = (x) => { };
// Act
var result = unitUnderTest.Map((object)source, (object)destination, typeof(TestClass1), typeof(TestClass2), opts);
// Assert
result.ShouldNotBeNull();
result.ShouldBeOfType <TestClass2>();
var result2 = result as TestClass2;
result2.Id.ShouldBe(source.Id);
result2.Name.ShouldBe(source.Name);
destination.ShouldNotBeNull();
destination.Id.ShouldBe(source.Id);
destination.Name.ShouldBe(source.Name);
}
public unsafe void TypedReferenceTest2()
{
byte *addr;
var c = new TestClass1();
c.X = 1234;
var tr0 = __makeref(c);
addr = (byte *)&tr0;
Logging.Log((IntPtr)addr);
var valuePtr = *(IntPtr *)addr;
Logging.Log("Value: " + valuePtr);
addr += sizeof(IntPtr);
Logging.Log((IntPtr)addr);
var typePtr = *(IntPtr *)addr;
Logging.Log("Type: " + typePtr);
var tr = new TypedReference();
addr = (byte *)&tr;
Logging.Log((IntPtr)addr);
*(IntPtr *)addr = valuePtr;
Logging.Log("Value: " + *(IntPtr *)addr);
addr += sizeof(IntPtr);
Logging.Log((IntPtr)addr);
*(IntPtr *)addr = typeof(TestClass1).TypeHandle.Value;
Logging.Log("Type: " + *(IntPtr *)addr);
Logging.Log("__reftype: " + __reftype(tr));
Logging.Log("__refvalue: " + __refvalue(tr, TestClass1).X);
}
public void DatabaseCanDeleteObject()
{
TestClass1 c1 = new TestClass1();
c1.Boolean = true;
c1.Date = DateTime.Now;
c1.Name = "SuperName321";
c1.IntSixteen = 16;
c1.IntThirtyTwo = 32;
c1.IntSixtyFour = 64;
_database.Store(c1);
ObjectReference<TestClass1> result = _database.Search<TestClass1>(new { Name = "SuperName321" }).First();
Assert.IsNotNull(result.Object);
Assert.IsNotNull(result.Id);
Assert.AreEqual(c1.ToString(), result.Object.ToString());
result.Delete();
var ret = _database.Search<TestClass1>(new {Name = "SuperName321"});
Assert.IsTrue(!ret.Any());
}
public void CanWrite_ReturnsFalse_WhenObjectInCache()
{
var testObject = new TestClass1();
Expect.Once.On(cache).Method("Contains").With(testObject).Will(Return.Value(true));
Assert.IsFalse(writer.CanWrite(testObject, testObject.GetType()));
}
public static TestClass2 Create(TestClass1 input)
{
TestClass2 output = new TestClass2();
output._testValue = ((ITestInterface)input).TestValue;
return(output);
}
public void CanWrite_ReturnsFalse_IfExternalInstanceCannotProvide()
{
var testObject = new TestClass1();
Expect.Once.On(repository).Method("HasType").With(testObject.GetType()).Will(Return.Value(false));
Assert.IsFalse(writer.CanWrite(testObject, testObject.GetType()));
}
public void TestUnregisterInstance()
{
var instanceOriginal1 = new TestClass1();
SimpleIoc.Default.Reset();
SimpleIoc.Default.Register(() => instanceOriginal1);
var instance1 = SimpleIoc.Default.GetInstance <TestClass1>();
Assert.AreSame(instanceOriginal1, instance1);
SimpleIoc.Default.Unregister(instanceOriginal1);
try
{
var instance2 = SimpleIoc.Default.GetInstance <TestClass1>();
Assert.AreSame(instance1, instance2);
}
#if NETSTANDARD1_0
catch (System.InvalidOperationException)
#else
catch (ActivationException ex)
#endif
{
Assert.Fail("ActivationException was thrown");
}
}
public void Path_Root()
{
var target = new TestClass1();
target.Path("").Single().Should().Be(target);
target.Path(null).Single().Should().Be(target);
}
public void TestObjectProxyReadFromMap()
{
// Normal Test
Dictionary <string, object> map = new Dictionary <string, object>();
map.Add("Id", 7L);
map.Add("Name", "test");
ObjectProxy proxy = new ObjectProxy(typeof(TestClass1));
TestClass1 instance = new TestClass1();
proxy.ReadFromMap(instance, map);
Assert.AreEqual(7L, instance.Id);
Assert.AreEqual("test", instance.Name);
// Lower case test
map = new Dictionary <string, object>();
map.Add("id", 7L);
map.Add("name", "test");
instance = new TestClass1();
proxy.ReadFromMap(instance, map);
Assert.AreEqual(7L, instance.Id);
Assert.AreEqual("test", instance.Name);
// Convert types test
map = new Dictionary <string, object>();
map.Add("id", "7");
map.Add("name", "test");
instance = new TestClass1();
proxy.ReadFromMap(instance, map);
Assert.AreEqual(7L, instance.Id);
Assert.AreEqual("test", instance.Name);
}
public void TestObjectProxyCreateObject()
{
ObjectProxy proxy = new ObjectProxy(typeof(TestClass1));
TestClass1 instance = (TestClass1)proxy.CreateObject();
Assert.IsNotNull(instance);
}
public static void Default_7_DeserializeObject()
{
var jsonFactory = JsonFactory.GetInstance();
Assert.NotNull(jsonFactory);
var class1 = new TestClass1
{
TestBool1 = true,
TestInt1 = 3,
TestLong1 = 10,
TestString1 = "test"
};
var result = jsonFactory.SerializeObject(class1);
Assert.NotNull(result);
Assert.Equal("{\"TestBool1\":true,\"TestInt1\":3,\"TestLong1\":10,\"TestString1\":\"test\"}", result);
var deserializedClass1 = jsonFactory.DeserializeObject <TestClass1>(result);
Assert.Equal(class1.TestBool1, deserializedClass1.TestBool1);
Assert.Equal(class1.TestInt1, deserializedClass1.TestInt1);
Assert.Equal(class1.TestLong1, deserializedClass1.TestLong1);
Assert.Equal(class1.TestString1, deserializedClass1.TestString1);
class1 = new TestClass1
{
TestLong1 = 1000000000000
};
result = jsonFactory.SerializeObject(class1);
deserializedClass1 = jsonFactory.DeserializeObject <TestClass1>(result);
Assert.Equal(class1.TestLong1, deserializedClass1.TestLong1);
}
public void TestUnregisterInstanceWithKey()
{
var instanceOriginal1 = new TestClass1();
var instanceOriginal2 = new TestClass1();
const string key1 = "My key 1";
const string key2 = "My key 2";
SimpleIoc.Default.Reset();
SimpleIoc.Default.Register(() => instanceOriginal1, key1);
SimpleIoc.Default.Register(() => instanceOriginal2, key2);
var instance1 = SimpleIoc.Default.GetInstance <TestClass1>(key1);
Assert.AreSame(instanceOriginal1, instance1);
var instance2 = SimpleIoc.Default.GetInstance <TestClass1>(key2);
Assert.AreSame(instanceOriginal2, instance2);
SimpleIoc.Default.Unregister <TestClass1>(key1);
try
{
SimpleIoc.Default.GetInstance <TestClass1>(key1);
Assert.Fail("ActivationException was expected");
}
#if NETSTANDARD1_0
catch (System.InvalidOperationException)
#else
catch (ActivationException ex)
#endif
{
}
}
public static void Default_6_SerializeObject_WithList()
{
var jsonFactory = JsonFactory.GetInstance();
Assert.NotNull(jsonFactory);
var classList = new List <TestClass1>();
var class1 = new TestClass1
{
TestBool1 = true,
TestInt1 = 3,
TestString1 = "test"
};
classList.Add(class1);
var class2 = new TestClass1
{
TestInt1 = 5
};
classList.Add(class2);
var result = jsonFactory.SerializeObject(classList);
Assert.NotNull(result);
Assert.Equal("[{\"TestBool1\":true,\"TestInt1\":3,\"TestLong1\":0,\"TestString1\":\"test\"},{\"TestBool1\":false,\"TestInt1\":5,\"TestLong1\":0,\"TestString1\":null}]", result);
}
// Returns true if the expected result is right
// Returns false if the expected result is wrong
public bool PosTest4()
{
bool retVal = true;
TestLibrary.TestFramework.BeginScenario("PosTest4: create a multidimensional Array with user define Generic type..GetEnumerator method Returns an IEnumerator for the Array.");
try
{
int[] parameter = { c_MaxValue, c_MaxValue };
Array myArray = Array.CreateInstance(typeof(TestClass1 <int>), parameter);
TestClass1 <int>[,] myTemperatureArray = new TestClass1 <int> [c_MaxValue, c_MaxValue];
TestClass1 <int> generator = null;
for (int i = 0; i < c_MaxValue; i++)
{
for (int j = 0; j < c_MaxValue; j++)
{
generator = new TestClass1 <int>();
generator.Value = i * 4 + j;
myArray.SetValue(generator, i, j);
myTemperatureArray[i, j] = generator;
}
}
if (!ToAssureIenumeratorReturnandCorrect(myArray, myTemperatureArray))
{
TestLibrary.TestFramework.LogError("007", "Getenumerator method should returns an IEnumerator for the Array. ");
retVal = false;
}
}
catch (Exception e)
{
TestLibrary.TestFramework.LogError("008", "Unexpected exception: " + e);
retVal = false;
}
return(retVal);
}
public async Task ThenTheHandlerIsCalled()
{
// arrange
var testMessage = new TestClass1();
bool class1Called = false;
bool class2Called = false;
_sut.RegisterHandler <TestClass1>((message) =>
{
Assert.AreSame(testMessage, message);
class1Called = true;
return(Task.CompletedTask);
});
_sut.RegisterHandler <TestClass2>((message) =>
{
Assert.AreSame(testMessage, message);
class2Called = true;
return(Task.CompletedTask);
});
// act
await _sut.Consume(testMessage);
// assert
Assert.IsTrue(class1Called);
Assert.IsFalse(class2Called);
}
public void Scenario_Arrange_Assert_should_work_as_expected()
{
bool arrange1Called = false;
bool arrange2Called = false;
bool assert1Called = false;
bool assert2Called = false;
ForTest.Scenarios <TestClass1, TestClass2>()
.Arrange(t1 => arrange1Called = true).Assert(t2 => assert1Called = true)
.Arrange(t1 => arrange2Called = true).Assert(t2 => assert2Called = true)
.TestEach(scenario =>
{
var test1 = new TestClass1();
scenario.Arrange(test1);
var test2 = new TestClass2();
scenario.Assert(test2);
});
using (new AssertionScope())
{
arrange1Called.Should().BeTrue();
assert1Called.Should().BeTrue();
arrange2Called.Should().BeTrue();
assert2Called.Should().BeTrue();
}
}
public void TestInitialize()
{
int p1 = default(int);
double p2 = default(double);
testClass1TestInstance = new TestClass1(p1, p2);
}
public void TestGetAllInstances1()
{
SimpleIoc.Default.Reset();
const string key1 = "key1";
var instance1 = new TestClass1();
SimpleIoc.Default.Register(() => instance1, key1);
SimpleIoc.Default.Register <TestClass1>();
var instances = SimpleIoc.Default.GetAllInstances <TestClass1>().ToList();
Assert.AreEqual(2, instances.Count);
var getInstance1 = SimpleIoc.Default.GetInstance <TestClass1>(key1);
Assert.AreSame(instance1, getInstance1);
Assert.IsTrue(instances.Contains(instance1));
instances.Remove(instance1);
Assert.AreEqual(1, instances.Count);
var getInstance2 = SimpleIoc.Default.GetInstance <TestClass1>();
Assert.AreSame(instances[0], getInstance2);
SimpleIoc.Default.GetInstance <TestClass1>("key2");
instances = SimpleIoc.Default.GetAllInstances <TestClass1>().ToList();
Assert.AreEqual(3, instances.Count);
}
public void TestValue2()
{
var prop1 = Fake.Word;
var prop2a = Fake.Word;
var prop2b = Fake.Word;
var input = new TestClass1
{
Prop1 = prop1,
Prop2a = prop2a,
Prop2b = prop2b// + "s"
};
var expctd = new TestClass1D7
{
type = "testclass1",
field_prop1 = und.Values(prop1),
field_prop2 = und.Value1_2(prop2a, prop2b)
};
var actual = D7FieldMapper.Map(input) as TestClass1D7;
var expctdStr = Json.Write(expctd, true);
var actualStr = Json.Write(actual, true);
actualStr.MustBe(expctdStr);
}
public void TestGetInstancesWithInstanceGeneric()
{
const string key1 = "MyKey1";
const string key2 = "MyKey2";
var instanceOriginal1 = new TestClass1();
var instanceOriginal2 = new TestClass1();
SimpleIoc.Default.Reset();
SimpleIoc.Default.Register <ITestClass>(() => instanceOriginal1, key1);
SimpleIoc.Default.Register <ITestClass>(() => instanceOriginal2, key2);
var instance1 = SimpleIoc.Default.GetInstance <ITestClass>(key1);
var instance2 = SimpleIoc.Default.GetInstance <ITestClass>(key1);
var instance3 = SimpleIoc.Default.GetInstance <ITestClass>(key2);
Assert.IsNotNull(instance1);
Assert.IsNotNull(instance2);
Assert.IsNotNull(instance3);
Assert.IsInstanceOfType(instance1, typeof(TestClass1));
Assert.IsInstanceOfType(instance2, typeof(TestClass1));
Assert.IsInstanceOfType(instance3, typeof(TestClass1));
Assert.AreSame(instance1, instance2);
Assert.AreNotSame(instance1, instance3);
}
public void TestObjectProxyFactoryFromMap()
{
// Normal Test
Dictionary <string, object> map = new Dictionary <string, object>();
map.Add("Id", 7L);
map.Add("Name", "test");
TestClass1 instance = ObjectProxyFactory.FromMap <TestClass1>(map);
Assert.AreEqual(7L, instance.Id);
Assert.AreEqual("test", instance.Name);
// Lower case test
map = new Dictionary <string, object>();
map.Add("id", 7L);
map.Add("name", "test");
instance = ObjectProxyFactory.FromMap <TestClass1>(map);
Assert.AreEqual(7L, instance.Id);
Assert.AreEqual("test", instance.Name);
// Convert types test
map = new Dictionary <string, object>();
map.Add("id", "7");
map.Add("name", "test");
instance = ObjectProxyFactory.FromMap <TestClass1>(map);
Assert.AreEqual(7L, instance.Id);
Assert.AreEqual("test", instance.Name);
}
public void ConfigRetriever_ManualWithUrl()
{
var url = $"{ConsulHttpSchema}://{ConsulHost}:{ConsulPort}";
var retriever = new ConsulRetriever(url, ConsulAclToken);
var logger = new StdoutLogger();
var configRetriever = new ConfigRetriever <TestClass1>(retriever, logger);
var resultTask = configRetriever.Fill();
var result = resultTask.Result;
var expected = new TestClass1()
{
PropTestClass1_1 = new TestClass1_1()
{
PropInt = 10,
PropDouble = 10.10
},
PropTestClass2 = new TestClass2()
{
PropString = "some string",
PropTestClass3 = new TestClass3()
{
PropBool = true,
PropLong = 1000,
PropString = "some string"
}
}
};
result.Should().BeEquivalentTo(expected);
}
public void Path_Typed_Long()
{
var target = new TestClass1();
var result = target.Path(".<System.String>").ToList();
result.Should().BeEquivalentTo(new [] { "test" });
}
public void Extend()
{
var test = new TestExpando();
test.Field1 = "Value from Real Object";
test.Property1 = "ValueFromProp";
dynamic test2 = new ExpandoObject();
test2.ExField1 = "Value from Expando";
var exField2 = new string[] { "el1", "el2" };
test2.ExField2 = exField2;
dynamic target = CQ.Extend(null, test);
Assert.AreEqual("Value from Real Object", target.Field1, "Appended a regular object field to an expando object");
Assert.AreEqual("ValueFromProp", target.Property1, "Appended a regular object property to an expando object");
CQ.Extend(target, test2);
Assert.AreEqual("Value from Expando", target.ExField1, "Appended an expando object property to an expando object");
Assert.AreEqual(exField2, target.ExField2, "Appended a regular object property to an expando object");
// Test "extending" regular objects (property copy)
TestClass1 t1 = new TestClass1();
t1.Prop1 = "value1";
t1.Prop2 = "value2";
TestClass2 t2 = new TestClass2();
t2.Prop2 = "class2value2";
t2.Prop3 = "class2vlaue3";
CQ.Extend(t1, t2);
Assert.AreEqual("value1", t1.Prop1, "Target prop1 unchanged");
Assert.AreEqual("class2value2", t1.Prop2, "Target prop2 updated");
}
public void TestContainsInstance()
{
SimpleIoc.Default.Reset();
const string key1 = "My key";
var instance = new TestClass1();
SimpleIoc.Default.Register(() => instance, key1);
SimpleIoc.Default.Register <TestClass2>();
Assert.IsFalse(SimpleIoc.Default.ContainsCreated <TestClass1>());
Assert.IsFalse(SimpleIoc.Default.ContainsCreated <TestClass1>(key1));
Assert.IsFalse(SimpleIoc.Default.ContainsCreated <TestClass2>());
Assert.IsFalse(SimpleIoc.Default.ContainsCreated <TestClass3>());
SimpleIoc.Default.GetInstance <TestClass1>(key1);
Assert.IsTrue(SimpleIoc.Default.ContainsCreated <TestClass1>());
Assert.IsTrue(SimpleIoc.Default.ContainsCreated <TestClass1>(key1));
Assert.IsFalse(SimpleIoc.Default.ContainsCreated <TestClass2>());
Assert.IsFalse(SimpleIoc.Default.ContainsCreated <TestClass3>());
SimpleIoc.Default.GetInstance <TestClass2>();
Assert.IsTrue(SimpleIoc.Default.ContainsCreated <TestClass1>());
Assert.IsTrue(SimpleIoc.Default.ContainsCreated <TestClass1>(key1));
Assert.IsTrue(SimpleIoc.Default.ContainsCreated <TestClass2>());
Assert.IsFalse(SimpleIoc.Default.ContainsCreated <TestClass3>());
}
public void CompareToTest1()
{
Random r = new Random();
string[] s = new string[] { "QWERTY", "UIOP", "ASDFGHJKL", "zxcvbnm,./", "1234567&*()" };
List <TestClass1> list = new List <TestClass1>();
DateTime start = DateTime.UtcNow;
for (int i = 0; i < 100000; i++)
{
TestClass1 t = new TestClass1(r.Next(), r.Next(), s[r.Next() % 5]);
int insertionIndex = list.BinarySearch(t);
if (insertionIndex < 0)
{
insertionIndex = ~insertionIndex;
}
list.Add(t);
}
DateTime end = DateTime.UtcNow;
TimeSpan duration = end - start;
Debug.WriteLine(duration);
}
public void TestMethod1()
{
TestClass1 tc1 = new TestClass1()
{
MyProperty = 564
};
tc1.TestClass2Property = new TestClass2()
{
TestClass1Property = tc1,
IntProperty = 5,
GuidProperty = Guid.NewGuid(),
DateTimeProperty = DateTime.Now,
StringBuilderProperty = new StringBuilder("adfdsfas")
};
QuicklySerializer ser = new QuicklySerializer();
var bytes = ser.FastWriteBytes(tc1);
var tc2 = ser.FastReadBytes <TestClass1>(bytes);
Assert.Equal(tc1.MyProperty, tc2.MyProperty);
Assert.NotNull(tc2.TestClass2Property);
Assert.Equal(tc1.TestClass2Property.TestClass1Property, tc1);
Assert.Equal(tc1.TestClass2Property.IntProperty, tc2.TestClass2Property.IntProperty);
Assert.Equal(tc1.TestClass2Property.GuidProperty, tc2.TestClass2Property.GuidProperty);
Assert.Equal(tc1.TestClass2Property.DateTimeProperty, tc2.TestClass2Property.DateTimeProperty);
Assert.Equal(tc1.TestClass2Property.StringBuilderProperty.ToString(), tc2.TestClass2Property.StringBuilderProperty.ToString());
}
public void TestValue2()
{
var prop1 = Fake.Word;
var prop2a = Fake.Word;
var prop2b = Fake.Word;
var input = new TestClass1
{
Prop1 = prop1,
Prop2a = prop2a,
Prop2b = prop2b// + "s"
};
var expctd = new TestClass1D7
{
type = "testclass1",
field_prop1 = und.Values(prop1),
field_prop2 = und.Value1_2(prop2a, prop2b)
};
var actual = D7FieldMapper.Map(input) as TestClass1D7;
var expctdStr = Json.Write(expctd, true);
var actualStr = Json.Write(actual, true);
actualStr.MustBe(expctdStr);
}
static void Main(string[] args)
{
TestClass1 ts = new TestClass1();
ts.Show();
Console.ReadLine();
}
public void ToString_WithPropertyNullAndEndPropertyValueType_ReturnsEmptyString()
{
var obj = new TestClass1 {Class0 = null};
var result = obj.TryFetch(o => o.Class0.IntProperty).ToString();
Assert.That(result, Is.EqualTo("0"));
}
public void Can_create_from_real_types()
{
var sut = new TestClass1 {Property = new TestClass2 {Property = "test"}}.ToDynamic();
Assert.IsInstanceOf<ExpandoObject>(sut);
Assert.IsInstanceOf<ExpandoObject>(sut.Property);
Assert.AreEqual("test", sut.Property.Property);
}
public void Test1()
{
IWindsorContainer container = new WindsorContainer();
var testClass1 = new TestClass1();
container.Kernel.Register(Component.For<ITestInterface1>().Instance(testClass1));
ITestInterface1 iti = container.Resolve<ITestInterface1>();
Assert.AreSame(iti, testClass1);
}
public void JsonNetCharacterTest1(string str)
{
var jsonNetSerializer = new JsonNetSerializer();
var sut = new TestClass1 {Name = str};
var result = jsonNetSerializer.ToJson(sut);
Assert.That(str, Is.EqualTo(sut.Name));
Assert.That(result.Contains(str));
}
public void Sets_value_of_id_property()
{
var guid = Guid.NewGuid();
var instance = new TestClass1();
mocker.GetMock<IGetNameOfIdPropertyForType>().Setup(a => a.GetNameOfIdProperty(It.IsAny<Type>())).Returns("Id");
mocker.Resolve<SetValueOfIdProperty>().SetId(instance, guid.ToString());
Assert.AreEqual(guid.ToString(), instance.Id);
}
public void CanCopyProperties()
{
var t1Obj = new TestClass1 { dummyInt = 0, dummyList = new List<int> { 1, 2 }, dummyString = "str", exclusivePropertyTestClass1=4, mismatchingTypeProperty=3.2 };
var t2Obj = new TestClass2 { exclusivePropertyTestClass2 = 3, mismatchingTypeProperty=5 };
Helpers.CopyProperties(t1Obj, t2Obj);
Assert.Equal(t1Obj.dummyInt, t2Obj.dummyInt);
Assert.Equal(t1Obj.dummyString, t2Obj.dummyString);
Assert.Equal(t1Obj.dummyList, t2Obj.dummyList);
Assert.Equal(t2Obj.exclusivePropertyTestClass2, 3);
Assert.Equal(t2Obj.mismatchingTypeProperty, 5);
}
public static void Main()
{
TestInterface ti1 = new TestClass1();
ti1.TestMethod();
TestInterface ti2 = new TestClass2();
ti2.TestMethod();
OutputInterface(ti1);
OutputInterface(ti2);
}
public void InvokeGenericMethod()
{
TestClass1 tc1 = new TestClass1();
MethodInvokingFactoryObject mcfo = new MethodInvokingFactoryObject();
mcfo.TargetType = typeof(Activator);
mcfo.TargetMethod = "CreateInstance<Spring.Objects.TestObject>";
mcfo.AfterPropertiesSet();
object obj = mcfo.GetObject();
Assert.IsNotNull(obj);
Assert.IsTrue(obj is TestObject);
}
public void GetSingletonNonStatic()
{
TestClass1 tc1 = new TestClass1();
MethodInvokingFactoryObject mcfo = new MethodInvokingFactoryObject();
mcfo.TargetObject = tc1;
mcfo.TargetMethod = "Method1";
mcfo.AfterPropertiesSet();
int i = (int) mcfo.GetObject();
Assert.IsTrue(i == 1);
i = (int) mcfo.GetObject();
Assert.IsTrue(i == 1);
Assert.IsTrue(mcfo.IsSingleton);
}
public void AutomagicInit__can_handle_boolean()
{
//ARRANGE
var cmdArgs = new string[] { @"param4" };
//ACT
var args = CommandlineArguments.ParseCommandLineArguments(cmdArgs);
TestClass1 tc = new TestClass1();
args.AutomagicInit(tc);
//ASSERT
tc.param4.Should().BeTrue();
}
public void Test3()
{
var ta = TypeAccessor.GetAccessor<TestClass1>();
var obj = new TestClass1
{
Class2 = new TestClass2 {
Class3 = new TestClass3 {
Class4 = new TestClass4 { Field1 = 50 }
}}};
var value = ta["Class2.Class3.Class4.Field1"].GetValue(obj);
Assert.That(value, Is.EqualTo(50));
}
public void aa2()
{
var obj = new TestClass1();
var cecilTestClass1 = CurrentAssembly.FindRuntimeType(typeof(TestClass1));
cecilTestClass1.Methods.First(method => method.Name == "TestMethod");
var method1 = cecilTestClass1.GetMethodByName("TestMethod");
var dynMethod = Recompiler.RecompileMethod(method1);
var result = dynMethod.Invoke(obj, new object[] { obj });
Assert.AreEqual("ab", (string)result);
Assert.AreEqual(obj.a, 1);
}
public void Write_GetInstanceFromRepository()
{
var testObject = new TestClass1();
var parentNode = NewMock<INodeWriter>();
var classNode = NewMock<INodeWriter>();
StubTypeMapper(typeof (int));
Expect.Once.On(cache).Method("Add").With(testObject).Will(Return.Value(7));
Expect.Once.On(document).Method("CreateAppObjectElement").With("System.Int32", 7, parentNode).Will(
Return.Value(classNode));
Expect.Once.On(classNode).Method("Dispose").WithNoArguments();
writer.Write(testObject, parentNode, typeof (int));
}
public void NavigateForward_NavigateToModelThatIsAlreadyInChainBeforeCurrent_ChainAfterTheTargetIsEmpty()
{
var kernel = NinjectBootstrapper.GetKernel(new TestModule());
var firstClassMock = new Mock<ViewModelBaseFactory<TestClass1>>();
TestClass1 instance1 = new TestClass1();
firstClassMock.Setup(x => x.Get(It.IsAny<object>())).Returns(instance1);
var secondClassMock = new Mock<ViewModelBaseFactory<TestClass2>>();
TestClass2 instance2 = new TestClass2();
secondClassMock.Setup(x => x.Get(It.IsAny<object>())).Returns(instance2);
var thirdClassMock = new Mock<ViewModelBaseFactory<TestClass3>>();
TestClass3 instance3 = new TestClass3();
thirdClassMock.Setup(x => x.Get(It.IsAny<object>())).Returns(instance3);
var fourthClassMock = new Mock<ViewModelBaseFactory<TestClass4>>();
TestClass4 instance4 = new TestClass4();
fourthClassMock.Setup(x => x.Get(It.IsAny<object>())).Returns(instance4);
var factory = new ChildrenViewModelsFactory(new List<IViewModelFactory>
{
firstClassMock.Object,
secondClassMock.Object,
thirdClassMock.Object,
fourthClassMock.Object,
});
kernel.Bind<IViewModelNavigator>()
.To<ViewModelNavigator>()
.WithConstructorArgument("childrenViewModelsFactory", factory);
var nav = kernel.Get<IViewModelNavigator>();
nav.NavigateForward(instance1);
nav.NavigateForward<TestClass2>(instance1, null);
nav.NavigateForward<TestClass3>(instance2, null);
nav.NavigateForward<TestClass4>(instance3, null);
nav.NavigateForward<TestClass1>(instance4, null);
FieldInfo storage = typeof(ViewModelNavigator).GetField("_storage", BindingFlags.NonPublic | BindingFlags.Instance);
// ReSharper disable once PossibleNullReferenceException
ViewModelStorage store = (ViewModelStorage) storage.GetValue(nav);
FieldInfo order = typeof(ViewModelStorage).GetField("_navigationOrder", BindingFlags.NonPublic | BindingFlags.Instance);
// ReSharper disable once PossibleNullReferenceException
LinkedList<BaseViewModel> orderVal = (LinkedList<BaseViewModel>)order.GetValue(store);
Assert.IsTrue(orderVal.Count == 1);
}
public void ExtendPocoFromDynamic()
{
TestClass1 t1 = new TestClass1();
t1.Prop1 = "value1";
t1.Prop2 = "value2";
dynamic t2 = new JsObject();
t2.Prop2 = "class2value2";
t2.Prop3 = "class2vlaue3";
CQ.Extend(t1, t2);
Assert.AreEqual("value1", t1.Prop1, "Target prop1 unchanged");
Assert.AreEqual("class2value2", t1.Prop2, "Target prop2 updated");
}
public void RoundtripTest1()
{
Directory.CreateDirectory(_path);
Cabinet.Initialise(_path);
var x = new TestClass1();
x.Value1 = "Hey!";
x.Value2 = "You!";
Cabinet.SetAsync(x, "Series X", "Season Y", 5).Wait();
var y = Cabinet.GetAsync<TestClass1>("Series X", "Season Y", 5).Result;
Cabinet.SetAsync(y, "asdf!").Wait();
var z = Cabinet.GetAsync<TestClass1>("asdf!").Result;
Assert.AreEqual(x, z);
}
public void ExtendPoco()
{
// Test "extending" regular objects (property copy)
TestClass1 t1 = new TestClass1();
t1.Prop1 = "value1";
t1.Prop2 = "value2";
TestClass2 t2 = new TestClass2();
t2.Prop2 = "class2value2";
t2.Prop3 = "class2vlaue3";
CQ.Extend(t1, t2);
Assert.AreEqual("value1", t1.Prop1, "Target prop1 unchanged");
Assert.AreEqual("class2value2", t1.Prop2, "Target prop2 updated");
}
// Returns true if the expected result is right
// Returns false if the expected result is wrong
public bool PosTest2()
{
bool retVal = true;
TestLibrary.TestFramework.BeginScenario("PosTest1: override isByRefImpl and Only these type which BaseType is BaseClass Return true ,TestClass1 as test object ");
try
{
TestClass1 myobject = new TestClass1();
if (myobject.GetType().IsByRef)
{
TestLibrary.TestFramework.LogError("003", "TestClass1 is not Passed by reference.");
retVal = false;
}
}
catch (Exception e)
{
TestLibrary.TestFramework.LogError("004", "Unexpected exception: " + e);
retVal = false;
}
return retVal;
}
public void CheckDictionaryAddAndGetWithInstanceTemplate()
{
ITypeInstanceDictionary dict = new TypeInstanceDictionary();
TestClass1 class1Instance1 = new TestClass1();
class1Instance1.StringProperty1 = "TestVal1";
class1Instance1.BoolProperty2 = true;
TestClass1 class1Instance2 = new TestClass1();
class1Instance2.StringProperty1 = "TestVal2";
class1Instance2.BoolProperty2 = false;
dict.Add<TestClass1, int>(class1Instance1, 1);
dict.Add<TestClass1, int>(class1Instance2, 2);
Assert.IsNotNull(dict.Get<TestClass1, int>(1));
Assert.IsNotNull(dict.Get<TestClass1, int>(2));
Assert.IsTrue(Type.ReferenceEquals(class1Instance1, dict.Get<TestClass1, int>(1)));
Assert.IsTrue(Type.ReferenceEquals(class1Instance2, dict.Get<TestClass1, int>(2)));
}
public void Write_CachesTheObjectAndEnodesClassTypeObject()
{
var testObject = new TestClass1();
var parentNode = NewMock<INodeWriter>();
var classNode = NewMock<INodeWriter>();
var membersNode = NewMock<INodeWriter>();
StubTypeMapper();
Expect.Once.On(document).Method("CreateClassElement").With(testObject.GetType().ToString(), 7, parentNode).
Will(
Return.Value(classNode));
Expect.Once.On(document).Method("CreateMembersElement").With(classNode).Will(Return.Value(membersNode));
Expect.Once.On(cache).Method("Add").With(testObject).Will(Return.Value(7));
Expect.Once.On(memberWriter).Method("Write").With(testObject, membersNode, testObject.GetType());
Expect.Once.On(baseTypeMembersWriter).Method("WriteMembers").With(testObject, classNode,
testObject.GetType());
Expect.Once.On(classNode).Method("Dispose").WithNoArguments();
Expect.Once.On(membersNode).Method("Dispose").WithNoArguments();
writer.Write(testObject, parentNode, parentNode.GetType());
}
public bool NegTest1()
{
bool retVal = true;
TestLibrary.TestFramework.BeginScenario("NegTest1:The object does not implement IConvertible");
try
{
TestClass1 objVal = new TestClass1();
ulong ulongVal = Convert.ToUInt64(objVal);
TestLibrary.TestFramework.LogError("N001", "The object does not implement IConvertible but not throw exception");
retVal = false;
}
catch (InvalidCastException) { }
catch (Exception e)
{
TestLibrary.TestFramework.LogError("N002", "Unexpect exception:" + e);
retVal = false;
}
return retVal;
}
public void CanWrite_ReturnsTrue_WhenObjectNotInCache()
{
var testObject = new TestClass1();
Expect.Once.On(cache).Method("Contains").With(testObject).Will(Return.Value(false));
Assert.IsTrue(writer.CanWrite(testObject, testObject.GetType()));
}
public TestClass2(TestClass1 class1)
{
this.class1 = class1;
}
public void TryFetch_WithPropertyNull_ReturnsEmptyString()
{
var obj = new TestClass1 {Class0 = null};
var result = obj.TryFetch(o => o.Class0.StringProperty);
Assert.That(result, Is.Empty);
}
public void TryFetch_WithObjectGraphWithMethodCall_ReturnsValue()
{
var obj0 = new TestClass0 {StringProperty = Any.String};
var obj1 = new TestClass1 {Class0 = obj0};
string result = obj1.TryFetch(o => o.Class0.GetString());
Assert.That(result, Is.EqualTo(Any.String));
}
public void TryFetch_WithPropertyNullAndFallbackText_ReturnsFallbackText()
{
var obj = new TestClass1 {Class0 = null};
var result = obj.TryFetch(o => o.Class0.IntProperty).ToString(Any.String);
Assert.That(result, Is.EqualTo(Any.String));
}
