public void CompletelyInvalidIntParameterModifier_ShouldLogExpectedErrors() { var obj = TestSyntaxFactory.CreateObject(new[] { // not a bool TestSyntaxFactory.CreateProperty("secure", TestSyntaxFactory.CreateInt(1)), // default value of wrong type TestSyntaxFactory.CreateProperty("default", TestSyntaxFactory.CreateBool(true)), // not an array TestSyntaxFactory.CreateProperty("allowed", TestSyntaxFactory.CreateObject(new ObjectPropertySyntax[0])), // not ints TestSyntaxFactory.CreateProperty("minValue", TestSyntaxFactory.CreateBool(true)), TestSyntaxFactory.CreateProperty("maxValue", TestSyntaxFactory.CreateString("11")), TestSyntaxFactory.CreateProperty("minLength", TestSyntaxFactory.CreateObject(new ObjectPropertySyntax[0])), TestSyntaxFactory.CreateProperty("maxLength", TestSyntaxFactory.CreateBool(false)), // extra property TestSyntaxFactory.CreateProperty("extra", TestSyntaxFactory.CreateBool(false)), TestSyntaxFactory.CreateProperty("metadata", TestSyntaxFactory.CreateObject(new[] { // wrong type of description TestSyntaxFactory.CreateProperty("description", TestSyntaxFactory.CreateInt(155)) })) }); TypeValidator.GetExpressionAssignmentDiagnostics(CreateTypeManager(), obj, LanguageConstants.CreateParameterModifierType(LanguageConstants.Int, LanguageConstants.Int)) .Select(d => d.Message) .Should().BeEquivalentTo( "The property 'allowed' expected a value of type int[] but the provided value is of type object.", "The property 'minValue' expected a value of type int but the provided value is of type bool.", "The property 'default' expected a value of type int but the provided value is of type bool.", "The property 'maxValue' expected a value of type int but the provided value is of type '11'.", "The property 'description' expected a value of type string but the provided value is of type int.", "The property 'secure' is not allowed on objects of type ParameterModifier<int>.", "The property 'minLength' is not allowed on objects of type ParameterModifier<int>.", "The property 'maxLength' is not allowed on objects of type ParameterModifier<int>.", "The property 'extra' is not allowed on objects of type ParameterModifier<int>."); }
protected override object GetItemChildAtIndex(object aNode, int aIndex) { if (TypeValidator.IsCompatible(aNode.GetType(), typeof(DevelopmentDescriptionCollection)) == true) { if ((aIndex < 0) || (aIndex >= (aNode as DevelopmentDescriptionCollection).Count)) { return(null); } return((aNode as DevelopmentDescriptionCollection)[aIndex]); } else if (TypeValidator.IsCompatible(aNode.GetType(), typeof(DevelopmentInformationAttribute)) == true) { if ((aIndex < 0) || (aIndex >= (aNode as DevelopmentInformationAttribute).Count)) { return(null); } return((aNode as DevelopmentInformationAttribute)[aIndex]); } return(null); }
public static StateType ResolveState(this IDrawingCell aCell) { if (aCell.MasterIsSensitive() == false) { return(StateType.Insensitive); } if (TypeValidator.IsCompatible(aCell.GetType(), typeof(IGtkState)) == true) { return((aCell as IGtkState).State); } if (TypeValidator.IsCompatible(aCell.Owner.GetType(), typeof(IDrawingCell)) == true) { return((aCell.Owner as IDrawingCell).ResolveState()); } if (TypeValidator.IsCompatible(aCell.Owner.GetType(), typeof(Gtk.Widget)) == true) { return((aCell.Owner as Gtk.Widget).State); } return(StateType.Normal); }
public BaseGenericClientObservableListView(IList <T> aParentView) { if (aParentView == null) { throw new NullReferenceException("Parent view can't be null"); } parentView = aParentView; if (TypeValidator.IsCompatible(parentView.GetType(), typeof(IListEvents)) == true) { myAddedMethod = new ElementAddedInListObjectEvent(ElementAddedIntoMaster); myChangedMethod = new ElementChangedInListObjectEvent(ElementChangedInMaster); myListChangedMethod = new ListChangedEvent(MasterListChanged); myRemovedMethod = new ElementRemovedFromListObjectEvent(ElementRemovedFromMaster); mySortedMethod = new ElementsInListSortedEvent(ElementsSortedInMaster); (parentView as IListEvents).ElementAdded += myAddedMethod; (parentView as IListEvents).ElementChanged += myChangedMethod; (parentView as IListEvents).ElementRemoved += myRemovedMethod; (parentView as IListEvents).ElementsSorted += mySortedMethod; (parentView as IListEvents).ListChanged += myListChangedMethod; } }
public override IEnumerable <ErrorDiagnostic> GetDiagnostics() { var diagnostics = this.ValidateIdentifierAccess(); switch (this.Modifier) { case ParameterDefaultValueSyntax defaultValueSyntax: diagnostics = diagnostics.Concat(ValidateDefaultValue(defaultValueSyntax)); break; case ObjectSyntax modifierSyntax: if (this.Type.TypeKind != TypeKind.Error && this.TryGetPrimitiveType() is TypeSymbol primitiveType) { var modifierType = LanguageConstants.CreateParameterModifierType(primitiveType, this.Type); diagnostics = diagnostics.Concat(TypeValidator.GetExpressionAssignmentDiagnostics(this.Context.TypeManager, modifierSyntax, modifierType)); } break; } return(diagnostics); }
public void ValidBoolParameterModifierShouldProduceNoDiagnostics() { var obj = TestSyntaxFactory.CreateObject(new[] { TestSyntaxFactory.CreateProperty("default", TestSyntaxFactory.CreateBool(true)), TestSyntaxFactory.CreateProperty("allowed", TestSyntaxFactory.CreateArray(new [] { TestSyntaxFactory.CreateArrayItem(TestSyntaxFactory.CreateBool(false)) })), TestSyntaxFactory.CreateProperty("metadata", TestSyntaxFactory.CreateObject(new[] { TestSyntaxFactory.CreateProperty("description", TestSyntaxFactory.CreateString("my description")), TestSyntaxFactory.CreateProperty("extra1", TestSyntaxFactory.CreateString("extra")), TestSyntaxFactory.CreateProperty("extra2", TestSyntaxFactory.CreateBool(true)), TestSyntaxFactory.CreateProperty("extra3", TestSyntaxFactory.CreateInt(100)) })) }); TypeValidator.GetExpressionAssignmentDiagnostics(CreateTypeManager(), obj, LanguageConstants.CreateParameterModifierType(LanguageConstants.Bool)).Should().BeEmpty(); }
public static void SetGtkState(this IDrawingCell aCell, StateType aState) { if (TypeValidator.IsCompatible(aCell.GetType(), typeof(ICustomGtkState)) == true) { if ((aCell as ICustomGtkState).StateResolving == ValueResolveMethod.Manual) { (aCell as ICustomGtkState).CustomState = aState; } else { return; } return; } if (aCell.Owner != null) { if (TypeValidator.IsCompatible(aCell.Owner.GetType(), typeof(IDrawingCell)) == true) { (aCell.Owner as IDrawingCell).SetGtkState(aState); } } }
/// <summary> /// Handles ButtonPress event /// </summary> /// <param name="evnt"> /// Arguments <see cref="Gdk.EventButton"/> /// </param> /// <returns> /// true if handled, false if not <see cref="System.Boolean"/> /// </returns> protected override bool OnButtonPressEvent(Gdk.EventButton evnt) { if (HasFocus == false) { return(base.OnButtonPressEvent(evnt)); } IDrawingCell cell = mainbox.CellAtCoordinates(System.Convert.ToInt32(evnt.X), System.Convert.ToInt32(evnt.Y)); if (cell == null) { return(base.OnButtonPressEvent(evnt)); } if (TypeValidator.IsCompatible(cell.GetType(), typeof(DateText)) == true) { if ((int)(cell as DateText).Part < 3) { Selected = (cell as DateText).Part; return(true); } } return(base.OnButtonPressEvent(evnt)); }
private static IServiceCollection AddBaseGraphQLClientServices( this IServiceCollection services, string schema, IEnumerable <string> modelNamespaces = null) { services.AddTransient <IFieldValidator, FieldValidator>(); services.AddTransient <ISchemaValidator, SchemaValidator>(); var typeValidator = new TypeValidator(modelNamespaces ?? new List <string>()); services.AddSingleton <ITypeValidator>(typeValidator); services.AddTransient <IRequestBuilder, RequestBuilder>(); services.AddTransient <IResultBuilder, ResultBuilder>(); var schemaPrivider = new PartialSchemaProvider(); schemaPrivider.WithSchema(schema); services.AddSingleton <IPartialSchemaProvider>(schemaPrivider); return(services); }
public void UnionShouldBeAssignableToTypeIfAllMembersAre() { var boolIntUnion = UnionType.Create(LanguageConstants.Bool, LanguageConstants.Int); var stringUnion = UnionType.Create(LanguageConstants.String); TypeValidator.AreTypesAssignable(stringUnion, LanguageConstants.String).Should().BeTrue(); TypeValidator.AreTypesAssignable(stringUnion, LanguageConstants.Bool).Should().BeFalse(); TypeValidator.AreTypesAssignable(stringUnion, boolIntUnion).Should().BeFalse(); var logLevelsUnion = UnionType.Create(new StringLiteralType("Error"), new StringLiteralType("Warning"), new StringLiteralType("Info")); var failureLogLevelsUnion = UnionType.Create(new StringLiteralType("Error"), new StringLiteralType("Warning")); TypeValidator.AreTypesAssignable(logLevelsUnion, LanguageConstants.String).Should().BeTrue(); TypeValidator.AreTypesAssignable(logLevelsUnion, stringUnion).Should().BeTrue(); TypeValidator.AreTypesAssignable(logLevelsUnion, boolIntUnion).Should().BeFalse(); // Source union is a subset of target union - this should be allowed TypeValidator.AreTypesAssignable(failureLogLevelsUnion, logLevelsUnion).Should().BeTrue(); // Source union is a strict superset of target union - this should not be allowed TypeValidator.AreTypesAssignable(logLevelsUnion, failureLogLevelsUnion).Should().BeFalse(); }
private TypeDesc SimpleExpression(HashSet <SymbolEnum> followers) { bool hasPrefixSign = false; if (CurrentSymbol == SymbolEnum.Minus || CurrentSymbol == SymbolEnum.Plus) { hasPrefixSign = true; NextSymbol(); } var firstOperandType = NeutralizerDecoratorWithReturn(Term, Starters.Term, Followers.Term, 6, followers); if (hasPrefixSign) { if (!TypeValidator.SupportsSign(firstOperandType)) { Error(211); } } while (CurrentSymbol == SymbolEnum.Plus || CurrentSymbol == SymbolEnum.Minus || CurrentSymbol == SymbolEnum.OrSy) { var operation = CurrentSymbol; NextSymbol(); var secondOperandType = NeutralizerDecoratorWithReturn(Term, Starters.Term, Followers.Term, 6, followers); var expressionType = TypeValidator.GetTypeAfterAddition(firstOperandType, secondOperandType, operation); if (expressionType == null) { Error(328); } return(expressionType); } return(firstOperandType); }
// Слагаемое private TypeDesc Term(HashSet <SymbolEnum> followers) { var firstOperandType = NeutralizerDecoratorWithReturn(Factor, Starters.Factor, Followers.Factor, 6, followers); while (CurrentSymbol == SymbolEnum.Star || CurrentSymbol == SymbolEnum.Slash || CurrentSymbol == SymbolEnum.DivSy || CurrentSymbol == SymbolEnum.ModSy || CurrentSymbol == SymbolEnum.AndSy) { var operation = CurrentSymbol; NextSymbol(); var secondOperandType = NeutralizerDecoratorWithReturn(Factor, Starters.Factor, Followers.Factor, 6, followers); var expressionType = TypeValidator.GetTypeAfterMultiplication(firstOperandType, secondOperandType, operation); if (expressionType == null) { Error(328); } return(expressionType); } return(firstOperandType); }
public void InvalidArrayValuesShouldBeRejected() { var obj = TestSyntaxFactory.CreateObject(new[] { TestSyntaxFactory.CreateProperty("name", TestSyntaxFactory.CreateString("test")), // zones is an array of strings - set wrong item types TestSyntaxFactory.CreateProperty("zones", TestSyntaxFactory.CreateArray(new[] { TestSyntaxFactory.CreateArrayItem(TestSyntaxFactory.CreateBool(true)), TestSyntaxFactory.CreateArrayItem(TestSyntaxFactory.CreateInt(2)) })), // this property is an array - specify a string instead TestSyntaxFactory.CreateProperty("managedByExtended", TestSyntaxFactory.CreateString("not an array")) }); TypeValidator.GetExpressionAssignmentDiagnostics(CreateTypeManager(), obj, CreateDummyResourceType()) .Select(d => d.Message) .Should().BeEquivalentTo( "The enclosing array expected an item of type string, but the provided item was of type bool.", "The property 'managedByExtended' expected a value of type string[] but the provided value is of type 'not an array'.", "The enclosing array expected an item of type string, but the provided item was of type int."); }
//private Type validator; //public TypeValidationAttribute(Type propertyClassType) { // if (propertyClassType == null) // { // throw new ArgumentNullException("propertyClassType"); // } // if (!typeof (CoinValidatorBase).IsAssignableFrom(validator)) // { // throw new ArgumentException("Validator Attribute param not validator"); // } // type = propertyClassType; public override bool IsValid(object value) { PropertyDescriptorCollection properties = TypeDescriptor.GetProperties(value); object originalValue = properties.Find("Attendee", true /* ignoreCase */).GetValue(value); // object confirmValue = properties.Find(ConfirmProperty, true /* ignoreCase */).GetValue(value); return(false); if (AcceptedTypes == null) { AcceptedTypes = new List <Type>(); } if (AcceptedType1 != null) { AcceptedTypes.Add(AcceptedType1); } if (AcceptedType2 != null) { AcceptedTypes.Add(AcceptedType2); } var validator = new TypeValidator(AcceptedTypes); return(validator.IsValid(value.GetType())); }
public override void VisitFunctionCallSyntax(FunctionCallSyntax syntax) { // must have more than 1 argument to use interpolation if (syntax.NameEquals(concatFunction) && syntax.Arguments.Length > 1 && !syntax.GetParseDiagnostics().Any()) { // We should only suggest rewriting concat() calls that result in a string (concat can also operate on and // return arrays) var resultType = this.model.GetTypeInfo(syntax); if (resultType is not AnyType && TypeValidator.AreTypesAssignable(resultType, LanguageConstants.String)) { if (CreateFix(syntax) is CodeFix fix) { this.diagnostics.Add(parent.CreateFixableDiagnosticForSpan(syntax.Span, fix)); // Only report on the top-most string-valued concat call return; } } } base.VisitFunctionCallSyntax(syntax); }
protected override SyntaxBase ReplaceStringSyntax(StringSyntax syntax) { var declaredType = semanticModel.GetDeclaredType(syntax); if (semanticModel.GetTypeInfo(syntax) is not StringLiteralType actualType) { return(base.ReplaceStringSyntax(syntax)); } if (declaredType is null || TypeValidator.AreTypesAssignable(actualType, declaredType)) { return(base.ReplaceStringSyntax(syntax)); } var stringLiteralCandidates = Enumerable.Empty <StringLiteralType>(); if (declaredType is StringLiteralType stringLiteralType) { stringLiteralCandidates = stringLiteralType.AsEnumerable(); } else if (declaredType is UnionType unionType && unionType.Members.All(x => x.Type is StringLiteralType)) { stringLiteralCandidates = unionType.Members.Select(x => (StringLiteralType)x.Type); } var insensitiveMatch = stringLiteralCandidates.FirstOrDefault(x => StringComparer.OrdinalIgnoreCase.Equals(x.Name, actualType.Name)); if (insensitiveMatch == null) { return(base.ReplaceStringSyntax(syntax)); } var stringToken = new Token(TokenType.StringComplete, new TextSpan(0, 0), insensitiveMatch.Name, Enumerable.Empty <SyntaxTrivia>(), Enumerable.Empty <SyntaxTrivia>()); return(new StringSyntax(stringToken.AsEnumerable(), Enumerable.Empty <SyntaxBase>(), insensitiveMatch.RawStringValue.AsEnumerable())); }
public void Publics() { TokenValidationParameters validationParameters = new TokenValidationParameters(); Type type = typeof(TokenValidationParameters); PropertyInfo[] properties = type.GetProperties(); if (properties.Length != 43) { Assert.True(false, "Number of properties has changed from 43 to: " + properties.Length + ", adjust tests"); } TokenValidationParameters actorValidationParameters = new TokenValidationParameters(); SecurityKey issuerSigningKey = KeyingMaterial.DefaultX509Key_2048_Public; SecurityKey issuerSigningKey2 = KeyingMaterial.RsaSecurityKey_2048; List <SecurityKey> issuerSigningKeys = new List <SecurityKey> { KeyingMaterial.DefaultX509Key_2048_Public, KeyingMaterial.RsaSecurityKey_2048 }; List <SecurityKey> issuerSigningKeysDup = new List <SecurityKey> { KeyingMaterial.DefaultX509Key_2048_Public, KeyingMaterial.RsaSecurityKey_2048 }; string validAudience = "ValidAudience"; List <string> validAudiences = new List <string> { validAudience }; string validIssuer = "ValidIssuer"; List <string> validIssuers = new List <string> { validIssuer }; var propertyBag = new Dictionary <string, Object> { { "CustomKey", "CustomValue" } }; TypeValidator typeValidator = (typ, token, parameters) => "ActualType"; AlgorithmValidator algorithmValidator = ValidationDelegates.AlgorithmValidatorBuilder(false); var validTypes = new List <string> { "ValidType1", "ValidType2", "ValidType3" }; var validAlgorithms = new List <string> { "RSA2048", "RSA1024" }; TokenValidationParameters validationParametersInline = new TokenValidationParameters() { AlgorithmValidator = algorithmValidator, ActorValidationParameters = actorValidationParameters, AudienceValidator = ValidationDelegates.AudienceValidatorReturnsTrue, IssuerSigningKey = issuerSigningKey, IssuerSigningKeyResolver = (token, securityToken, keyIdentifier, tvp) => { return(new List <SecurityKey> { issuerSigningKey }); }, IssuerSigningKeys = issuerSigningKeys, IssuerValidator = ValidationDelegates.IssuerValidatorEcho, LifetimeValidator = ValidationDelegates.LifetimeValidatorReturnsTrue, PropertyBag = propertyBag, SignatureValidator = ValidationDelegates.SignatureValidatorReturnsJwtTokenAsIs, SaveSigninToken = true, TypeValidator = typeValidator, ValidAlgorithms = validAlgorithms, ValidateAudience = false, ValidateIssuer = false, ValidAudience = validAudience, ValidAudiences = validAudiences, ValidIssuer = validIssuer, ValidIssuers = validIssuers, ValidTypes = validTypes }; Assert.True(object.ReferenceEquals(actorValidationParameters, validationParametersInline.ActorValidationParameters)); Assert.True(object.ReferenceEquals(validationParametersInline.IssuerSigningKey, issuerSigningKey)); Assert.True(object.ReferenceEquals(validationParametersInline.PropertyBag, propertyBag)); Assert.True(validationParametersInline.SaveSigninToken); Assert.False(validationParametersInline.ValidateAudience); Assert.False(validationParametersInline.ValidateIssuer); Assert.True(object.ReferenceEquals(validationParametersInline.ValidAlgorithms, validAlgorithms)); Assert.True(object.ReferenceEquals(validationParametersInline.AlgorithmValidator, algorithmValidator)); Assert.True(object.ReferenceEquals(validationParametersInline.TypeValidator, typeValidator)); Assert.True(object.ReferenceEquals(validationParametersInline.ValidAudience, validAudience)); Assert.True(object.ReferenceEquals(validationParametersInline.ValidAudiences, validAudiences)); Assert.True(object.ReferenceEquals(validationParametersInline.ValidIssuer, validIssuer)); Assert.True(validationParametersInline.IgnoreTrailingSlashWhenValidatingAudience); TokenValidationParameters validationParametersSets = new TokenValidationParameters(); validationParametersSets.AlgorithmValidator = algorithmValidator; validationParametersSets.ActorValidationParameters = actorValidationParameters; validationParametersSets.AudienceValidator = ValidationDelegates.AudienceValidatorReturnsTrue; validationParametersSets.IssuerSigningKey = KeyingMaterial.DefaultX509Key_2048_Public; validationParametersSets.IssuerSigningKeyResolver = (token, securityToken, keyIdentifier, tvp) => { return(new List <SecurityKey> { issuerSigningKey2 }); }; validationParametersSets.IssuerSigningKeys = issuerSigningKeysDup; validationParametersSets.IssuerValidator = ValidationDelegates.IssuerValidatorEcho; validationParametersSets.LifetimeValidator = ValidationDelegates.LifetimeValidatorReturnsTrue; validationParametersSets.PropertyBag = propertyBag; validationParametersSets.SignatureValidator = ValidationDelegates.SignatureValidatorReturnsJwtTokenAsIs; validationParametersSets.SaveSigninToken = true; validationParametersSets.TypeValidator = typeValidator; validationParametersSets.ValidateAudience = false; validationParametersSets.ValidateIssuer = false; validationParametersSets.ValidAlgorithms = validAlgorithms; validationParametersSets.ValidAudience = validAudience; validationParametersSets.ValidAudiences = validAudiences; validationParametersSets.ValidIssuer = validIssuer; validationParametersSets.ValidIssuers = validIssuers; validationParametersSets.ValidTypes = validTypes; var compareContext = new CompareContext(); IdentityComparer.AreEqual(validationParametersInline, validationParametersSets, compareContext); IdentityComparer.AreEqual(validationParametersInline.Clone() as TokenValidationParameters, validationParametersInline, compareContext); string id = Guid.NewGuid().ToString(); DerivedTokenValidationParameters derivedValidationParameters = new DerivedTokenValidationParameters(id, validationParametersInline); DerivedTokenValidationParameters derivedValidationParametersCloned = derivedValidationParameters.Clone() as DerivedTokenValidationParameters; IdentityComparer.AreEqual(derivedValidationParameters, derivedValidationParametersCloned, compareContext); IdentityComparer.AreEqual(derivedValidationParameters.InternalString, derivedValidationParametersCloned.InternalString, compareContext); TestUtilities.AssertFailIfErrors(compareContext); }
private bool IsValidBooking(BookingModel booking, Result result) { if (TypeValidator.Validate(booking) == FlowOptions.Failed) { result.AddMessageToList(BookingResource.NotValidBooking); } else { if (booking.StartDate >= booking.EndDate) { result.AddMessageToList(BookingResource.DatesNotValid); } if (TypeValidator.Validate(booking.IdHotel) == FlowOptions.Failed) { result.AddMessageToList(BookingResource.HotelRequired); } if (TypeValidator.Validate(booking.IdRoom) == FlowOptions.Failed) { result.AddMessageToList(BookingResource.RoomRequired); } if (TypeValidator.Validate(booking.ApplicantName) == FlowOptions.Failed) { result.AddMessageToList(BookingResource.ApplicantRequired); } if (TypeValidator.Validate(booking.Email) == FlowOptions.Failed) { result.AddMessageToList(BookingResource.EmailRequired); } if (TypeValidator.Validate(booking.ContactName) == FlowOptions.Failed) { result.AddMessageToList(BookingResource.ContactNameRequired); } if (TypeValidator.Validate(booking.ContactPhone) == FlowOptions.Failed) { result.AddMessageToList(BookingResource.ContactPhoneRequired); } foreach (GuestModel guest in booking.Guests) { if (TypeValidator.Validate(guest) == FlowOptions.Failed) { result.AddMessageToList(BookingResource.NotValidGuest); } else { if (TypeValidator.Validate(guest.Name) == FlowOptions.Failed) { result.AddMessageToList(BookingResource.GuestNameRequired); } if (TypeValidator.Validate(guest.LastName) == FlowOptions.Failed) { result.AddMessageToList(BookingResource.GuestLastNRequired); } if (TypeValidator.Validate(guest.BirtDate) == FlowOptions.Failed) { result.AddMessageToList(BookingResource.GuestBirtRequired); } if (TypeValidator.Validate(guest.Name) == FlowOptions.Failed) { result.AddMessageToList(BookingResource.GuestNameRequired); } if (TypeValidator.Validate(guest.LastName) == FlowOptions.Failed) { result.AddMessageToList(BookingResource.GuestLastNRequired); } if (TypeValidator.Validate(guest.BirtDate) == FlowOptions.Failed) { result.AddMessageToList(BookingResource.GuestBirtRequired); } if (TypeValidator.Validate(guest.Genre) == FlowOptions.Failed) { result.AddMessageToList(BookingResource.GuestGenreRequired); } if (TypeValidator.Validate(guest.Identification) == FlowOptions.Failed) { result.AddMessageToList(BookingResource.GuestIdRequired); } if (TypeValidator.Validate(guest.IdentificationType) == FlowOptions.Failed) { result.AddMessageToList(BookingResource.GuestIdTypeRequired); } if (TypeValidator.Validate(guest.Email) == FlowOptions.Failed) { result.AddMessageToList(BookingResource.GuesEmailRequired); } if (TypeValidator.Validate(guest.PhoneNumber) == FlowOptions.Failed) { result.AddMessageToList(BookingResource.GuestPhoneRequired); } } } } return((result.Messages.Count == 0) ? true : false); }
private bool CheckedMember(MemberExpression column) { var result = column != null && TypeValidator.IsValidat(column.Member.Name) == false; return(result); }
public override Expression Visit(Expression node) { if (node == null) { return(node); } var targetExpression = QueryModelVisitor.QueryCompilationContext.QuerySourceMapping .GetExpression(_querySource); if (targetExpression.Type == typeof(ValueBuffer) && !CheckedMember(node as MemberExpression)) { return(node); } var result = base.Visit(node); if (result.NodeType == ExpressionType.Convert) { var convert = result as UnaryExpression; var pas = convert.Operand as MethodCallExpression; var parmeter = pas.Arguments.ToArray()[0] as ConstantExpression; if (parmeter.Type == typeof(int) && object.Equals(parmeter.Value, -999)) { parmeter = Expression.Constant(0); var gentMethod = convertMethod.MakeGenericMethod(convert.Type, parmeter.Type); pas = Expression.Call(gentMethod, parmeter); result = Expression.Convert(pas, convert.Type); } return(result); } switch (node) { case MemberExpression column: if (TypeValidator.IsValidat(column.Member.Name) == false) { var select = column.Expression as QuerySourceReferenceExpression; var type = select.ReferencedQuerySource.ItemType; for (int i = 0; i < Projection.Count; i++) { var col = Projection[i] as ColumnExpression; if (col.Name == column.Member.Name) { Projection.RemoveAt(i); } } } break; default: break; } //var column = node as MemberExpression; //if (column != null && TypeValidator.IsValidat(column.Member.Name) == false) //{ // var select = column.Expression as QuerySourceReferenceExpression; // var type = select.ReferencedQuerySource.ItemType; // for (int i = 0; i < Projection.Count; i++) // { // var col = Projection[i] as ColumnExpression; // if (col.Name == column.Member.Name) // { // Projection.RemoveAt(i); // } // } //} return(result); }
public static bool MasterIsGtkWidget(this IDrawingCell aCell) { return(TypeValidator.IsCompatible(aCell.Master.GetType(), typeof(Gtk.Widget)) == true); }
protected void AddValidation(string field, TypeValidator validator, string[] args = null) { switch (validator) { case TypeValidator.CampoObrigatorio: Details.Add(new ErrorDetail() { message = string.Format("Campo {0}: obrigatório.", field) }); break; case TypeValidator.CampoTamanho: Details.Add(new ErrorDetail() { message = string.Format("Campo {0}: tamanho máximo: {1} caracteres.", field, args[0]) }); break; case TypeValidator.CampoTamanhoIntervalo: Details.Add(new ErrorDetail() { message = string.Format("Campo {0}: valor inválido (mínimo: {1}, máximo: {2}).", field, args[0], args[1]) }); break; case TypeValidator.CampoTamanhoUnico: Details.Add(new ErrorDetail() { message = string.Format("Campo {0}: tamanho obrigatório de {1} caracteres.", field, args[0]) }); break; case TypeValidator.CampoValorInvalido: Details.Add(new ErrorDetail() { message = string.Format("Campo {0}: valor inválido.", field) }); break; case TypeValidator.CampoNaoExisteBanco: Details.Add(new ErrorDetail() { message = string.Format("O campo {0} não tem valor relacionado na tabela {1}", field, args[0]) }); break; case TypeValidator.CampoDuplicado: Details.Add(new ErrorDetail() { message = string.Format("Já existe um {0} com o valor informado.", field) }); break; case TypeValidator.None: Details.Add(new ErrorDetail() { message = args[0] }); break; } }
public void TestInit() { this.mockReflectHelper = new Mock <ReflectHelper>(); this.typeValidator = new TypeValidator(this.mockReflectHelper.Object); this.warnings = new List <string>(); }
public void DiscriminatedObjectType_raises_appropriate_diagnostics_for_matches() { var discriminatedType = new DiscriminatedObjectType( "discObj", "myDiscriminator", new [] { new NamedObjectType("typeA", new [] { new TypeProperty("myDiscriminator", new StringLiteralType("valA")), new TypeProperty("fieldA", LanguageConstants.Any, TypePropertyFlags.Required), }, null), new NamedObjectType("typeB", new [] { new TypeProperty("myDiscriminator", new StringLiteralType("valB")), new TypeProperty("fieldB", LanguageConstants.Any, TypePropertyFlags.Required), }, null), }); // no discriminator field supplied var obj = TestSyntaxFactory.CreateObject(new [] { TestSyntaxFactory.CreateProperty("fieldA", TestSyntaxFactory.CreateString("someVal")), }); var errors = TypeValidator.GetExpressionAssignmentDiagnostics(CreateTypeManager(), obj, discriminatedType); errors.Should().SatisfyRespectively( x => { x.Message.Should().Be("The property 'myDiscriminator' requires a value of type 'valA' | 'valB', but none was supplied."); }); // incorrect type specified for the discriminator field obj = TestSyntaxFactory.CreateObject(new [] { TestSyntaxFactory.CreateProperty("myDiscriminator", TestSyntaxFactory.CreateObject(Enumerable.Empty <ObjectPropertySyntax>())), TestSyntaxFactory.CreateProperty("fieldB", TestSyntaxFactory.CreateString("someVal")), }); errors = TypeValidator.GetExpressionAssignmentDiagnostics(CreateTypeManager(), obj, discriminatedType); errors.Should().SatisfyRespectively( x => { x.Message.Should().Be("The property 'myDiscriminator' expected a value of type 'valA' | 'valB' but the provided value is of type object."); }); // discriminator value that matches neither option supplied obj = TestSyntaxFactory.CreateObject(new [] { TestSyntaxFactory.CreateProperty("myDiscriminator", TestSyntaxFactory.CreateString("valC")), }); errors = TypeValidator.GetExpressionAssignmentDiagnostics(CreateTypeManager(), obj, discriminatedType); errors.Should().SatisfyRespectively( x => { x.Message.Should().Be("The property 'myDiscriminator' expected a value of type 'valA' | 'valB' but the provided value is of type 'valC'."); }); // missing required property for the 'valB' branch obj = TestSyntaxFactory.CreateObject(new [] { TestSyntaxFactory.CreateProperty("myDiscriminator", TestSyntaxFactory.CreateString("valB")), }); errors = TypeValidator.GetExpressionAssignmentDiagnostics(CreateTypeManager(), obj, discriminatedType); errors.Should().SatisfyRespectively( x => { x.Message.Should().Be("The specified object is missing the following required properties: fieldB."); }); // supplied the required property for the 'valB' branch obj = TestSyntaxFactory.CreateObject(new [] { TestSyntaxFactory.CreateProperty("myDiscriminator", TestSyntaxFactory.CreateString("valB")), TestSyntaxFactory.CreateProperty("fieldB", TestSyntaxFactory.CreateString("someVal")), }); errors = TypeValidator.GetExpressionAssignmentDiagnostics(CreateTypeManager(), obj, discriminatedType); errors.Should().BeEmpty(); }
public void NonLiteralExpression_IsLiteralExpression_ShouldReturnViolations(string displayName, SyntaxBase expression) { TypeValidator.GetCompileTimeConstantViolation(expression).Should().NotBeEmpty(); }
public void NonExpressionShouldProduceNoViolations(string displayName, SyntaxBase expression) { TypeValidator.GetCompileTimeConstantViolation(expression).Should().BeEmpty(); }
public void EmptyModifierIsValid() { var obj = TestSyntaxFactory.CreateObject(new ObjectPropertySyntax[0]); TypeValidator.GetExpressionAssignmentDiagnostics(CreateTypeManager(), obj, LanguageConstants.CreateParameterModifierType(LanguageConstants.Int)).Should().BeEmpty(); }
public void VariousObjects_ShouldProduceNoDiagnosticsWhenAssignedToObjectType(string displayName, ObjectSyntax @object) { TypeValidator.GetExpressionAssignmentDiagnostics(CreateTypeManager(), @object, LanguageConstants.Object).Should().BeEmpty(); }
public bool CanAttachTo(TypeSymbol targetType) => TypeValidator.AreTypesAssignable(targetType, attachableType);
public void AnyTypeShouldBeAssignableToAnyType() { TypeValidator.AreTypesAssignable(LanguageConstants.Any, LanguageConstants.Any).Should().BeTrue(); }