public void Static_Comparer_A_Value_Type() { var oldModel = new StructModel { Id = 1, StructMember = new StructMember { Id = 1, Value = "Old" } }; var newModel = new StructModel { Id = 1, StructMember = new StructMember { Id = 1, Value = "New" } }; var changes = Comparer.Compare(oldModel, newModel); Assert.AreEqual(changes.Count(), 1); Assert.IsNotNull(changes.Single(x => x.Name == "StructMember.Value" && (string)x.OldValue == "Old" && (string)x.NewValue == "New")); }
/// <summary> /// Interpreta los datos de una estructura /// </summary> protected void ParseStruct(SyntaxNode objNode, LanguageStructModel objParent, INamedTypeSymbol objSymbol) { StructModel objStruct = objParent.Items.CreateStruct(objParent); // Inicializa los elementos ParseNamedTypeSymbol(objStruct, objNode, objSymbol); }
/// <summary> /// Interpreta los datos de una estructura /// </summary> protected void ParseStruct(SyntaxNode node, LanguageStructModel parent, INamedTypeSymbol symbol) { StructModel structDoc = parent.Items.CreateStruct(parent); // Inicializa los elementos ParseNamedTypeSymbol(structDoc, node, symbol); }
public void ParseEventStructHasRightType() { var ev = new StructModel("e", StructType.Event); var parsed = FileModel.Parse(ev.Generate().NormalizeWhitespace().ToString(), FileModel.ParseOptions.DisallowMultipleStructs); Assert.That(parsed, Is.Not.Null); Assert.That(parsed.Structs[0].Type, Is.EqualTo(StructType.Event)); }
/// <summary> /// Interpreta los datos de una estructura /// </summary> private void ParseStruct(SyntaxNode objNode, LanguageStructModel objParent) { StructModel objStruct = objParent.Items.CreateStruct(objParent); INamedTypeSymbol objSymbol = objTreeSemantic.GetDeclaredSymbol(objNode as StructDeclarationSyntax); // Inicializa los elementos ParseNamedTypeSymbol(objStruct, objNode, objSymbol); }
/// <summary> /// Obtiene el MLNode de una estructura /// </summary> private void GetMLStruct(MLNode objMLRoot, DocumentFileModel objDocument) { StructModel objStruct = objDocument.LanguageStruct as StructModel; if (objStruct != null) { AddTablesComplexParts(objMLRoot, objDocument); } }
public void RemoveAll(StructModel <int> provider) { try { _cacheMem.RemoveAll(provider.Item); } catch (Exception e) { ErrorLog.Error(e); } }
public void CanPopulateStruct() { var model = new StructModel(); var actual = Model.WriteLog <StructModel>(_output.WriteLine).Populate(model); actual.Id.Should().NotBeEmpty(); actual.FirstName.Should().NotBeNullOrWhiteSpace(); actual.LastName.Should().NotBeNullOrWhiteSpace(); actual.Email.Should().NotBeNullOrWhiteSpace(); var expectedFirstName = EmailValueGenerator.SpecialCharacters.Replace(actual.FirstName !, string.Empty).ToLowerInvariant(); var expectedLastName = EmailValueGenerator.SpecialCharacters.Replace(actual.LastName !, string.Empty).ToLowerInvariant(); actual.Email.Should().StartWith(expectedFirstName + "." + expectedLastName + "@"); }
public void Should_invoke_response_negotiator_for_value_type_model() { // Given var model = new StructModel(); var route = new FakeRoute(model); var parameters = new DynamicDictionary(); var context = new NancyContext { Trace = new DefaultRequestTrace() }; // When var result = this.invoker.Invoke(route, new CancellationToken(), parameters, context).Result; // Then A.CallTo(() => this.responseNegotiator.NegotiateResponse(model, context)).MustHaveHappened(); }
internal FieldModel(MemberInfo memberInfo, Type fieldType, TypeDesc fieldTypeDesc) { _name = memberInfo.Name; _fieldType = fieldType; _fieldTypeDesc = fieldTypeDesc; _memberInfo = memberInfo; _checkShouldPersistMethodInfo = memberInfo.DeclaringType.GetMethod("ShouldSerialize" + memberInfo.Name, Array.Empty <Type>()); _checkShouldPersist = _checkShouldPersistMethodInfo != null; FieldInfo specifiedField = memberInfo.DeclaringType.GetField(memberInfo.Name + "Specified"); if (specifiedField != null) { if (specifiedField.FieldType != typeof(bool)) { throw new InvalidOperationException(SR.Format(SR.XmlInvalidSpecifiedType, specifiedField.Name, specifiedField.FieldType.FullName, typeof(bool).FullName)); } _checkSpecified = specifiedField.IsInitOnly ? SpecifiedAccessor.ReadOnly : SpecifiedAccessor.ReadWrite; _checkSpecifiedMemberInfo = specifiedField; } else { PropertyInfo specifiedProperty = memberInfo.DeclaringType.GetProperty(memberInfo.Name + "Specified"); if (specifiedProperty != null) { if (StructModel.CheckPropertyRead(specifiedProperty)) { _checkSpecified = specifiedProperty.CanWrite ? SpecifiedAccessor.ReadWrite : SpecifiedAccessor.ReadOnly; _checkSpecifiedMemberInfo = specifiedProperty; } if (_checkSpecified != SpecifiedAccessor.None && specifiedProperty.PropertyType != typeof(bool)) { throw new InvalidOperationException(SR.Format(SR.XmlInvalidSpecifiedType, specifiedProperty.Name, specifiedProperty.PropertyType.FullName, typeof(bool).FullName)); } } } if (memberInfo is PropertyInfo) { _readOnly = !((PropertyInfo)memberInfo).CanWrite; _isProperty = true; } else if (memberInfo is FieldInfo) { _readOnly = ((FieldInfo)memberInfo).IsInitOnly; } }
public void PopulateReturnsValueWithoutModification() { var executeStrategy = Substitute.For <IExecuteStrategy>(); var expected = new StructModel { Email = Guid.NewGuid().ToString(), FirstName = Guid.NewGuid().ToString(), Id = Guid.NewGuid(), LastName = Guid.NewGuid().ToString() }; var sut = new StructTypeCreator(); var actual = sut.Populate(executeStrategy, expected); actual.Should().BeEquivalentTo(expected); }
internal TypeModel GetTypeModel(Type type, bool directReference) { TypeModel model; if (_models.TryGetValue(type, out model)) { return(model); } TypeDesc typeDesc = _typeScope.GetTypeDesc(type, null, directReference); switch (typeDesc.Kind) { case TypeKind.Enum: model = new EnumModel(type, typeDesc, this); break; case TypeKind.Primitive: model = new PrimitiveModel(type, typeDesc, this); break; case TypeKind.Array: case TypeKind.Collection: case TypeKind.Enumerable: model = new ArrayModel(type, typeDesc, this); break; case TypeKind.Root: case TypeKind.Class: case TypeKind.Struct: model = new StructModel(type, typeDesc, this); break; default: if (!typeDesc.IsSpecial) { throw new NotSupportedException(SR.Format(SR.XmlUnsupportedTypeKind, type.FullName)); } model = new SpecialModel(type, typeDesc, this); break; } _models.Add(type, model); return(model); }
public void IsIgnoredReturnsTrueWhenParameterMatchesStructPropertyWithNameMatch() { var configuration = Model.UsingDefaultConfiguration(); var value = new StructModel { FirstName = Guid.NewGuid().ToString() }; var model = new StructMatchingNameWrapper <StructModel>(value); var propertyInfo = typeof(StructMatchingNameWrapper <StructModel>).GetProperty(nameof(StructMatchingNameWrapper <StructModel> .Value)) !; var args = new object?[] { value }; var sut = new DefaultPropertyResolver(CacheLevel.PerInstance); var actual = sut.IsIgnored(configuration, model, propertyInfo, args); actual.Should().BeTrue(); }
/// <summary> /// Convierte una estructura /// </summary> private StructDocumentationModel ConvertStruct(StructDocumentationModel objParent, StructModel objItem) { StructDocumentationModel objStruct = Create(objParent, objItem, "Struct"); // Añade los parámetros de la clase compleja base AddParametersBaseComplex(objStruct, objItem); // Crea los elementos hijo objStruct.Childs.AddRange(Convert(objStruct, objItem.Items)); // Devuelve la estructura return(objStruct); }
private bool InitializeStructMembers(StructMapping mapping, StructModel model, RecursionLimiter limiter) { if (mapping.IsFullyInitialized) { return(true); } if (model.TypeDesc.BaseTypeDesc != null) { StructMapping baseMapping = ImportStructLikeMapping((StructModel)_modelScope.GetTypeModel(model.Type.BaseType, false), limiter); // check to see if the import of the baseMapping was deferred int baseIndex = limiter.DeferredWorkItems.IndexOf(mapping.BaseMapping); if (baseIndex < 0) { mapping.BaseMapping = baseMapping; } else { // the import of the baseMapping was deferred, make sure that the derived mappings is deferred as well if (!limiter.DeferredWorkItems.Contains(mapping)) { limiter.DeferredWorkItems.Add(new ImportStructWorkItem(model, mapping)); } // make sure that baseMapping get processed before the derived int top = limiter.DeferredWorkItems.Count - 1; if (baseIndex < top) { ImportStructWorkItem baseMappingWorkItem = limiter.DeferredWorkItems[baseIndex]; limiter.DeferredWorkItems[baseIndex] = limiter.DeferredWorkItems[top]; limiter.DeferredWorkItems[top] = baseMappingWorkItem; } return(false); } } ArrayList members = new ArrayList(); foreach (MemberInfo memberInfo in model.GetMemberInfos()) { if (!(memberInfo is FieldInfo) && !(memberInfo is PropertyInfo)) { continue; } SoapAttributes memberAttrs = GetAttributes(memberInfo); if (memberAttrs.SoapIgnore) { continue; } FieldModel fieldModel = model.GetFieldModel(memberInfo); if (fieldModel == null) { continue; } MemberMapping member = ImportFieldMapping(fieldModel, memberAttrs, mapping.Namespace, limiter); if (member == null) { continue; } if (!member.TypeDesc.IsPrimitive && !member.TypeDesc.IsEnum && !member.TypeDesc.IsOptionalValue) { if (model.TypeDesc.IsValueType) { throw new NotSupportedException(SR.Format(SR.XmlRpcRefsInValueType, model.TypeDesc.FullName)); } if (member.TypeDesc.IsValueType) { throw new NotSupportedException(SR.Format(SR.XmlRpcNestedValueType, member.TypeDesc.FullName)); } } if (mapping.BaseMapping != null) { if (mapping.BaseMapping.Declares(member, mapping.TypeName)) { continue; } } members.Add(member); } mapping.Members = (MemberMapping[])members.ToArray(typeof(MemberMapping)); if (mapping.BaseMapping == null) { mapping.BaseMapping = GetRootMapping(); } IncludeTypes(model.Type, limiter); return(true); }
private StructMapping ImportStructLikeMapping(StructModel model, RecursionLimiter limiter) { if (model.TypeDesc.Kind == TypeKind.Root) { return(GetRootMapping()); } SoapAttributes a = GetAttributes(model.Type); string typeNs = _defaultNs; if (a.SoapType != null && a.SoapType.Namespace != null) { typeNs = a.SoapType.Namespace; } string typeName = XsdTypeName(model.Type, a, model.TypeDesc.Name); typeName = XmlConvert.EncodeLocalName(typeName); StructMapping mapping = (StructMapping)GetTypeMapping(typeName, typeNs, model.TypeDesc); if (mapping == null) { mapping = new StructMapping(); mapping.IsSoap = true; mapping.TypeDesc = model.TypeDesc; mapping.Namespace = typeNs; mapping.TypeName = typeName; if (a.SoapType != null) { mapping.IncludeInSchema = a.SoapType.IncludeInSchema; } _typeScope.AddTypeMapping(mapping); _types.Add(typeName, typeNs, mapping); if (limiter.IsExceededLimit) { limiter.DeferredWorkItems.Add(new ImportStructWorkItem(model, mapping)); return(mapping); } limiter.Depth++; InitializeStructMembers(mapping, model, limiter); while (limiter.DeferredWorkItems.Count > 0) { int index = limiter.DeferredWorkItems.Count - 1; ImportStructWorkItem item = limiter.DeferredWorkItems[index]; if (InitializeStructMembers(item.Mapping, item.Model, limiter)) { // // if InitializeStructMembers returns true, then there were *no* changes to the DeferredWorkItems // #if DEBUG // use exception in the place of Debug.Assert to avoid throwing asserts from a server process such as aspnet_ewp.exe if (index != limiter.DeferredWorkItems.Count - 1) { throw new InvalidOperationException(SR.Format(SR.XmlInternalErrorDetails, "DeferredWorkItems.Count have changed")); } if (item != limiter.DeferredWorkItems[index]) { throw new InvalidOperationException(SR.Format(SR.XmlInternalErrorDetails, "DeferredWorkItems.Top have changed")); } #endif // Remove the last work item limiter.DeferredWorkItems.RemoveAt(index); } } limiter.Depth--; } return(mapping); }
/// <summary> /// Convierte una estructura /// </summary> private StructDocumentationModel ConvertStruct(StructDocumentationModel parent, StructModel item) { StructDocumentationModel structDoc = Create(parent, item, "Struct"); // Añade los parámetros de la clase compleja base AddParametersBaseComplex(structDoc, item); // Crea los elementos hijo structDoc.Childs.AddRange(Convert(structDoc, item.Items)); // Devuelve la estructura return(structDoc); }