private async void OnTimedEvent(Object source, System.Timers.ElapsedEventArgs e)
{
var meta = new TestMetaData
{
IsLastShuttle = Current == Last,
IsCompleted = Current == null && Next == null,
NextShuttle = Next != null ? Next.StartTime : Current.StartTime,
TotalTime = CurrentTime,
TotalDistance = Current.AccumulatedShuttleDistance,
Level = Current.SpeedLevel,
Shuttle = Current.ShuttleNo,
Speed = Current.Speed,
//Progress = _progress,
Athletes = Athletes
};
byte[] bytes;
var obj = meta;
var data = JsonConvert.SerializeObject(obj, Formatting.Indented);
bytes = Encoding.ASCII.GetBytes(data);
var arraySegment = new ArraySegment <byte>(bytes);
await this.WebSocket.SendAsync(arraySegment, WebSocketMessageType.Text, true, CancellationToken.None);
}
public void HasMetaDataProperty()
{
object dataContext = GetDataContext(TestMetaData.CreateEmptyClassMetaInfo());
var metaData = GetMetaDataProperty(dataContext);
Assert.IsNotNull(metaData);
}
public void HasIndexingState()
{
var originalMetaData = TestMetaData.CreateSingleFieldClass();
dynamic metaData = MetaClassInfo(originalMetaData);
Assert.AreEqual("data (Index: Unknown)", metaData.SingleField.data);
}
private Type SingleTypeQueryContext()
{
var metaInfo = TestMetaData.CreateEmptyClassMetaInfo();
var infos = NewTestInstance(metaInfo);
return(infos.DataContext);
}
public void DoesNotAddArrayTypes()
{
var meta = TestMetaData.CreateClassWithArrayField();
var db = Configure(DatabaseMetaInfo.Create(meta, TestUtils.NewName()));
Assert.NotNull(db);
}
public void GenericEquals()
{
var t1 = TestMetaData.CreateGenericType();
var t2 = TestMetaData.CreateGenericType();
Assert.AreEqual(t1, t2);
}
public void SameNameDifferentAssembly()
{
var typeInfos = TestMetaData.SameNameDifferentAssembly();
var result = CodeGenerator.Create(typeInfos, TestUtils.NewName());
Assert.AreEqual(2, result.Types.Count);
}
private static IEnumerable <ITypeDescription> CircularType()
{
var type = SimpleClassDescription.Create(TestMetaData.SingleFieldType(),
TestMetaData.CreateField);
return(new ITypeDescription[] { type });
}
public void GenerateEmptyClass()
{
var metaInfo = TestMetaData.CreateEmptyClassMetaInfo();
var type = GenerateSingle(metaInfo);
Assert.IsTrue(type.Name.StartsWith(metaInfo.Single().Name));
}
public void NoContextForArrayTypes()
{
var metaInfo = TestMetaData.CreateClassWithArrayField();
var infos = NewTestInstance(metaInfo);
var properties = AllPropertiesExceptMetaData(infos);
Assert.AreEqual(1, properties.Count());
}
internal static IEnumerable <ITypeDescription> TypeWithGenericList()
{
var stringList = KnownType.Create(typeof(List <string>));
var type = SimpleClassDescription.Create(TestMetaData.SingleFieldType(),
f => TestMetaData.CreateField(stringList));
return(new[] { type, stringList });
}
public void HasMetaDataForConflictingTypes()
{
var originalMetaData = TestMetaData.CreateNameConflicMetaInfo();
dynamic metaData = MetaClassInfo(originalMetaData);
Assert.NotNull(metaData.ANamespace.EmptyClass);
Assert.NotNull(metaData.ANamespace.OtherNamespace.EmptyClass);
}
private IEnumerable <ITypeDescription> CreateSingleIntFieldClass()
{
var stringType = KnownType.Create(typeof(int));
var type = SimpleClassDescription.Create(TestMetaData.SingleFieldType(),
f => TestMetaData.CreateField(stringType));
return(new[] { type, stringType });
}
public void GenericNameWithTwoParams()
{
var complex = TestMetaData.CreateGenericType(
TypeName.Create("System.Int32", "mscorelib"), TypeName.Create("System.Int64", "mscorelib"));
Assert.AreEqual("TheType_2_Int32_Int64",
complex.Name);
}
public void CanInstantiateGenericWithClass()
{
var metaInfo = TestMetaData.CreateEmptyClassMetaInfo();
var type = GenerateSingle(metaInfo);
var genericList = typeof(List <>).MakeGenericType(type);
var list = genericList.GetConstructor(new Type[0]).Invoke(new object[0]);
}
public void HasNames()
{
var originalMetaData = TestMetaData.CreateEmptyClassMetaInfo();
dynamic metaData = MetaClassInfo(originalMetaData);
Assert.AreEqual("EmptyClass", metaData.EmptyClass.ClassName);
Assert.AreEqual(originalMetaData.Single().TypeName.FullName, metaData.EmptyClass.ClassFullName);
}
public void ArrayOfGeneratedType()
{
var simpleType = TestMetaData.CreateEmptyClassMetaInfo();
var code = CodeGenerator.Create(simpleType, TestUtils.NewName());
var generatedType = code.Types[simpleType.Single()];
var type = generatedType.MakeArrayType();
Assert.IsTrue(type.AssemblyQualifiedName.Contains("[]"));
}
public void CascadedGenericsName()
{
var theType = TestMetaData.CreateGenericType();
var complex = TestMetaData.CreateGenericType(
TypeName.Create("System.Int32", "mscorelib"), theType.TypeName);
Assert.AreEqual("TheType_2_Int32_TheType_1_Int32",
complex.Name);
}
public void CanInstantiateClass()
{
var metaInfo = TestMetaData.CreateEmptyClassMetaInfo();
var type = GenerateSingle(metaInfo);
var instance = CreateInstance(type);
Assert.NotNull(instance);
}
public void GetsGenericTypeFromCurrentAssembly()
{
var dynamicType = new [] { TestMetaData.CreateGenericType() };
var dynamicAssembly = CodeGenerator.Create(dynamicType, TestUtils.NewName());
var typeToFind = dynamicAssembly.Types[dynamicType.Single(t => t.IsBusinessEntity)];
var found = TypeLoader.Create(new string[0])(TypeNameParser.ParseString(ReflectPlatform.FullyQualifiedName(typeToFind)));
Assert.AreEqual(typeToFind, found.Value);
}
public void ResolvesGenericParameters()
{
var otherType = TestMetaData.CreateEmptyClassMetaInfo();
var theType = KnownType.Create(typeof(System.Collections.Generic.List <>), otherType);
var resovledType = theType.TryResolveType(t => typeof(string));
Assert.AreEqual(typeof(System.Collections.Generic.List <string>), resovledType.Value);
Assert.IsTrue(theType.TypeName.FullName.StartsWith("System.Collections.Generic.List"));
}
public void HasAssembly()
{
var metaInfo = TestMetaData.CreateEmptyClassMetaInfo();
var name = TestUtils.NewName();
var infos = CodeGenerator.Create(metaInfo, name);
Assert.IsTrue(File.Exists(name.CodeBase));
}
public void CanInstantiateClassWithSingleField()
{
var metaInfo = TestMetaData.CreateSingleFieldClass();
var type = ExtractSingleFieldType(metaInfo);
Assert.IsTrue(type.Name.StartsWith(SingleFieldMeta(metaInfo).Name));
dynamic instance = CreateInstance(type);
AssertFieldCanBeSet(instance, "newData");
}
public void CanCreateTypeMultipleTimes()
{
var metaInfo = TestMetaData.CreateEmptyClassMetaInfo();
var type1 = SingleNotObject(metaInfo);
var type2 = SingleNotObject(metaInfo);
Assert.NotNull(type1);
Assert.NotNull(type2);
}
public void HasFields()
{
var originalMetaData = TestMetaData.CreateSingleFieldClass();
dynamic metaData = MetaClassInfo(originalMetaData);
object meta2 = metaData;
Console.Out.WriteLine(meta2);
Assert.IsNotNull(metaData.SingleField);
Assert.IsNotNull(metaData.SingleField.data);
}
public void CreateMixedGenericInstance()
{
var metaInfo = TestMetaData.CreateClassListGenericOf(TestMetaData.CreateEmptyClassMetaInfo().First());
var types = NewTestInstance(metaInfo);
var genericTypes = types.Types[metaInfo.First()];
var fields = genericTypes.GetFields();
Assert.AreEqual(typeof(List <>), fields.Single().FieldType.GetGenericTypeDefinition());
}
public void ArraysAreLowerBoundZero()
{
var arrayType = TestMetaData.CreateEmptyClassMetaInfo().Single();
var metaInfo = SimpleClassDescription.Create(TestMetaData.SingleFieldType(),
f => TestMetaData.CreateArrayField(arrayType));
var type = ExtractSingleFieldType(new[] { metaInfo });
var fieldType = type.GetField("data").FieldType;
Assert.IsTrue(fieldType.AssemblyQualifiedName.Contains("[]"));
}
public void HasPublicGetterForLowerCaseBeginners()
{
var metaInfo = TestMetaData.CreateSingleFieldClass();
var type = ExtractSingleFieldType(metaInfo);
Assert.IsTrue(type.Name.StartsWith(SingleFieldMeta(metaInfo).Name));
dynamic instance = CreateInstance(type);
instance.Data = "newData";
Assert.AreEqual("newData", instance.Data);
}
private IEnumerable <ITypeDescription> SubClassType()
{
var baseClasses = TestMetaData.CreateSingleFieldClass();
var intType = KnownType.Create(typeof(int));
var baseClass = baseClasses.Single(b => !b.TryResolveType(TestUtils.FindNothingTypeResolver).HasValue);
var subType = SimpleClassDescription.Create(
TypeName.Create("ANamespace.SubClass", TestMetaData.AssemblyName), Maybe.From(baseClass),
f => TestMetaData.CreateField("subField", intType));
return(baseClasses.Concat(new[] { intType, subType }));
}
public void DoesAddPartialGenerics()
{
var meta = TestMetaData.CreateClassListGenericOf(TestMetaData.CreateEmptyClassMetaInfo().Single());
var db = Configure(DatabaseMetaInfo.Create(meta, TestUtils.NewName()));
var typeWithGenericField = meta.First();
var fieldType = typeWithGenericField.Fields.Single();
var typeInfo = db.Ext().Reflector().ForName(fieldType.Type.TypeName.FullName);
Assert.NotNull(typeInfo);
Assert.IsTrue(typeInfo.GetName().StartsWith("System.Collections.Generic.List`1[[ANamespace"));
}
