// Returns true if the expected result is right
// Returns false if the expected result is wrong
public bool PosTest3()
{
bool retVal = true;
TestLibrary.TestFramework.BeginScenario("PosTest3: Calling Item Property ,T is user define type. ");
try
{
IList <MyTestClass> myList = new List <MyTestClass>();
MyTestClass expectValue = new MyTestClass();
expectValue.ID = 100;
myList.Add(expectValue);
int index = 0;
MyTestClass actualValue = myList[index];
if (!actualValue.Equals(expectValue))
{
TestLibrary.TestFramework.LogError("003.1", "the method of Item property get can not return the correct value.");
retVal = false;
}
}
catch (Exception e)
{
TestLibrary.TestFramework.LogError("003.0", "Unexpected exception: " + e);
retVal = false;
}
return(retVal);
}
protected override void Context()
{
base.Context();
Source = Builder<MyTestClass>.CreateNew().Build();
Target = new MyTestClass();
}
public void CanWriteInTransactionScopeAndReadOutsideOfTransactionScope()
{
using (var server = GetNewServer(requestedStorage: "esent"))
{
EnsureDtcIsSupported(server);
using (var store = new DocumentStore {
Url = "http://localhost:8079"
}.Initialize())
{
var testEntity = new MyTestClass()
{
SomeText = "Foo"
};
using (var ts = new TransactionScope())
{
using (var session = store.OpenSession())
{
session.Store(testEntity);
session.SaveChanges();
}
ts.Complete();
}
using (var session = store.OpenSession())
{
session.Advanced.AllowNonAuthoritativeInformation = false;
var testEntityRetrieved = session.Load <MyTestClass>(testEntity.Id);
Assert.Equal(testEntityRetrieved.SomeText, testEntity.SomeText);
}
}
}
}
public void SetUp()
{
_faker = new FackerProgram.Faker();
_faker.DTOAdd(typeof(Foo));
_faker.DTOAdd(typeof(Bar));
result = _faker.Create <MyTestClass>();
}
public void ExitNullArgumentValidLevel3Test()
{
testClass1 = new MyTestClass();
testClass1.MyString = "Hello";
testClass1.MyPropertyTestClass = new MyPropertyTestClass();
testClass1.MyPropertyTestClass.MyOtherString = "Hello";
}
public void GetValueFromResponse_Returns_Null_Not_Found_Property()
{
var userServiceMock = new Mock <IUserService>();
var userService = userServiceMock.Object;
var entityServiceMock = new Mock <IEntityService>();
var entityService = entityServiceMock.Object;
var att = new FilterAllowedOutgoingContentAttribute(typeof(IEnumerable <ContentItemBasic>), "DontFind", userService, entityService);
var val = new List <ContentItemBasic>()
{
new ContentItemBasic()
};
var container = new MyTestClass()
{
MyList = val
};
var result = att.GetValueFromResponse(
new ObjectContent(typeof(MyTestClass),
container,
new JsonMediaTypeFormatter(),
new MediaTypeHeaderValue("html/text")));
Assert.AreEqual(null, result);
}
public void DbAppSetting_customObect()
{
MyTestClassSetting setting = new MyTestClassSetting();
Assert.IsTrue(setting.InitialValue.SomeProperty == 1);
Assert.IsTrue(setting.InitialValue.SomeOtherProperty == "Test");
Assert.IsTrue(setting.InternalValue.SomeProperty == 1);
Assert.IsTrue(setting.InternalValue.SomeOtherProperty == "Test");
MyTestClass testClass = new MyTestClass();
testClass.SomeProperty = 2;
testClass.SomeOtherProperty = "Test2";
string jsonTestClass = new JavaScriptSerializer().Serialize(testClass);
DbAppSettingDto settingDto = new DbAppSettingDto()
{
Key = setting.FullSettingName, Value = jsonTestClass, Type = setting.TypeString
};
setting.From(settingDto);
Assert.IsTrue(setting.InitialValue.SomeProperty == 1);
Assert.IsTrue(setting.InitialValue.SomeOtherProperty == "Test");
Assert.IsTrue(setting.InternalValue.SomeProperty == 2);
Assert.IsTrue(setting.InternalValue.SomeOtherProperty == "Test2");
DbAppSettingDto toDto = setting.ToDto();
Assert.IsTrue(toDto.ApplicationKey == settingDto.ApplicationKey);
Assert.IsTrue(toDto.Key == settingDto.Key);
Assert.IsTrue(toDto.Type == settingDto.Type);
Assert.IsTrue(toDto.Value.Equals(settingDto.Value, StringComparison.InvariantCultureIgnoreCase));
}
public void CanWriteInTransactionScopeAndReadFromAnotherTransactionScope()
{
using (GetNewServer())
using (var store = new DocumentStore {
Url = "http://localhost:8080"
}.Initialize())
{
var testEntity = new MyTestClass()
{
SomeText = "Foo"
};
using (var ts = new TransactionScope())
{
using (var session = store.OpenSession())
{
session.Store(testEntity);
session.SaveChanges();
}
ts.Complete();
}
using (var ts = new TransactionScope())
{
using (var session = store.OpenSession())
{
session.Advanced.AllowNonAuthoritiveInformation = false;
var testEntityRetrieved = session.Load <MyTestClass>(testEntity.Id);
Assert.Equal(testEntityRetrieved.SomeText, testEntity.SomeText);
}
}
}
}
public void CanWriteInTransactionScopeAndReadFromAnotherTransactionScope()
{
using (var server = GetNewServer(requestedStorage: "esent"))
{
EnsureDtcIsSupported(server);
using (var store = new DocumentStore { Url = "http://localhost:8079" }.Initialize())
{
var testEntity = new MyTestClass() { SomeText = "Foo" };
using (var ts = new TransactionScope())
{
using (var session = store.OpenSession())
{
session.Store(testEntity);
session.SaveChanges();
}
ts.Complete();
}
using (var ts = new TransactionScope())
{
using (var session = store.OpenSession())
{
session.Advanced.AllowNonAuthoritativeInformation = false;
var testEntityRetrieved = session.Load<MyTestClass>(testEntity.Id);
Assert.Equal(testEntityRetrieved.SomeText, testEntity.SomeText);
}
}
}
}
}
// 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: Calling indexof method ,T is user define type,the item is not exist int the List. ");
try
{
IList <MyTestClass> myList = new List <MyTestClass>();
MyTestClass myTest = null;
for (int i = 1; i <= 10; i++)
{
myTest = new MyTestClass();
myTest.ID = i;
myList.Add(myTest);
}
int expectValue = -1;
myTest = new MyTestClass();
myTest.ID = 100;
int actualValue = myList.IndexOf(myTest);
if (actualValue != expectValue)
{
TestLibrary.TestFramework.LogError("004.1", "Calling IndexOf method return a value correctly.");
retVal = false;
}
}
catch (Exception e)
{
TestLibrary.TestFramework.LogError("004.0", "Unexpected exception: " + e);
retVal = false;
}
return(retVal);
}
public void Setup()
{
List <byte[]> bytesList = new List <byte[]>(Size);
List <byte[]> bytesList2 = new List <byte[]>(Size);
List <byte[]> bytesList3 = new List <byte[]>(Size);
List <MyTestClass> testClasses = new List <MyTestClass>(Size);
var bogus = new Bogus.Randomizer();
for (int i = 0; i < Size; i++)
{
MyTestClass myTestClass = new MyTestClass();
myTestClass.BoolProp = bogus.Bool();
myTestClass.IntList = new List <int>(100);
for (int j = 0; j < 100; j++)
{
myTestClass.IntList.Add(bogus.Int());
}
myTestClass.StringProp = bogus.String(10, 100);
myTestClass.StringProp2 = bogus.String(10, 100);
bytesList.Add(JsonSerializer.Serialize(myTestClass));
bytesList3.Add(System.Text.Json.JsonSerializer.SerializeToUtf8Bytes(myTestClass));
bytesList2.Add(MessagePack.MessagePackSerializer.Typeless.Serialize(myTestClass, ContractlessStandardResolver.Options));
testClasses.Add(myTestClass);
}
_serializedObjectsUtf8Json = bytesList.ToArray();
_serializedObjectsMessagePack = bytesList2.ToArray();
_serializedObjectsTextJson = bytesList3.ToArray();
_testClasses = testClasses.ToArray();
}
// Returns true if the expected result is right
// Returns false if the expected result is wrong
public bool NegTest1()
{
bool retVal = true;
TestLibrary.TestFramework.BeginScenario("NegTest1: index is not a valid index in the IList.");
try
{
IList <MyTestClass> myList = new List <MyTestClass>();
MyTestClass expectValue = new MyTestClass();
expectValue.ID = 100;
myList.Add(expectValue);
int index = 100;
MyTestClass actualValue = myList[index];
TestLibrary.TestFramework.LogError("101.1", "ArgumentOutOfRangeException should be caught.");
retVal = false;
}
catch (ArgumentOutOfRangeException)
{
}
catch (Exception e)
{
TestLibrary.TestFramework.LogError("101.0", "Unexpected exception: " + e);
retVal = false;
}
return(retVal);
}
public void _ConditionalValue_IsConvertedToTheSameInstance_WhenValuePresent()
{
var myValue = new MyTestClass();
MyTestClass conditionalValue = ConditionalValue.From(new MyTestClass());
(myValue == conditionalValue).Should().BeFalse();
}
public async Task GetDocuments_ShouldSucceed()
{
const int NUM_DOCS = 3;
var postDocResponses = new PostDocumentResponse <MyTestClass> [NUM_DOCS];
for (int i = 0; i < NUM_DOCS; i++)
{
var document = new MyTestClass {
Message = "Test " + i
};
postDocResponses[i] = await _docClient.PostDocumentAsync(_testCollection, document);
}
var getDocsResponse = await _docClient.GetDocumentsAsync <MyTestClass>(
_testCollection,
postDocResponses.Select(r => r._key).ToList());
Assert.Equal(NUM_DOCS, getDocsResponse.Count);
for (int i = 0; i < NUM_DOCS; i++)
{
var getDocResponse = getDocsResponse.FirstOrDefault(doc => doc._key == postDocResponses[i]._key);
Assert.NotNull(getDocResponse);
Assert.Equal(postDocResponses[i]._rev, getDocResponse._rev);
Assert.Equal(postDocResponses[i]._id, getDocResponse._id);
}
}
public void PerformOnConnection_Verify_Mapper_Called_On_DataReader()
{
IResultMapper <MyTestClass> mockMapper = MockRepository.GenerateMock <IResultMapper <MyTestClass> >();
var mockTestClass = new MyTestClass();
this.DataReader.Stub(x => x.Read())
.Repeat
.Once()
.Return(true);
//mock no fields so that no query structure is populated as we do not care about
//it in this test
this.DataReader.Stub(x => x.FieldCount)
.Return(0);
mockMapper.Expect(x => x.MapResult(Arg <IDataReader> .Is.Equal(this.DataReader), Arg <QueryResultStructure> .Is.Anything))
.Return(mockTestClass);
var result = RetrievalQueryExecutorBuilder <MyTestClass> .ForQuery("QUERY")
.WithCustomResultMapper(mockMapper)
.Build()
.PerformOnConnection(this.Connection);
mockMapper.VerifyAllExpectations();
Assert.AreSame(mockTestClass, result.First(), "Did not return the expected mapped object");
}
public static MyTestClass BuildMyTestClass()
{
MyTestClass myTestClass = new MyTestClass();
myTestClass._id = new ObjectId("testclassid");
myTestClass.myString = "Hello World!";
myTestClass.myInt = 100;
myTestClass.myBool = true;
myTestClass.myFloat = 0.1234567f;
myTestClass.myStringArray = new string[] { "ar_one", "ar_two", "ar_three" };
myTestClass.myStringList = new List <string>()
{
"list_one", "list_two", "list_three"
};
myTestClass.myFloatArray = new float[] { 0.1f, 0.12f, 1.23f };
myTestClass.myIntList = new List <int>()
{
3, 2, 1
};
myTestClass.myDate = DateTime.Now.ToUniversalTime();
// this.myPlayerInfo = new PlayerInfo("Randy", 10, 1234);
myTestClass.mySpecialItem = new TestItem("Special", 2, 299);
myTestClass.myInventory.Add(new TestItem("Shield", 1, 100));
myTestClass.myInventory.Add(new TestItem("Potion", 1, 100));
myTestClass.myInventory.Add(new TestItem("Sword", 100, 0));
return(myTestClass);
}
public void CanWriteInTransactionScopeAndReadOutsideOfTransactionScope()
{
using(GetNewServer())
using (var store = new DocumentStore { Url = "http://localhost:8080" }.Initialize())
{
var testEntity = new MyTestClass() {SomeText = "Foo"};
using (var ts = new TransactionScope())
{
using (var session = store.OpenSession())
{
session.Store(testEntity);
session.SaveChanges();
}
ts.Complete();
}
using (var session = store.OpenSession())
{
session.Advanced.AllowNonAuthoritiveInformation = false;
var testEntityRetrieved = session.Load<MyTestClass>(testEntity.Id);
Assert.Equal(testEntityRetrieved.SomeText, testEntity.SomeText);
}
}
}
public void Feature_Equals_GetHashCode_Contract_Properties_Of_Objects()
{
// order of keys should not matter
var leftProp = new MyTestClass
{
StringProperty = "Hello, GeoJSON !",
EnumProperty = MyTestEnum.Value1,
IntProperty = -1,
BooleanProperty = true,
DateTimeProperty = DateTime.Now,
DoubleProperty = 1.2345d
};
var left = new Net.Feature.Feature(new Point(new GeographicPosition(10, 10)), leftProp);
var rightProp = new MyTestClass
{
BooleanProperty = true,
DateTimeProperty = DateTime.Now,
DoubleProperty = 1.2345d,
EnumProperty = MyTestEnum.Value1,
IntProperty = -1,
StringProperty = "Hello, GeoJSON !"
};
var right = new Net.Feature.Feature(new Point(new GeographicPosition(10, 10)), rightProp);
Assert_Are_Equal(left, right);
}
// Returns true if the expected result is right
// Returns false if the expected result is wrong
public bool PosTest3()
{
bool retVal = true;
TestLibrary.TestFramework.BeginScenario("PosTest3: Calling indexof method ,T is user define type. ");
try
{
IList <MyTestClass> myList = new List <MyTestClass>();
MyTestClass myTest = null;
for (int i = 1; i <= 10; i++)
{
myTest = new MyTestClass();
myTest.ID = i;
myList.Add(myTest);
}
int index = 1;
MyTestClass expectValue = new MyTestClass();
expectValue.ID = 999;
myList.Insert(index, expectValue);
MyTestClass actualValue = myList[index];
if (actualValue != expectValue)
{
TestLibrary.TestFramework.LogError("003.1", "Calling IndexOf method return a value incorrectly,should return " + expectValue);
retVal = false;
}
}
catch (Exception e)
{
TestLibrary.TestFramework.LogError("003.0", "Unexpected exception: " + e);
retVal = false;
}
return(retVal);
}
private void button1_Click(object sender, EventArgs e)
{
var testClass = new MyTestClass();
var message = string.Format("Version {0} of external assembly", testClass.MyVersion());
MessageBox.Show(message, "Information", MessageBoxButtons.OK);
}
public void CreateMappingCollection_Verify_Private_Properties_Mapped()
{
var myObject = new MyTestClass();
var result = ObjectFieldMappingCollection.CreateMappingCollection(myObject);
Assert.NotNull(result.GetFieldInfo("B"));
}
private void button1_Click(object sender, EventArgs e)
{
var testClass = new MyTestClass();
var message = string.Format("Version {0} of external assembly", testClass.MyVersion());
MessageBox.Show(message, "Information", MessageBoxButtons.OK);
}
protected override void Context()
{
base.Context();
Source = Builder <MyTestClass> .CreateNew().Build();
Target = new MyTestClass();
}
public void TestParamsLengthZero()
{
var obj = new MyTestClass();
// Check that passing no parameters to the 'params' parameter (empty array) works
var result = ClrFacade.CallInstanceMethod(obj, "UniqueNameStrStrParams", new[] { "", "" });
// However, if it means that there are more than one candidate methods:
Assert.Throws <AmbiguousMatchException>(() => { ClrFacade.CallInstanceMethod(obj, "StringSameNameParams", new[] { "" }); });
}
public void RegularExpressionAttributeTest()
{
var entity = new MyTestClass();
var validatior = new EntityValidator(entity);
entity.RegExprProperty = "abc";
Assert.IsTrue(entity.HasValidationErrors);
entity.RegExprProperty = "abcdef";
Assert.IsFalse(entity.HasValidationErrors);
}
public void RequiredAttributeStringTest()
{
var entity = new MyTestClass();
var validatior = new EntityValidator(entity);
entity.StringProperty = null;
Assert.IsTrue(entity.HasValidationErrors);
entity.StringProperty = "";
Assert.IsFalse(entity.HasValidationErrors);
}
public void Assign_calls_Defaults_action()
{
var myTestClass = new MyTestClass();
var sut = DefaultValuesProvider <MyTestClass> .Create(m =>
{
m.HasChanged = true;
});
sut.Assign(myTestClass);
Assert.True(myTestClass.HasChanged);
}
void MyTest()
{
var myclass = new MyTestClass();
MethodInfo method = myclass.GetType().GetMethod("MyTestFunc");
ParameterInfo[] parameterInfos = method.GetParameters();
foreach (ParameterInfo param in parameterInfos)
{
Debug.LogError(param.Name + param.ParameterType.IsByRef + "_" + param.ParameterType);
}
}
static void Main(string[] args)
{
var myTestClass = new MyTestClass();
myTestClass.Run();
var logger = new GeneralLogger();
var providerSettings = new TestJobsProviderSettings
{
SearchInAssemblyName = "AsyncNet.Selenium.Tests"
};
var jobsProvider = new TestJobsProvider(providerSettings);
var managerSettings = new JobsManagerSettings();
var jobsManager = new TestJobsManager(jobsProvider, managerSettings);
jobsManager.OnStart += (s, e) => logger.Info("PROCESS START");
jobsManager.OnFailed += (s, e) => logger.Info("PROCESS FAILED");
jobsManager.OnFinished += (s, e) => logger.Info("PROCESS FINISHED");
jobsManager.OnActionExecuting += (s, e) => logger.Info("START - " + ((TestCaseJob)s).TestCaseType.Name);
jobsManager.OnActionExecuted += (s, e) => logger.Info("STOP - " + ((TestCaseJob)s).TestCaseType.Name);
jobsManager.OnActionCanceled += (s, e) => logger.Info("CANCELLED - " + ((TestCaseJob)s).TestCaseType.Name);
jobsManager.OnActionFailed += (s, e) => logger.Info("FAILED - " + ((TestCaseJob)s).TestCaseType.Name + " Exception: " + e.Exception.ToString());
jobsManager.OnBackActionExecuting += (s, e) => logger.Info("BACK START - " + ((TestCaseJob)s).TestCaseType.Name);
jobsManager.OnBackActionExecuted += (s, e) => logger.Info("BACK STOP - " + ((TestCaseJob)s).TestCaseType.Name);
jobsManager.OnBackActionFailed += (s, e) => logger.Info("BACK FAILED - " + ((TestCaseJob)s).TestCaseType.Name + " Exception: " + e.Exception.ToString());
jobsManager.OnStateChanged += (s, e) => logger.Info("STATE CHANGED - " + ((TestCaseJob)s).State.ToString() + " - " + ((TestCaseJob)s).TestCaseType.Name);
jobsManager.BeginRun();
bool ask = true;
while (ask)
{
Console.WriteLine("c - Cancel, t - Terminate, q - Quit");
var key = Console.ReadKey().KeyChar;
switch (key)
{
case 'c':
jobsManager.Cancel();
break;
case 't':
jobsManager.Terminate();
break;
case 'q':
ask = false;
break;
}
}
}
protected override void Context()
{
base.Context();
Source = Builder <MyTestClass> .CreateNew().Build();
Target = new MyTestClass
{
Age = Source.Age,
Name = Source.Name,
};
}
public void Serialize_Class_Test()
{
var source = new MyTestClass
{
Field1 = 42,
Field2 = "Stranger Things"
};
var result = _redisCacheSerializer.Serialize(source, typeof(MyTestClass));
result.ToString().ShouldBe("{\"Payload\":\"{\\\"Field1\\\":42,\\\"Field2\\\":\\\"Stranger Things\\\"}\",\"Type\":\"Abp.RedisCache.Tests.DefaultRedisCacheSerializer_Tests+MyTestClass, Abp.RedisCache.Tests, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null\"}");
}
public void Serialize_Class_Test()
{
var source = new MyTestClass
{
Field1 = 42,
Field2 = "Stranger Things"
};
var result = _redisCacheSerializer.Serialize(source, typeof(MyTestClass));
result.ShouldBe("{\"Payload\":\"{\\\"Field1\\\":42,\\\"Field2\\\":\\\"Stranger Things\\\"}\",\"Type\":\"Abp.RedisCache.Tests.DefaultRedisCacheSerializer_Tests+MyTestClass, Abp.RedisCache.Tests\"}");
}
protected override void InitializeCore()
{
rangeClass = new MyTestClass();
int32Info = rangeClass.GetType().GetProperty("Int32Value");
doubleInfo = rangeClass.GetType().GetProperty("DoubleValue");
floatInfo = rangeClass.GetType().GetProperty("FloatValue");
charInfo = rangeClass.GetType().GetProperty("CharValue");
stringInfo = rangeClass.GetType().GetProperty("StringValue");
shortInfo = rangeClass.GetType().GetProperty("ShortValue");
byteInfo = rangeClass.GetType().GetProperty("ByteValue");
decimalInfo = rangeClass.GetType().GetProperty("DecimalValue");
}
protected override void InitializeCore()
{
rangeClass = new MyTestClass();
int32Info = rangeClass.GetType().GetProperty("Int32Value");
doubleInfo = rangeClass.GetType().GetProperty("DoubleValue");
floatInfo = rangeClass.GetType().GetProperty("FloatValue");
charInfo = rangeClass.GetType().GetProperty("CharValue");
stringInfo = rangeClass.GetType().GetProperty("StringValue");
shortInfo = rangeClass.GetType().GetProperty("ShortValue");
byteInfo = rangeClass.GetType().GetProperty("ByteValue");
decimalInfo = rangeClass.GetType().GetProperty("DecimalValue");
}
public void Test1()
{
//Assert.Pass();
// ARRANGE
var handlerMock = new Mock <HttpMessageHandler>(MockBehavior.Strict);
handlerMock
.Protected()
// Setup the PROTECTED method to mock
.Setup <Task <HttpResponseMessage> >(
"SendAsync",
ItExpr.IsAny <HttpRequestMessage>(),
ItExpr.IsAny <CancellationToken>()
)
// prepare the expected response of the mocked http call
.ReturnsAsync(new HttpResponseMessage()
{
StatusCode = HttpStatusCode.OK,
Content = new StringContent("[{'id':1,'value':'1'}]"),
})
.Verifiable();
// use real http client with mocked handler here
var httpClient = new HttpClient(handlerMock.Object)
{
BaseAddress = new Uri("http://test.com/"),
};
var subjectUnderTest = new MyTestClass(httpClient);
// ACT
var result = await subjectUnderTest
.GetSomethingRemoteAsync("api/test/whatever");
// ASSERT
result.Should().NotBeNull(); // this is fluent assertions here...
result.Id.Should().Be(1);
// also check the 'http' call was like we expected it
var expectedUri = new Uri("http://test.com/api/test/whatever");
handlerMock.Protected().Verify(
"SendAsync",
Times.Exactly(1), // we expected a single external request
ItExpr.Is <HttpRequestMessage>(req =>
req.Method == HttpMethod.Get && // we expected a GET request
req.RequestUri == expectedUri // to this uri
),
ItExpr.IsAny <CancellationToken>()
);
}
public void GetValueFromResponse_Returns_Null_Not_Found_Property()
{
var att = new FilterAllowedOutgoingContentAttribute(typeof(IEnumerable<ContentItemBasic>), "DontFind");
var val = new List<ContentItemBasic>() { new ContentItemBasic() };
var container = new MyTestClass() { MyList = val };
var result = att.GetValueFromResponse(
new ObjectContent(typeof(MyTestClass),
container,
new JsonMediaTypeFormatter(),
new MediaTypeHeaderValue("html/text")));
Assert.AreEqual(null, result);
}
public void Can_Get_Correct_ReferenceType_Property_Value()
{
var referenceTypeProperty = typeof(MyTestClass).GetProperty("ReferenceTypeProperty", BindingFlags.Public | BindingFlags.Instance);
Assert.IsNotNull(referenceTypeProperty);
var referenceTypePropertyValueGetter = referenceTypeProperty.GetValueGetter();
Assert.IsNotNull(referenceTypePropertyValueGetter);
var testClass = new MyTestClass();
object nullValue = referenceTypePropertyValueGetter(testClass);
Assert.IsNull(nullValue);
testClass.ReferenceTypeProperty = "418";
object fourOneEightValue = referenceTypePropertyValueGetter(testClass);
Assert.IsInstanceOfType(fourOneEightValue, typeof(string));
Assert.AreEqual("418", fourOneEightValue);
}
public void Can_Get_Correct_NullableType_PropertyValue()
{
var nullableTypeProperty = typeof(MyTestClass).GetProperty("NullableTypeProperty", BindingFlags.Public | BindingFlags.Instance);
Assert.IsNotNull(nullableTypeProperty);
var nullableTypePropertyValueGetter = nullableTypeProperty.GetValueGetter();
Assert.IsNotNull(nullableTypePropertyValueGetter);
var testClass = new MyTestClass();
object nullValue = nullableTypePropertyValueGetter(testClass);
Assert.IsNull(nullValue);
testClass.NullableTypeProperty = 418;
object fourOneEightValue = nullableTypePropertyValueGetter(testClass);
Assert.IsInstanceOfType(fourOneEightValue, typeof(int?));
Assert.AreEqual(418, fourOneEightValue);
}
public void Can_Get_Correct_ValueType_Property_Value()
{
var valueTypeProperty = typeof (MyTestClass).GetProperty("ValueTypeProperty", BindingFlags.Public | BindingFlags.Instance);
Assert.IsNotNull(valueTypeProperty);
var valueTypePropertyValueGetter = valueTypeProperty.GetValueGetter();
Assert.IsNotNull(valueTypePropertyValueGetter);
var testClass = new MyTestClass();
object zeroValue = valueTypePropertyValueGetter(testClass);
Assert.IsInstanceOfType(zeroValue, typeof (int));
Assert.AreEqual(0, zeroValue);
testClass.ValueTypeProperty = 418;
object fourOneEightValue = valueTypePropertyValueGetter(testClass);
Assert.IsInstanceOfType(fourOneEightValue, typeof(int));
Assert.AreEqual(418, fourOneEightValue);
}
public void TestFeatureFromClass()
{
var testObject = new MyTestClass()
{
BooleanProperty = true,
DateTimeProperty = DateTime.Now,
DoubleProperty = 1.2345d,
EnumProperty = MyTestEnum.Value1,
IntProperty = -1,
StringProperty = "Hello, GeoJSON !"
};
Feature.Feature feature = new Feature.Feature(new Point(new GeographicPosition(10, 10)), testObject);
Assert.IsNotNull(feature.Properties);
Assert.IsTrue(feature.Properties.Count > 1);
Assert.AreEqual(feature.Properties.Count, 6);
}
public void Ctor_Can_Add_Properties_Using_Object()
{
var properties = new MyTestClass
{
BooleanProperty = true,
DateTimeProperty = DateTime.Now,
DoubleProperty = 1.2345d,
EnumProperty = MyTestEnum.Value1,
IntProperty = -1,
StringProperty = "Hello, GeoJSON !"
};
Net.Feature.Feature feature = new Net.Feature.Feature(new Point(new GeographicPosition(10, 10)), properties);
Assert.IsNotNull(feature.Properties);
Assert.IsTrue(feature.Properties.Count > 1);
Assert.AreEqual(feature.Properties.Count, 6);
}
// Returns true if the expected result is right
// Returns false if the expected result is wrong
public bool PosTest3()
{
bool retVal = true;
TestLibrary.TestFramework.BeginScenario("PosTest3: Calling indexof method ,T is user define type. ");
try
{
IList<MyTestClass> myList = new List<MyTestClass>();
MyTestClass myTest = null;
for (int i = 1; i <= 10; i++)
{
myTest = new MyTestClass();
myTest.ID = i;
myList.Add(myTest);
}
int expectValue = 9;
int actualValue = myList.IndexOf(myTest);
if (actualValue != expectValue)
{
TestLibrary.TestFramework.LogError("003.1", "Calling IndexOf method return a value correctly.");
retVal = false;
}
}
catch (Exception e)
{
TestLibrary.TestFramework.LogError("003.0", "Unexpected exception: " + e);
retVal = false;
}
return retVal;
}
protected override void Context()
{
base.Context();
Target = new MyTestClass();
}
protected override void Context()
{
base.Context();
Source = new MyTestClass();
}
protected override void Context()
{
base.Context();
Source = Builder<MyTestClass>.CreateNew().Build();
Target = new MyTestClass
{
Age = Source.Age,
Name = Source.Name,
};
}
public void Init()
{
rangeClass = new MyTestClass();
int32Info = rangeClass.GetType().GetProperty("Int32Value");
Assert.IsNotNull(int32Info);
doubleInfo = rangeClass.GetType().GetProperty("DoubleValue");
Assert.IsNotNull(doubleInfo);
floatInfo = rangeClass.GetType().GetProperty("FloatValue");
Assert.IsNotNull(floatInfo);
charInfo = rangeClass.GetType().GetProperty("CharValue");
Assert.IsNotNull(charInfo);
stringInfo = rangeClass.GetType().GetProperty("StringValue");
Assert.IsNotNull(stringInfo);
}
public void Feature_Equals_GetHashCode_Contract_Properties_Of_Objects()
{
// order of keys should not matter
var leftProp = new MyTestClass
{
StringProperty = "Hello, GeoJSON !",
EnumProperty = MyTestEnum.Value1,
IntProperty = -1,
BooleanProperty = true,
DateTimeProperty = DateTime.Now,
DoubleProperty = 1.2345d
};
var left = new Net.Feature.Feature(new Point(new GeographicPosition(10, 10)), leftProp);
var rightProp = new MyTestClass
{
BooleanProperty = true,
DateTimeProperty = DateTime.Now,
DoubleProperty = 1.2345d,
EnumProperty = MyTestEnum.Value1,
IntProperty = -1,
StringProperty = "Hello, GeoJSON !"
};
var right = new Net.Feature.Feature(new Point(new GeographicPosition(10, 10)), rightProp);
Assert_Are_Equal(left, right);
}
