public void AllEntitiesInheritEntityBase() { var failed = false; var exclusions = new Type[] { }; foreach (var testType in TestTypes) { var types = testType.Assembly.GetTypes().Where(t => t.Namespace.IfNullOrEmpty("").Contains(".Entities")).OrderBy(t => t.Name); foreach (var type in types) { if (exclusions.Contains(type) || type.IsAbstract || type.IsSealed || type.IsEnum || type.Namespace.IfNullOrEmpty("").EndsWith("Entities.Components")) continue; if(typeof (EntityBase).IsAssignableFrom(type)) { Debug.WriteLine("PASS | " + type.Name); continue; } failed = true; Debug.WriteLine("FAIL | " + type.Name); } } Assert.IsFalse(failed); }
public static HbmMapping LoadMappingFrom(params Assembly[] assemblies) { Require.NotNull(assemblies, "assemblies"); var baseTypes = new Type[] { typeof(ClassMapping<>), typeof(JoinedSubclassMapping<>), typeof(UnionSubclassMapping<>), typeof(SubclassMapping<>) }; var mapper = new ModelMapper(); foreach (var asm in assemblies) { foreach (var type in asm.GetTypes()) { if (!type.IsClass || type.IsAbstract || type.IsInterface || !type.BaseType.IsGenericType) continue; if (!baseTypes.Contains(type.BaseType.GetGenericTypeDefinition())) continue; mapper.AddMapping(type); } } var mapping = mapper.CompileMappingForAllExplicitlyAddedEntities(); mapping.autoimport = false; return mapping; }
/// <inheritdoc /> public object CreateProxy (Type baseType, Type[] implementedInterfaces, object[] constructorArguments) { if (baseType.IsInterface) { // TODO: should Moq.Core do this work? It's the same for // Castle and LinFu and presumably other (future?) libraries var fixedInterfaces = new Type[implementedInterfaces.Length + 1]; fixedInterfaces[0] = baseType; implementedInterfaces.CopyTo (fixedInterfaces, 1); implementedInterfaces = fixedInterfaces; baseType = typeof (object); } if (!implementedInterfaces.Contains(typeof(IProxy))) { var fixedInterfaces = new Type[implementedInterfaces.Length + 1]; fixedInterfaces[0] = typeof(IProxy); implementedInterfaces.CopyTo (fixedInterfaces, 1); implementedInterfaces = fixedInterfaces; } // TODO: the proxy factory should automatically detect requests to proxy // delegates and generate an interface on the fly for them, without Moq // having to know about it at all. return generator.CreateClassProxy (baseType, implementedInterfaces, proxyOptions, constructorArguments, new Interceptor ()); }
public object CreateProxy (Type baseType, Type[] implementedInterfaces, object[] constructorArguments) { if (baseType.IsInterface) { // TODO: should Moq.Core do this work? It's the same for // Castle and LinFu and presumably other (future?) libraries var fixedInterfaces = new Type[implementedInterfaces.Length + 1]; fixedInterfaces[0] = baseType; implementedInterfaces.CopyTo (fixedInterfaces, 1); implementedInterfaces = fixedInterfaces; baseType = typeof (object); } // TODO: this code is duplicated exactly from the Castle proxy factory. if (!implementedInterfaces.Contains (typeof (IProxy))) { var fixedInterfaces = new Type[implementedInterfaces.Length + 1]; fixedInterfaces[0] = typeof (IProxy); implementedInterfaces.CopyTo (fixedInterfaces, 1); implementedInterfaces = fixedInterfaces; } // TODO: the proxy factory should automatically detect requests to proxy // delegates and generate an interface on the fly for them, without Moq // having to know about it at all. // NOTE: LinFu doesn't support passing ctor args??!?!?! if (constructorArguments.Length != 0) throw new NotSupportedException (); return factory.CreateProxy(baseType, new Interceptor (), implementedInterfaces); }
/// <summary> /// /// </summary> /// <param name="attributes">The list of available attributes</param> /// <param name="container">This is the type of container we are searchig attributes for.</param> /// <returns>The attributes matching the <see cref="EdiStructureType"/></returns> public static IEnumerable<EdiAttribute> OfType(this IEnumerable<EdiAttribute> attributes, EdiStructureType container) { var typesToSearch = new Type[0]; switch (container) { case EdiStructureType.None: case EdiStructureType.Interchange: break; case EdiStructureType.Group: typesToSearch = new [] { typeof(EdiGroupAttribute) }; break; case EdiStructureType.Message: typesToSearch = new [] { typeof(EdiMessageAttribute) }; break; case EdiStructureType.SegmentGroup: typesToSearch = new [] { typeof(EdiSegmentGroupAttribute) }; break; case EdiStructureType.Segment: typesToSearch = new [] { typeof(EdiSegmentAttribute), typeof(EdiSegmentGroupAttribute) }; break; case EdiStructureType.Element: typesToSearch = new [] { typeof(EdiElementAttribute) }; break; default: break; } return null == typesToSearch ? Enumerable.Empty<EdiAttribute>() : attributes.Where(a => typesToSearch.Contains(a.GetType())); }
public bool HasSupportFor(Type[] scenarios) { if (IsTravis && scenarios.Contains(Type.Integration)) { return false; } return true; }
private static Type FindCommandTypeInMethodParameters(Type[] commandTypes, MethodInfo handlerMethod) { var commandParam = handlerMethod.GetParameters().FirstOrDefault(p => commandTypes.Contains(p.ParameterType)); if (commandParam != null) return commandParam.ParameterType; return null; }
private void InitializeCaches(string expressionStringValue) { var parser = new ExpressionParser(); cachedExpressionString = expressionStringValue; cachedExpression = parser.EvaluateExpression(cachedExpressionString.ToLower()); System.Type[] types = new System.Type[inputs.Length]; for (int i = 0; i < inputs.Length; i++) { types[i] = inputs[i].GetVariable(this).Type; if (types[i] != typeof(int) && types[i] != typeof(float) && types[i] != typeof(Vector2) && types[i] != typeof(Vector3)) { Debug.LogError("Expression Action only supports int, float, Vector2 and Vector3 variables!"); } } if (types.Contains(typeof(Vector2)) && types.Contains(typeof(Vector3))) { Debug.LogError("Expression Action can't use Vector2 and Vector3 simultaneously!"); } if (types.Contains(typeof(Vector3))) { evaluatedOutputType = typeof(Vector3); outputComponentCount = 3; } else if (types.Contains(typeof(Vector2))) { evaluatedOutputType = typeof(Vector2); outputComponentCount = 2; } else if (types.Contains(typeof(float))) { evaluatedOutputType = typeof(float); outputComponentCount = 1; } else { evaluatedOutputType = typeof(int); outputComponentCount = 1; } }
private bool IsBetterChoice(ConstructorInfo current, ConstructorInfo candidate, Type[] existingTypes) { if (current == null) return true; if (candidate.GetParameters() .Where(x => !existingTypes.Contains(x.ParameterType)) .Any(x => x.ParameterType.IsSealed && !x.ParameterType.IsArray)) return false; return current.GetParameters().Length < candidate.GetParameters().Length; }
public static string ToJson(this object entityClass) { JObject json = new JObject(); Type[] MainProperties = new Type[] { typeof(bool), typeof(string), typeof(long), typeof(int), typeof(Int32), typeof(double), typeof(float) }; // Is a Simple Class Type t = entityClass.GetType(); foreach (PropertyInfo info in t.GetProperties()) { // is System Main type of [Custom Type] if (!MainProperties.Contains(info.PropertyType)) { string innerClassJson = info.GetValue(entityClass).ToJson(); json.Add(info.Name.ToLower(), innerClassJson); } else { Type propertytype = info.PropertyType; if (propertytype == typeof(string)) { json.Add(info.Name.ToLower(), info.GetValue(entityClass) == null ? "" : info.GetValue(entityClass).ToString()); } else if (propertytype == typeof(int)) { json.Add(info.Name.ToLower(), int.Parse(info.GetValue(entityClass).ToString())); } else if (propertytype == typeof(long)) { json.Add(info.Name.ToLower(), long.Parse(info.GetValue(entityClass).ToString())); } else if (propertytype == typeof(double)) { json.Add(info.Name.ToLower(), float.Parse(info.GetValue(entityClass).ToString())); } else if (propertytype == typeof(bool)) { json.Add(info.Name.ToLower(), bool.Parse(info.GetValue(entityClass).ToString())); } } } return(json.ToString().Replace("\\\"", "\"").Replace("\"[", "[").Replace("]\"", "]").Replace("\"{", "{").Replace("}\"", "}").Replace("\r\n", "")); }
/// <summary> /// Search an IQueryable's fields for the keywords (objects) - this does not iterate through levels of an object /// </summary> /// <param name="list_to_search">IQueryable to search</param> /// <param name="types_to_explore">array of types to search, others will be ignored</param> /// <param name="keywords">objects to search for</param> /// <returns>IQueryable of the inputed type filtered by the search specifications</returns> public static IQueryable Search( this IQueryable list_to_search, Type[] types_to_explore, object[] keywords ) { list_to_search.NotNull(); Dictionary<string, Type> dic = new Dictionary<string, Type>(); foreach( var item in list_to_search.Take( 1 ) ) { foreach( PropertyInfo pi in item.GetType().GetProperties() ) { if( types_to_explore.Contains( pi.PropertyType ) ) { dic.Add( pi.Name, pi.PropertyType ); } } } return list_to_search.Search( dic, keywords ); }
public static bool Contains(this Exception e, Type[] exceptionTypes) { bool result = false; while (e != null) { if (exceptionTypes.Contains(e.GetType())) { result = true; break; } e = e.InnerException; } return result; }
public void AllEntitiesInitializeComponents() { var failed = false; var exclusions = new Type[] { }; foreach (var testType in TestTypes) { var types = testType.Assembly.GetTypes().Where(t => t.Namespace.IfNullOrEmpty("").Contains(".Entities")).OrderBy(t => t.Name); foreach (var type in types) { if (exclusions.Contains(type) || type.IsAbstract || type.IsSealed || type.IsEnum || type.Namespace.IfNullOrEmpty("").EndsWith("Entities.Components")) continue; if (typeof(EntityBase).IsAssignableFrom(type)) { var components = type.GetProperties(BindingFlags.Instance | BindingFlags.Public) .Where(t => t.PropertyType.Namespace.EndsWith("Entities.Components")); if (components.Any()) { var obj = Activator.CreateInstance(type); foreach (var list in components) { var val = list.GetValue(obj, null); if (val == null) { Debug.WriteLine("FAIL | " + type.Name + "." + list.Name); failed = true; } else Debug.WriteLine("PASS | " + type.Name + "." + list.Name); } } } } } Assert.IsFalse(failed); }
/* * output - a destination to write results out to. To write output * to the standard output, pass in System.Console.Out */ public static void Run(TextWriter output, Result result) { Assert.Output = output; Suite suite = new Suite(); Type[] entryAssemblyTypes = Assembly.GetEntryAssembly().GetTypes(); Type[] forbiddenTypes = new Type[] { GetTypeFromAssemblyTypes(entryAssemblyTypes, "TestRunner") , GetTypeFromAssemblyTypes(entryAssemblyTypes, "WasRunObj") , GetTypeFromAssemblyTypes(entryAssemblyTypes, "WasRunSetUpFailed") }; foreach (Type t in entryAssemblyTypes) { if (t.IsSubclassOf(typeof(TDDUnit.Case)) && !forbiddenTypes.Contains(t)) { suite.Add(t); } } foreach (string test in suite.FailedTests(result)) { output.WriteLine("Failed: " + test); } output.WriteLine(result.Summary); }
public bool AnyOnStack(Type[] parsedTypes) { return _stack.Any(partial => { return parsedTypes.Contains(partial.GetType()); }); }
private static bool TryGetGenericType(this Type type, Type[] acceptableTypes, out Type collectionOf) { if (!type.IsGenericType) { collectionOf = null; return false; } var genericType = type.GetGenericTypeDefinition(); if (acceptableTypes.Contains(genericType)) { collectionOf = type.GetGenericArguments()[0]; return true; } collectionOf = null; return false; }
private static void VerifyDependencies() { var gameObjects = GameObject.FindObjectsOfType(typeof(GameObject)).Where(go => go.name != "[SaveIt]").ToArray(); var usableDependencyTypes = new System.Type[] { typeof(Mesh), typeof(Material), typeof(PhysicMaterial), typeof(Shader), typeof(Texture), typeof(Texture2D), typeof(AudioClip), typeof(ProceduralMaterial), typeof(AnimationClip), typeof(Font) }; var dependencies = EditorUtility.CollectDependencies(gameObjects) .Where(dependency1 => { if (dependency1 == null) { return false; } var want = usableDependencyTypes.Contains(dependency1.GetType()); return want; }) .Union(new Object[] { new PhysicMaterial() { name = "Default" } }) .Select(dependency2 => { var path = AssetDatabase.GetAssetPath(dependency2); if (string.IsNullOrEmpty(path)) { path = "$" + dependency2.name; } return new ResourceEntry() { Name = dependency2.name, Resource = dependency2, TypeName = dependency2.GetType().FullName }; }); dependencies = dependencies.Union(GameObject.FindObjectsOfType(typeof(Saveable)) .Where(saveable => ((Saveable)saveable).Prefab != null) .Select(saveable => { var prefab = ((Saveable)saveable).Prefab; return new ResourceEntry() { Name = prefab.name, Resource = prefab, TypeName = prefab.GetType().FullName }; })); var saveItGameObject = (GameObject)GameObject.Find("[SaveIt]"); if (saveItGameObject == null) { saveItGameObject = new GameObject("[SaveIt]"); } var saveItComponent = saveItGameObject.GetComponent<SaveItComponent>(); if (saveItComponent == null) { saveItComponent = saveItGameObject.AddComponent<SaveItComponent>(); } saveItComponent.ResourceEntries = dependencies.Distinct().ToArray(); }
/// <summary> /// Returns code to instantiate an equivalent instance of the given value /// </summary> /// <param name="value">value to instantiate</param> /// <returns>code to instantiate the value</returns> private string ConvertToCode(object value) { Globalization.CultureInfo realCulture = Globalization.CultureInfo.CurrentCulture; // null is easy // if (value == null) return "null"; try { System.Threading.Thread.CurrentThread.CurrentCulture = Globalization.CultureInfo.InvariantCulture; // switch based on the type Type type = value.GetType(); Type[] simpleTypes = new Type[] { typeof(bool), typeof(int) }; Type[] castTypes = new Type[] { typeof(byte), typeof(short), typeof(ushort), typeof(sbyte) }; if (simpleTypes.Contains(type)) return value.ToString().ToLower(); else if (castTypes.Contains(type)) return "(" + type.FullName + ")(" + value.ToString() + ")"; else if (type == typeof(uint)) return value.ToString() + "U"; else if (type == typeof(long)) return value.ToString() + "L"; else if (type == typeof(ulong)) return value.ToString() + "UL"; else if (type == typeof(decimal)) return value.ToString() + "M"; else if (type == typeof(float)) { if (float.IsNegativeInfinity((float)value)) return "float.NegativeInfinity"; if (float.IsPositiveInfinity((float)value)) return "float.PositiveInfinity"; if (float.IsNaN((float)value)) return "float.NaN"; if ((float)value == float.MaxValue) return "float.MaxValue"; if ((float)value == float.MinValue) return "float.MinValue"; return value.ToString() + "f"; } else if (type == typeof(double)) { if (double.IsNegativeInfinity((double)value)) return "double.NegativeInfinity"; if (double.IsPositiveInfinity((double)value)) return "double.PositiveInfinity"; if (double.IsNaN((double)value)) return "double.NaN"; if ((double)value == double.MaxValue) return "double.MaxValue"; if ((double)value == double.MinValue) return "double.MinValue"; return value.ToString() + "d"; } else if (type == typeof(string)) return "\"" + value + "\""; else if (type == typeof(byte[])) return "new byte[] { " + string.Join(", ", (value as byte[]).Select(b => b.ToString()).ToArray()) + "}"; else if (type == typeof(Guid)) return "new Guid(\"" + value.ToString() + "\")"; else if (type == typeof(DateTime)) { DateTime dt = (DateTime)value; return "new DateTime(" + dt.Ticks + ", DateTimeKind." + dt.Kind.ToString() + ")"; } else { // may need to add more cases in the future, for now this is sufficient throw new NotSupportedException(); } } finally { System.Threading.Thread.CurrentThread.CurrentCulture = realCulture; } }
private static bool CheckIfAllowedTemplatesContainsDefaultTemplate(Type[] allowedTemplates, Type defaultTemplate) { return (allowedTemplates.Any() && !allowedTemplates.Contains(defaultTemplate)); }
public async Task LoginAsync(UserStatus initialStatus = UserStatus.Online) { await @lock.WriterLockAsync(); try { if (IsLoggedIn) return; IConnection connection = null; ConnectionStream stream = null; CommandReader reader = null; CommandWriter writer = null; ResponseTracker responseTracker = null; IConnectableObservable<Command> commands = null; IDisposable commandsDisposable = null; int transferCount = 0; SocketEndPoint endPoint = SocketEndPoint.Parse("messenger.hotmail.com:1863"); string authTicket = null; while (authTicket == null) { connection = new SocketConnection(); await connection.ConnectAsync(endPoint); stream = new ConnectionStream(connection); writer = new CommandWriter(stream); reader = new CommandReader(stream, new Dictionary<string, Type> { { "VER", typeof(VersionCommand) }, { "CVR", typeof(ClientVersionCommand) }, { "USR", typeof(AuthenticateCommand) }, { "XFR", typeof(TransferCommand) }, { "SYN", typeof(SynchronizeCommand) }, { "SBS", typeof(SbsCommand) }, { "MSG", typeof(MessageCommand) }, { "LST", typeof(UserCommand) }, { "LSG", typeof(GroupCommand) }, { "BPR", typeof(UserPropertyCommand) }, { "BLP", typeof(PrivacySettingCommand) }, { "GTC", typeof(PrivacySettingCommand) }, { "CHG", typeof(ChangeStatusCommand) }, { "UBX", typeof(BroadcastCommand) }, { "PRP", typeof(LocalPropertyCommand) }, { "NLN", typeof(UserOnlineCommand) }, { "ILN", typeof(InitialUserOnlineCommand) }, { "FLN", typeof(UserOfflineCommand) }, { "UUX", typeof(SendBroadcastCommand) }, { "NOT", typeof(NotificationCommand) }, { "QNG", typeof(PingCommand) }, { "CHL", typeof(ChallengeCommand) }, { "ADC", typeof(AddContactCommand) }, { "REM", typeof(RemoveContactCommand) }, { "ADG", typeof(AddGroupCommand) }, { "RMG", typeof(RemoveGroupCommand) }, { "REG", typeof(RenameGroupCommand) }, { "QRY", typeof(AcceptChallengeCommand) }, { "RNG", typeof(RingCommand) }, { "SBP", typeof(ChangeUserPropertyCommand) }, { "IMS", typeof(EnableIMCommand) }, }); commands = reader.GetReadObservable().Publish(); responseTracker = new ResponseTracker(writer, commands); commandsDisposable = commands.Connect(); var versionCommand = new VersionCommand("MSNP12"); var versionResponse = await responseTracker.GetResponseAsync<VersionCommand>(versionCommand, defaultTimeout); if (versionResponse.Versions.Length == 0) throw new ProtocolNotAcceptedException(); var clientVersionCommand = new ClientVersionCommand { LocaleId = "0x0409", OsType = "winnt", OsVersion = "5.0", Architecture = "1386", LibraryName = "MSMSGS", ClientVersion = "5.0.0482", ClientName = "WindowsMessenger", LoginName = credentials.LoginName, }; await responseTracker.GetResponseAsync<ClientVersionCommand>(clientVersionCommand, defaultTimeout); var userCommand = new AuthenticateCommand("TWN", "I", credentials.LoginName); var userResponse = await responseTracker.GetResponseAsync(userCommand, new Type[] { typeof(AuthenticateCommand), typeof(TransferCommand) }, defaultTimeout); if (userResponse is AuthenticateCommand) { authTicket = (userResponse as AuthenticateCommand).Argument; } else if (userResponse is TransferCommand) { TransferCommand transferResponse = userResponse as TransferCommand; if (transferCount > 3) throw new InvalidOperationException("The maximum number of redirects has been reached."); transferCount++; endPoint = SocketEndPoint.Parse(transferResponse.Host); commandsDisposable.Dispose(); reader.Close(); writer.Close(); connection.Dispose(); } } PassportAuthentication auth = new PassportAuthentication(); string authToken = await auth.GetToken(credentials.LoginName, credentials.Password, authTicket); var authCommand = new AuthenticateCommand("TWN", "S", authToken); var authResponse = await responseTracker.GetResponseAsync<AuthenticateCommand>(authCommand, defaultTimeout); var synCommand = new SynchronizeCommand(syncTimeStamp1 ?? "0", syncTimeStamp2 ?? "0"); var synResponse = await responseTracker.GetResponseAsync<SynchronizeCommand>(synCommand, defaultTimeout); IDisposable syncCommandsSubscription = null; List<Command> syncCommands = null; if (synResponse.TimeStamp1 != syncTimeStamp1 || synResponse.TimeStamp2 != syncTimeStamp2) { syncCommands = new List<Command>(); Type[] syncTypes = new Type[] { typeof(MessageCommand), typeof(UserCommand), typeof(GroupCommand), typeof(LocalPropertyCommand), typeof(PrivacySettingCommand), }; syncCommandsSubscription = commands .Where(c => syncTypes.Contains(c.GetType())) .Catch(Observable.Empty<Command>()) .Subscribe(c => syncCommands.Add(c)); //if we're expecting users/groups, wait for them before we proceed if (synResponse.UserCount + synResponse.GroupCount > 0) { await commands .Where(c => c is UserCommand || c is GroupCommand) .Take(synResponse.UserCount + synResponse.GroupCount) .Timeout(defaultTimeout); } } UserCapabilities capabilities = 0; MSNObject displayPicture = MSNObject.Empty; if (LocalUser != null) { capabilities = LocalUser.Capabilities; displayPicture = LocalUser.DisplayPicture; } Command changeStatusCommand = new ChangeStatusCommand(User.StatusToString(UserStatus.Online), (uint)capabilities, displayPicture != MSNObject.Empty ? displayPicture.ToString() : "0"); await responseTracker.GetResponseAsync(changeStatusCommand, defaultTimeout); if (syncCommandsSubscription != null) syncCommandsSubscription.Dispose(); this.writer = writer; this.reader = reader; this.stream = stream; this.connection = connection; this.responseTracker = responseTracker; this.commands = commands; this.commandsDisposable = commandsDisposable; if (LocalUser == null) { LocalUser = new LocalUser(this, credentials.LoginName); userCache.Add(credentials.LoginName, new WeakReference(LocalUser)); } LocalUser.Status = initialStatus; SyncEvents syncEvents = null; if (syncCommands != null) { syncTimeStamp1 = synResponse.TimeStamp1; syncTimeStamp2 = synResponse.TimeStamp2; syncEvents = ProcessSyncCommands(syncCommands); } var commandsSafe = commands .Catch<Command, ConnectionErrorException>(tx => Observable.Empty<Command>()); commandsSafe.OfType<MessageCommand>().Subscribe(cmd => HandleMessages(cmd, connection)); commandsSafe.OfType<RingCommand>().Subscribe(cmd => HandleRings(cmd, connection)); commandsSafe.OfType<BroadcastCommand>().Subscribe(cmd => HandleBroadcasts(cmd, connection)); commandsSafe.OfType<NotificationCommand>().Subscribe(cmd => HandleNotifications(cmd, connection)); commandsSafe.OfType<AddContactCommand>().Subscribe(cmd => HandleNewUsers(cmd, connection)); commandsSafe.OfType<OutCommand>().Subscribe(cmd => HandleOut(cmd, connection)); commandsSafe.OfType<ChallengeCommand>().Subscribe(cmd => HandleChallenges(cmd, connection)); commandsSafe.OfType<UserOnlineCommand>().Subscribe(cmd => HandleOnlineUsers(cmd, connection)); commandsSafe.OfType<InitialUserOnlineCommand>().Subscribe(cmd => HandleOnlineUsers(cmd, connection)); commandsSafe.OfType<UserOfflineCommand>().Subscribe(cmd => HandleOfflineUsers(cmd, connection)); connection.Error += connection_Error; IsLoggedIn = true; OnLoggedIn(); OnUserStatusChanged(new UserStatusEventArgs(LocalUser, initialStatus, UserStatus.Offline, true)); if (syncEvents != null) RaiseSyncEvents(syncEvents); } finally { @lock.WriterRelease(); } }
private static IEnumerable<MethodCommandTypeTuple> GetSelfHandlerMethods(Type type, Type[] commandTypes, MethodParameterInjector injector) { if (!commandTypes.Contains(type)) yield break; var methods = type.GetMethods().Where(m => m.GetCustomAttribute<CommandHandlerAttribute>() != null); var enumerator = methods.GetEnumerator(); try { if (!enumerator.MoveNext()) yield break; else { var method = enumerator.Current; if (method.GetParameters().Any(p => !injector.CanSupply(p.ParameterType))) throw new CommandHandlerMethodHasUnsupportedParameter(type, method); yield return new MethodCommandTypeTuple { Method = method, CommandType = type, HandlerType = type}; } if (enumerator.MoveNext()) throw new CommandsMayOnlyDeclareOneHandlerMethod(type); } finally { enumerator.Dispose(); } }
private static Dictionary<Type, object> GetMixinDictionary(object[] mixins, Type[] interfaceTypes) { Dictionary<Type, object> _mixins = new Dictionary<Type, object>(); foreach (var mixin in mixins) { if (mixin == null) throw new ArgumentNullException("mixin"); var mixinType = mixin.GetType(); foreach (var interfaceType in mixinType.GetInterfaces()) { if (interfaceTypes.Contains(interfaceType)) { throw new InvalidOperationException(String.Format(NLite.Reflection.Dynamic.Internal.Resources.InterfaceTypeWasAlreadyAdded, interfaceType)); } _mixins.Add(interfaceType, mixin); } } return _mixins; }
public void ControlTestersHaveFourConstructorsAndIndexer() { IList<Type> typesToSkip = new Type[]{typeof(MessageBoxTester),typeof(FormTester)}; Type[] types = typeof (ControlTester).Assembly.GetTypes(); foreach (Type type in types) { if (typeof(ControlTester).IsAssignableFrom(type)) { // Skip tests for generic classes (for now.) if (type.IsGenericType) continue; // Explicitly skip tests for these types. if (typesToSkip.Contains(type)) continue; ConstructorInfo[] constructors = type.GetConstructors(); // OpenFileDialogTester only has one construtor. if (type == typeof (OpenFileDialogTester)) { Assert.AreEqual(1, constructors.Length, string.Format("{0}has incorrect constructor count.", type.Name)); continue; } Assert.IsTrue(4 <= constructors.Length, string.Format("{0}has incorrect constructor count.", type.Name)); VerifyAllConstructors(type.Name, constructors); Assert.IsTrue(HasIntIndexer(type), string.Format("Type {0} does not have an int indexer.", type.Name)); } } }
public static void Start(bool smtpConfig, bool newsletter, bool pop3Config, bool emailReport, Type[] quickLinkFrom) { if (Navigator.Manager.NotDefined(MethodInfo.GetCurrentMethod())) { CultureInfoClient.Start(); Navigator.RegisterArea(typeof(MailingClient)); Navigator.AddSettings(new List<EntitySettings> { new EmbeddedEntitySettings<EmailAttachmentEntity>{ PartialViewName = e => ViewPrefix.FormatWith("EmailAttachment")}, new EntitySettings<EmailPackageEntity>{ PartialViewName = e => ViewPrefix.FormatWith("EmailPackage")}, new EntitySettings<EmailMessageEntity>{ PartialViewName = e => ViewPrefix.FormatWith("EmailMessage"), AvoidValidateRequest = true }, new EmbeddedEntitySettings<EmailAddressEntity>{ PartialViewName = e => ViewPrefix.FormatWith("EmailAddress")}, new EmbeddedEntitySettings<EmailRecipientEntity>{ PartialViewName = e => ViewPrefix.FormatWith("EmailRecipient")}, new EmbeddedEntitySettings<EmailConfigurationEntity> { PartialViewName = e => ViewPrefix.FormatWith("EmailConfiguration")}, new EntitySettings<SystemEmailEntity>{ }, new EntitySettings<EmailMasterTemplateEntity> { PartialViewName = e => ViewPrefix.FormatWith("EmailMasterTemplate"), AvoidValidateRequest = true }, new EmbeddedEntitySettings<EmailMasterTemplateMessageEntity> { PartialViewName = e => ViewPrefix.FormatWith("EmailMasterTemplateMessage"), MappingDefault = new EntityMapping<EmailMasterTemplateMessageEntity>(true) .SetProperty(emtm => emtm.MasterTemplate, ctx => { return (EmailMasterTemplateEntity)ctx.Parent.Parent.Parent.Parent.UntypedValue; }) }, new EntitySettings<EmailTemplateEntity> { PartialViewName = e => ViewPrefix.FormatWith("EmailTemplate"), AvoidValidateRequest = true }, new EmbeddedEntitySettings<EmailTemplateMessageEntity>() { PartialViewName = e => ViewPrefix.FormatWith("EmailTemplateMessage"), MappingDefault = new EntityMapping<EmailTemplateMessageEntity>(true) .SetProperty(etm => etm.Template, ctx => { return (EmailTemplateEntity)ctx.Parent.Parent.Parent.Parent.UntypedValue; }) }, new EmbeddedEntitySettings<EmailTemplateContactEntity>() { PartialViewName = e => ViewPrefix.FormatWith("EmailTemplateContact"), MappingDefault = new EntityMapping<EmailTemplateContactEntity>(true) .SetProperty(ec => ec.Token, ctx => { string tokenStr = UserAssetsHelper.GetTokenString(ctx); return ParseQueryToken(tokenStr, ctx.Parent.Parent.Parent.Inputs[TypeContextUtilities.Compose("Query", EntityBaseKeys.RuntimeInfo)]); }), }, new EmbeddedEntitySettings<EmailTemplateRecipientEntity>() { PartialViewName = e => ViewPrefix.FormatWith("EmailTemplateRecipient"), MappingDefault = new EntityMapping<EmailTemplateRecipientEntity>(true) .SetProperty(ec => ec.Token, ctx => { string tokenStr = UserAssetsHelper.GetTokenString(ctx); return ParseQueryToken(tokenStr, ctx.Parent.Parent.Parent.Parent.Inputs[TypeContextUtilities.Compose("Query", EntityBaseKeys.RuntimeInfo)]); }) }, }); OperationClient.AddSettings(new List<OperationSettings> { new EntityOperationSettings<EmailTemplateEntity>(EmailMessageOperation.CreateMailFromTemplate) { Group = EntityOperationGroup.None, Click = ctx => Module["createMailFromTemplate"](ctx.Options(), JsFunction.Event, new FindOptions(((EmailTemplateEntity)ctx.Entity).Query.ToQueryName()).ToJS(ctx.Prefix, "New"), ctx.Url.Action((MailingController mc)=>mc.CreateMailFromTemplateAndEntity())) } }); if (smtpConfig) { Navigator.AddSettings(new List<EntitySettings> { new EntitySettings<SmtpConfigurationEntity> { PartialViewName = e => ViewPrefix.FormatWith("SmtpConfiguration") }, new EmbeddedEntitySettings<SmtpNetworkDeliveryEntity> { PartialViewName = e => ViewPrefix.FormatWith("SmtpNetworkDelivery") }, new EmbeddedEntitySettings<ClientCertificationFileEntity> { PartialViewName = e => ViewPrefix.FormatWith("ClientCertificationFile")}, }); } if (newsletter) { Navigator.AddSettings(new List<EntitySettings> { new EntitySettings<NewsletterEntity> { PartialViewName = e => ViewPrefix.FormatWith("Newsletter"), AvoidValidateRequest = true}, new EntitySettings<NewsletterDeliveryEntity> { PartialViewName = e => ViewPrefix.FormatWith("NewsletterDelivery") }, }); OperationClient.AddSettings(new List<OperationSettings> { new EntityOperationSettings<NewsletterEntity>(NewsletterOperation.RemoveRecipients) { Click = ctx => Module["removeRecipients"](ctx.Options(), new FindOptions(typeof(NewsletterDeliveryEntity), "Newsletter", ctx.Entity).ToJS(ctx.Prefix, "New"), ctx.Url.Action((MailingController mc)=>mc.RemoveRecipientsExecute())) }, new EntityOperationSettings<NewsletterEntity>(NewsletterOperation.Send) { Group = EntityOperationGroup.None, } }); } if (emailReport) { Navigator.AddSettings(new List<EntitySettings> { new EntitySettings<SendEmailTaskEntity> { PartialViewName = e => ViewPrefix.FormatWith("SendEmailTask") } }); } if (pop3Config) { Navigator.AddSettings(new List<EntitySettings> { new EntitySettings<Pop3ConfigurationEntity> { PartialViewName = e => ViewPrefix.FormatWith("Pop3Configuration") }, new EntitySettings<Pop3ReceptionEntity> { PartialViewName = e => ViewPrefix.FormatWith("Pop3Reception") }, }); } if (quickLinkFrom != null) { LinksClient.RegisterEntityLinks<Entity>((lite,ctx) => { if (!quickLinkFrom.Contains(lite.EntityType)) return null; return new[] { new QuickLinkExplore(typeof(EmailMessageEntity), "Target", lite) }; }); } TasksGetWebMailBody += WebMailProcessor.ReplaceUntrusted; TasksGetWebMailBody += WebMailProcessor.CidToFilePath; TasksSetWebMailBody += WebMailProcessor.AssertNoUntrusted; TasksSetWebMailBody += WebMailProcessor.FilePathToCid; Navigator.EntitySettings<EmailMessageEntity>().MappingMain.AsEntityMapping() .RemoveProperty(a => a.Body) .SetProperty(a => a.Body, ctx => { if (!ctx.HasInput) return ctx.None(); var email = ((EmailMessageEntity)ctx.Parent.UntypedValue); return SetWebMailBody(ctx.Input, new WebMailOptions { Attachments = email.Attachments, UntrustedImage = null, Url = RouteHelper.New(), }); }); SpecialOmniboxProvider.Register(new SpecialOmniboxAction("AsyncEmailPanel", () => AsyncEmailSenderPermission.ViewAsyncEmailSenderPanel.IsAuthorized(), uh => uh.Action((AsyncEmailSenderController pc) => pc.View()))); } }
public void ValidateNoDanglingAttributes() { // This list represents attributes that have been cleared to ship without deriving // from ArgMetadata. This test is here to make sure that, by default, the attributes // in this project behave like most of the others. That is, most attributes should // derive from ArgMetadata. var whitelist = new Type[] { typeof(ArgReviverAttribute), }; var iArgMetadataSubInterfaces = typeof(Args).Assembly.GetTypes().Where(t => t.IsInterface && t.GetInterfaces().Contains(typeof(IArgMetadata))).ToList(); // In general, attributes in this project should derive from ArgMetadata var danglingAttrs = typeof(Args).Assembly.GetTypes().Where(t => t.IsSubclassOf(typeof(Attribute)) == true && t.GetInterfaces().Contains(typeof(IArgMetadata)) == false && whitelist.Contains(t) == false ).ToList(); // In general, attibutes should use more specific IArgMetadata interfaces var danglingAttrs2 = typeof(Args).Assembly.GetTypes().Where(t => t.GetInterfaces().Contains(typeof(Attribute)) == true && (from i in t.GetInterfaces() where iArgMetadataSubInterfaces.Contains(i) select i).Count() == 0 && whitelist.Contains(t) == false ).ToList(); Assert.AreEqual(0, danglingAttrs.Count); Assert.AreEqual(0, danglingAttrs2.Count); }
void WarnForMissingBindings() { var ignoredTypes = new Type[] { typeof(DependencyRootStandard), typeof(DisposablesHandler) }; var boundTypes = _disposables.Select(x => x.Disposable.GetType()).Distinct(); var unboundTypes = _container.AllConcreteTypes.Where(x => x.DerivesFrom<IDisposable>() && !boundTypes.Contains(x) && !ignoredTypes.Contains(x)); foreach (var objType in unboundTypes) { Log.Warn("Found unbound IDisposable with type '" + objType.Name() + "'"); } }
private static void VerifyDependencies() { var gameObjects = GameObject.FindObjectsOfType(typeof(GameObject)).Where(go => go.name != "[SaveIt]").ToArray(); var usableDependencyTypes = new System.Type[] { typeof(Mesh), typeof(Material), typeof(PhysicMaterial), typeof(Shader), typeof(Texture), typeof(Texture2D), typeof(AudioClip), typeof(ProceduralMaterial), typeof(AnimationClip), typeof(Font) }; var dependencies = EditorUtility.CollectDependencies(gameObjects) .Where(dependency1 => { if (dependency1 == null) { return(false); } var want = usableDependencyTypes.Contains(dependency1.GetType()); return(want); }) .Union(new Object[] { new PhysicMaterial() { name = "Default" } }) .Select(dependency2 => { var path = AssetDatabase.GetAssetPath(dependency2); if (string.IsNullOrEmpty(path)) { path = "$" + dependency2.name; } return(new ResourceEntry() { Name = dependency2.name, Resource = dependency2, TypeName = dependency2.GetType().FullName }); }); dependencies = dependencies.Union(GameObject.FindObjectsOfType(typeof(Saveable)) .Where(saveable => ((Saveable)saveable).Prefab != null) .Select(saveable => { var prefab = ((Saveable)saveable).Prefab; return(new ResourceEntry() { Name = prefab.name, Resource = prefab, TypeName = prefab.GetType().FullName }); })); var saveItGameObject = (GameObject)GameObject.Find("[SaveIt]"); if (saveItGameObject == null) { saveItGameObject = new GameObject("[SaveIt]"); } var saveItComponent = saveItGameObject.GetComponent <SaveItComponent>(); if (saveItComponent == null) { saveItComponent = saveItGameObject.AddComponent <SaveItComponent>(); } saveItComponent.ResourceEntries = dependencies.Distinct().ToArray(); }
private static IList<Type> GetTypes(Container container, Assembly assembly, Type[] typesToIgnore) { string assemblyName = assembly.GetName().Name; var existingRegistrationsServiceTypes = container.GetCurrentRegistrations().Select(instanceProducer => instanceProducer.ServiceType).ToList(); IList<Type> registrations = assembly.GetExportedTypes() .Where(type => !typesToIgnore.Contains(type)) .Where(type => !existingRegistrationsServiceTypes.Contains(type)) .Where(type => type.Namespace != null) .Where(type => type.Namespace.StartsWith(assemblyName, StringComparison.OrdinalIgnoreCase)) .Where(type => (type.Attributes & TypeAttributes.Abstract) != TypeAttributes.Abstract) .Where(type => type.GetInterfaces().Any()) .Where( type => type.GetInterfaces() .Any( inter => !typesToIgnore.Contains(inter) && inter.Namespace != null && inter.Namespace.StartsWith(assemblyName, StringComparison.OrdinalIgnoreCase))) .ToList(); // Ignore already registerd interfaces: for (int i = registrations.Count() - 1; i >= 0; i--) { foreach (var registrationInterface in registrations[i].GetInterfaces()) { if (existingRegistrationsServiceTypes.Contains(registrationInterface)) { registrations.RemoveAt(i); break; } } } return registrations; }
static Hashes() { All = (from hf in Assembly.GetAssembly(typeof(IHash)).GetTypes() where hf.IsClass where !hf.IsAbstract where hf != typeof(HMACNotBuildInAdapter) where hf != typeof(HashCryptoBuildIn) where hf != typeof(HMACBuildInAdapter) where hf != typeof(HashLib.Checksum.CRC32) where hf != typeof(HashLib.Checksum.CRC64) where hf.IsImplementingInterface(typeof(IHash)) where !hf.IsNested select hf).ToList().AsReadOnly(); All = (from hf in All orderby hf.Name select hf).ToList().AsReadOnly(); var x2 = new Type[] { typeof(HashLib.Crypto.BuildIn.SHA1Cng), typeof(HashLib.Crypto.BuildIn.SHA1Managed), typeof(HashLib.Crypto.BuildIn.SHA256Cng), typeof(HashLib.Crypto.BuildIn.SHA256Managed), typeof(HashLib.Crypto.BuildIn.SHA384Cng), typeof(HashLib.Crypto.BuildIn.SHA384Managed), typeof(HashLib.Crypto.BuildIn.SHA512Cng), typeof(HashLib.Crypto.BuildIn.SHA512Managed), typeof(HashLib.Crypto.MD5), typeof(HashLib.Crypto.RIPEMD160), typeof(HashLib.Crypto.SHA1), typeof(HashLib.Crypto.SHA256), typeof(HashLib.Crypto.SHA384), typeof(HashLib.Crypto.SHA512), }; AllUnique = (from hf in All where !(hf.IsDerivedFrom(typeof(HashLib.Hash32.DotNet))) where !x2.Contains(hf) where !hf.IsNested select hf).ToList().AsReadOnly(); Hash32 = (from hf in All where hf.IsImplementingInterface(typeof(IHash32)) select hf).ToList().AsReadOnly(); Hash64 = (from hf in All where hf.IsImplementingInterface(typeof(IHash64)) select hf).ToList().AsReadOnly(); Checksums = (from hf in All where hf.IsImplementingInterface(typeof(IChecksum)) select hf).ToList().AsReadOnly(); FastComputes = (from hf in All where hf.IsImplementingInterface(typeof(IFastHashCodes)) select hf).ToList().AsReadOnly(); NonBlock = (from hf in All where hf.IsImplementingInterface(typeof(INonBlockHash)) select hf).ToList().AsReadOnly(); CryptoAll = (from hf in All where hf.IsImplementingInterface(typeof(ICrypto)) select hf).ToList().AsReadOnly(); CryptoNotBuildIn = (from hf in CryptoAll where hf.IsImplementingInterface(typeof(ICryptoNotBuildIn)) select hf).ToList().AsReadOnly(); CryptoBuildIn = (from hf in CryptoAll where hf.IsImplementingInterface(typeof(ICryptoBuildIn)) select hf).ToList().AsReadOnly(); HMACCryptoBuildIn = (from hf in CryptoBuildIn where hf.IsImplementingInterface(typeof(IHasHMACBuildIn)) select hf).ToList().AsReadOnly(); }
/// <summary> /// Validates that the required ISteamAuthenticator object is attached to the client prior to initiating execution /// </summary> /// <param name="validAuthMethods">List of valid authenticators for API access.</param> /// <returns>Returns 'true' if the proper authenticator is attached. Throws <see cref="SteamAuthenticationException"/> otherwise.</returns> internal bool IsAuthorizedCall( Type[] validAuthMethods ) { if( Authenticator == null || !validAuthMethods.Contains( Authenticator.GetType() ) ) throw new SteamAuthenticationException( "API call has not been properly authenticated. Please ensure the proper ISteamAuthenticator object is added to the SteamClient (SteamClient.Authenticator)." ); return true; }
public void InterfaceValidatorAutoCheck() { var edmLib = typeof(IEdmElement).Assembly; Type interfaceValidatorType = edmLib.GetType("Microsoft.OData.Edm.Validation.Internal.InterfaceValidator"); var interfaceVisitorsField = interfaceValidatorType.GetField("InterfaceVisitors", BindingFlags.NonPublic | BindingFlags.Static); object interfaceVisitors = interfaceVisitorsField.GetValue(null); var containsKeyMethod = interfaceVisitors.GetType().GetMethod("ContainsKey"); Type[] skips = new Type[] { typeof(IEdmVocabularyAnnotatable), typeof(IEdmSchemaType), typeof(IEdmComplexType), typeof(IEdmLocatable), typeof(IEdmBinaryConstantExpression), typeof(IEdmGuidConstantExpression), typeof(IEdmDateTimeOffsetConstantExpression), typeof(IEdmDurationConstantExpression), typeof(IEdmBooleanConstantExpression), typeof(IEdmStringConstantExpression), typeof(IEdmNullExpression), typeof(IEdmIntegerConstantExpression), typeof(IEdmFloatingConstantExpression), typeof(IEdmDecimalConstantExpression), typeof(IEdmNullValue), typeof(IEdmPrimitiveValue), typeof(IEdmDateTimeOffsetValue), typeof(IEdmGuidValue), typeof(IEdmBooleanValue), typeof(IEdmDurationValue), typeof(IEdmDecimalValue), typeof(IEdmFloatingValue), typeof(IEdmIntegerValue), typeof(IEdmDirectValueAnnotationsManager), typeof(IEdmDirectValueAnnotationBinding), typeof(IEdmNavigationPropertyBinding), typeof(IEdmEntitySet), typeof(IEdmUnknownEntitySet), typeof(IEdmDateValue), typeof(IEdmDateConstantExpression), typeof(IEdmTimeOfDayValue), typeof(IEdmTimeOfDayConstantExpression), }; foreach (Type skip in skips) { if (skip != typeof(IEdmLocatable) && // location is optional skip != typeof(IEdmNavigationPropertyBinding) && // this interface is processed inline inside IEdmEntitySet visitor skip != typeof(IEdmDateTimeOffsetValue) && // the value properties in these interfaces are structs, so they can't be null. skip != typeof(IEdmDateValue) && skip != typeof(IEdmGuidValue) && skip != typeof(IEdmBooleanValue) && skip != typeof(IEdmDurationValue) && skip != typeof(IEdmDecimalValue) && skip != typeof(IEdmFloatingValue) && skip != typeof(IEdmIntegerValue) && skip != typeof(IEdmDirectValueAnnotationBinding) && skip != typeof(IEdmTimeOfDayValue) ) { Assert.AreEqual(0, skip.GetProperties().Length, "It is not safe to skip interfaces with properties."); } } StringBuilder missingVisitors = new StringBuilder(); foreach (Type type in edmLib.GetTypes()) { if (type.IsInterface && type.IsPublic && type.Namespace.StartsWith("Microsoft.OData.Edm", StringComparison.Ordinal) && type.Name.StartsWith("IEdm", StringComparison.Ordinal)) { if (!(bool)containsKeyMethod.Invoke(interfaceVisitors, new object[] { type }) && !skips.Contains(type)) { missingVisitors.AppendLine(type.FullName); } } } Assert.IsTrue(missingVisitors.Length == 0, "The following interfaces might need a visitor in InterfaceValidator class \r\n" + missingVisitors.ToString()); var isCriticalMethod = edmLib.GetType("Microsoft.OData.Edm.Validation.Internal.ValidationHelper").GetMethod("IsInterfaceCritical", BindingFlags.NonPublic | BindingFlags.Static); foreach (var errorCodeName in Enum.GetNames(typeof(EdmErrorCode))) { if (errorCodeName.StartsWith("InterfaceCritical", StringComparison.Ordinal)) { Assert.IsTrue((bool)isCriticalMethod.Invoke(null, new object[] { new EdmError(null, (EdmErrorCode)Enum.Parse(typeof(EdmErrorCode), errorCodeName), errorCodeName) }), "InterfaceValidator.IsCritial must return true for " + errorCodeName); } } }
private static bool IsExcludedType(Type type, Type[] excludeTypes) { return excludeTypes.Contains(type); }
private static bool isSimpleType(Type type) { Type[] simpleTypes = new Type[] { typeof(string), typeof(byte), typeof(byte?), typeof(short), typeof(short?), typeof(int), typeof(int?), typeof(long), typeof(long?), typeof(Guid), typeof(Guid?) }; return simpleTypes.Contains(type); }