Ejemplo n.º 1
0
        public static void Cozy()
        {
            Console.WriteLine("\n-----------------------------------------------");
            Console.WriteLine(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.FullName);
            Console.WriteLine("-----------------------------------------------");

            //匿名类在使用linq做数据处理的时候非常有用

            //例如有一个Model类型是和数据库某张表的结构完全一致,但在UI上面需要呈现的数据不需要那么多
            //或者需要两个字段拼接成一个绑定UI上面,匿名类的用处就体现出来了

            //创建一个List<Model>的数据源
            var dataSource = new Func<List<Model>>(() =>
            {
                return Enumerable.Range(0, 20).Select(x => new Model
                {
                    Id = x,
                    FirstName = string.Format("FirstName{0}", x),
                    LastName = string.Format("LastName{0}", x)
                }).ToList();
            })();

            //通过Select()返回一个List<AnonymousType>对象,打印出来
            dataSource.Select(x => new {Number = x.Id, Name = x.FirstName + x.LastName , 年龄 = x.Age}).ToList().ForEach(x =>            
                Console.WriteLine("编号:{0} \t姓名:{1}  \t年龄:{2}", x.Number, x.Name, x.年龄));
        }
		public string[] GenerateSql(IStructureSchema structureSchema, IndexesTableNames names, IndexesTableStatuses statuses)
		{
			if(statuses.AllExists)
				return new string[0];

			var structureTableName = structureSchema.GetStructureTableName();
			var sqlTemplateNameSuffix = GetSqlTemplateNameSuffix(structureSchema.IdAccessor.IdType);
			var generators = new Func<string>[]
			{
				() => !statuses.IntegersTableExists 
					? GenerateSqlFor("CreateIntegersIndexes", sqlTemplateNameSuffix, structureTableName, names.IntegersTableName) 
					: string.Empty,
				() => !statuses.FractalsTableExists 
					? GenerateSqlFor("CreateFractalsIndexes", sqlTemplateNameSuffix, structureTableName, names.FractalsTableName) 
					: string.Empty,
				() => !statuses.BooleansTableExists 
					? GenerateSqlFor("CreateBooleansIndexes", sqlTemplateNameSuffix, structureTableName, names.BooleansTableName) 
					: string.Empty,
				() => !statuses.DatesTableExists 
					? GenerateSqlFor("CreateDatesIndexes", sqlTemplateNameSuffix, structureTableName, names.DatesTableName) 
					: string.Empty,
				() => !statuses.GuidsTableExists 
					? GenerateSqlFor("CreateGuidsIndexes", sqlTemplateNameSuffix, structureTableName, names.GuidsTableName) 
					: string.Empty,
				() => !statuses.StringsTableExists 
					? GenerateSqlFor("CreateStringsIndexes", sqlTemplateNameSuffix, structureTableName, names.StringsTableName) 
					: string.Empty,
				() => !statuses.TextsTableExists 
					? GenerateSqlFor("CreateTextsIndexes", sqlTemplateNameSuffix, structureTableName, names.TextsTableName) 
					: string.Empty
			};

			return generators.Select(generator => generator()).Where(s => !string.IsNullOrWhiteSpace(s)).ToArray();
		}
Ejemplo n.º 3
0
        public override object CalculateResult()
        {
            var operations = new Func<Fraction, Fraction, Fraction>[]
            {
                (a, b) => a + b,
                (a, b) => a - b,
                (a, b) => a * b,
                (a, b) => a / b,
            };

            return new Range(1, 9, true)
                .GetCombinations(4)
                .Select(digits => digits
                    .GetPermutations()
                    .Select(p => new
                    {
                        a = p[0],
                        b = p[1],
                        c = p[2],
                        d = p[3],
                    })
                    .SelectMany(p => new Range(3)
                        .Aggregate(new[] { Enumerable.Empty<Func<Fraction, Fraction, Fraction>>() }.AsEnumerable(),
                            (a, i) =>
                                a.SelectMany(s => operations
                                    .Select(o => s.AppendItem(o))),
                            a => a
                                .Select(s => s
                                    .ToArray())
                                .ToArray())
                        .Select(o => new
                        {
                            x = o[0],
                            y = o[1],
                            z = o[2],
                        })
                        .SelectMany(o => new[]
                        {
                            o.x(o.y(o.z(p.a, p.b), p.c), p.d),
                            o.x(o.y(p.a, p.b), o.z(p.c, p.d)),
                            o.x(o.y(p.a, o.z(p.b, p.c)), p.d),
                            o.x(p.a, o.y(o.z(p.b, p.c), p.d)),
                            o.x(p.a, o.y(p.b, o.z(p.c, p.d)))
                        }))
                    .Let(r => new
                    {
                        Digits = digits,
                        Count = r
                            .Where(v => v > 0 && v.IsInteger)
                            .Distinct()
                            .OrderBy(v => v)
                            .ToMemorableEnumerable()
                            .TakeWhile(e => !e.HasPreviousValue || e.Value == e.PreviousValue + 1)
                            .Count()
                    }))
                .WithMax(x => x.Count)
                .Digits
                .StringJoin("");
        }
Ejemplo n.º 4
0
        public void Select_SourceIsAnArray_ExecutionIsDeferred()
        {
            bool funcCalled = false;

            Func <int>[] source = new Func <int>[] { () => { funcCalled = true; return(1); } };

            IEnumerable <int> query = source.Select(d => d());

            Assert.False(funcCalled);
        }
Ejemplo n.º 5
0
        /// <summary>
        /// Compare the hand between x and y and returns an integer that indicates whether
        /// the x is higher, tie or lower to y.
        /// </summary>
        /// <param name="x"></param>
        /// <param name="y"></param>
        /// <returns></returns>
        public int Evaluate(Hand x, Hand y)
        {
            var evaluators = new Func <Hand, Hand, int>[]
            {
                EvaluateRank,
                EvaluateNonSingle,
                EvaluateSingle
            };

            return(evaluators.Select(eval => eval(x, y)).FirstOrDefault(val => val != 0));
        }
Ejemplo n.º 6
0
        private static void FunctionCompositionUsingLinqLikeSyntaxRoutine()
        {
            Func <int, int, IEnumerable <int> > range = Enumerable.Range;

            var handler = range.Select(x => x * x * x)
                          .Select(x => x / 2)
                          .Where(x => x % 2 == 1)
                          .ForEach(Console.WriteLine);

            handler(1, 10);
        }
        private async Task <IEnumerable <List <long> > > GenerateValuesInMultipleThreads(int threadCount, int valueCount)
        {
            const int blockSize = 10;

            var serviceProvider = SqlServerTestHelpers.Instance.CreateServiceProvider();

            var sequence = ((IMutableModel) new Model()).AddSequence("Foo");

            sequence.IncrementBy = blockSize;
            var state = new SqlServerSequenceValueGeneratorState(sequence);

            var executor     = new FakeRawSqlCommandBuilder(blockSize);
            var sqlGenerator = new SqlServerUpdateSqlGenerator(
                new UpdateSqlGeneratorDependencies(
                    new SqlServerSqlGenerationHelper(
                        new RelationalSqlGenerationHelperDependencies()),
                    new SqlServerTypeMappingSource(
                        TestServiceFactory.Instance.Create <TypeMappingSourceDependencies>(),
                        TestServiceFactory.Instance.Create <RelationalTypeMappingSourceDependencies>())));

            var logger = new FakeDiagnosticsLogger <DbLoggerCategory.Database.Command>();

            var tests           = new Func <Task> [threadCount];
            var generatedValues = new List <long> [threadCount];

            for (var i = 0; i < tests.Length; i++)
            {
                var testNumber = i;
                generatedValues[testNumber] = new List <long>();
                tests[testNumber]           = async() =>
                {
                    for (var j = 0; j < valueCount; j++)
                    {
                        var connection = CreateConnection(serviceProvider);
                        var generator  = new SqlServerSequenceHiLoValueGenerator <long>(executor, sqlGenerator, state, connection, logger);

                        var value = j % 2 == 0
                            ? await generator.NextAsync(null)
                            : generator.Next(null);

                        generatedValues[testNumber].Add(value);
                    }
                };
            }

            var tasks = tests.Select(Task.Run).ToArray();

            foreach (var t in tasks)
            {
                await t;
            }

            return(generatedValues);
        }
Ejemplo n.º 8
0
        public async Task Multiple_threads_can_use_the_same_generator_async()
        {
            var serviceProvider = TestHelpers.CreateServiceProvider();

            var property = _model.GetEntityType(typeof(AnEntity)).GetProperty("Long");

            var executor  = new FakeSqlStatementExecutor(10);
            var generator = new SqlServerSequenceValueGenerator(executor, "Foo", 10);

            const int threadCount = 50;
            const int valueCount  = 35;

            var tests           = new Func <Task> [threadCount];
            var generatedValues = new List <long> [threadCount];

            for (var i = 0; i < tests.Length; i++)
            {
                var testNumber = i;
                generatedValues[testNumber] = new List <long>();
                tests[testNumber]           = async() =>
                {
                    for (var j = 0; j < valueCount; j++)
                    {
                        var storeServices = CreateStoreServices(serviceProvider);

                        var generatedValue = await generator.NextAsync(property, storeServices);

                        generatedValues[testNumber].Add((long)generatedValue.Value);
                    }
                };
            }

            var tasks = tests.Select(Task.Run).ToArray();

            foreach (var t in tasks)
            {
                await t;
            }

            // Check that each value was generated once and only once
            var checks = new bool[threadCount * valueCount];

            foreach (var values in generatedValues)
            {
                Assert.Equal(valueCount, values.Count);
                foreach (var value in values)
                {
                    checks[value] = true;
                }
            }

            Assert.True(checks.All(c => c));
        }
        public async Task Multiple_threads_can_use_the_same_generator_async()
        {
            var configMock = new Mock <DbContextConfiguration>();

            configMock.Setup(m => m.Connection).Returns(new Mock <RelationalConnection>().Object);

            var entryMock = new Mock <StateEntry>();

            entryMock.Setup(m => m.Configuration).Returns(configMock.Object);

            var executor  = new FakeSqlStatementExecutor(10);
            var generator = new SqlServerSequenceValueGenerator(executor, "Foo", 10);

            const int threadCount = 50;
            const int valueCount  = 35;

            var tests           = new Func <Task> [threadCount];
            var generatedValues = new List <long> [threadCount];

            for (var i = 0; i < tests.Length; i++)
            {
                var testNumber = i;
                generatedValues[testNumber] = new List <long>();
                tests[testNumber]           = async() =>
                {
                    for (var j = 0; j < valueCount; j++)
                    {
                        generatedValues[testNumber].Add((long)await generator.NextAsync(entryMock.Object, CreateProperty(typeof(long))));
                    }
                };
            }

            var tasks = tests.Select(Task.Run).ToArray();

            foreach (var t in tasks)
            {
                await t;
            }

            // Check that each value was generated once and only once
            var checks = new bool[threadCount * valueCount];

            foreach (var values in generatedValues)
            {
                Assert.Equal(valueCount, values.Count);
                foreach (var value in values)
                {
                    checks[value] = true;
                }
            }

            Assert.True(checks.All(c => c));
        }
Ejemplo n.º 10
0
        public static void NounsSearch()
        {
            var voc = Program.DefaultVocabulary;
            var mainWords = voc.GetAllInfos().Where(s => s.PartOfSpeach == "V").Select(s=> s.Stem);
            var searcher = new Symptoms(voc, mainWords, "S");

            var questionList = Program.DefaultQuestionList;

            var symptoms = new Func<List<InvertedIndexUnit>>(()=> searcher
                .GetSymptomsIndex(questionList.GetAllQuestions().Select(item => Tuple.Create(item.Id, item.WholeText)))
                .ToList()).DetectTime("nouns found");
            File.WriteAllLines("nouns_verbs.txt", symptoms.Select(s => s.ToStringCount()));
        }
Ejemplo n.º 11
0
        private static IEnumerable <double> PropertyMatchWeights(PropertyInfoEx source, PropertyInfoEx target)
        {
            var matchingFunctions = new Func <PropertyInfoEx, PropertyInfoEx, double>[]
            {
                (s, t) => s.PropertyInfo.Name.PercentMatchTo(t.PropertyInfo.Name), (s, t) => s.Path.PercentMatchTo(t.Path)

                // more functions here if needed...
            };

            return(matchingFunctions.Select(
                       f =>
                       AreMatchingSimpleTypes(source.PropertyInfo.PropertyType, target.PropertyInfo.PropertyType)
                        ? f(source, target)
                        : 0.0));
        }
Ejemplo n.º 12
0
        public FhirExtensionsBuilder(IStorageBuilder fhirStoreBuilder, Uri baseUri)
        {
            this.fhirStoreBuilder = fhirStoreBuilder;
            this.baseUri          = baseUri;
            var extensionBuilders = new Func <IFhirServiceExtension>[]
            {
                GetSearch,
                GetHistory,
                GetConformance,
                GetPaging,
                GetStorage
            };

            extensions = extensionBuilders.Select(builder => builder()).Where(ext => ext != null).ToList();
        }
Ejemplo n.º 13
0
        public static void show()
        {
            onPreSceneGUIDelegate        += OnPreSceneGUI;
            SceneView.onSceneGUIDelegate += OnSceneGUI;
            EditorApplication.update     += Update;

            SceneView.RepaintAll();

            _options = new Func <Widget>[] {
                none,
                listView,
                eventsPage,
            };
            _optionStrings = _options.Select(x => x.Method.Name).ToArray();
            _selected      = 0;
        }
Ejemplo n.º 14
0
        /// <summary>
        /// Bit minwise estimator requires this specific hash function.
        /// </summary>
        /// <returns></returns>
        private Func <int, IEnumerable <int> > GenerateHashes()
        {
            const int universeSize = int.MaxValue;
            var       bound        = (uint)universeSize;
            var       r            = new Random(11);
            var       hashFuncs    = new Func <int, int> [_hashCount];

            for (var i = 0; i < _hashCount; i++)
            {
                var a = unchecked ((uint)r.Next(universeSize));
                var b = unchecked ((uint)r.Next(universeSize));
                var c = unchecked ((uint)r.Next(universeSize));
                hashFuncs[i] = hash => QHash(hash, a, b, c, bound);
            }
            return(hash => hashFuncs.Select(f => f(hash)));
        }
Ejemplo n.º 15
0
        static void Main(string[] args)
        {
            var experiments = new Func <int>[] {
                filterImperative,
                generateMultiplesImperative,
                sumOfMultiples,
                filterFunctional,
                generateMultiplesFunctional,
            };

            foreach (var result in experiments
                     .Select(func => new { result = func(), time = benchmark(() => func(), 1000), name = func.Method.Name })
                     .OrderBy(tuple => tuple.time))
            {
                Console.WriteLine("{0,-30} {1} {2:00.0000}", result.name, result.result, result.time);
            }
        }
Ejemplo n.º 16
0
        private async Task <IEnumerable <List <long> > > GenerateValuesInMultipleThreads(int threadCount, int valueCount)
        {
            const int blockSize = 10;

            var serviceProvider = SqlServerTestHelpers.Instance.CreateServiceProvider();

            var sequence = Sequence.GetOrAddSequence(new Model(), RelationalFullAnnotationNames.Instance.SequencePrefix, "Foo");

            sequence.IncrementBy = blockSize;
            var state = new SqlServerSequenceValueGeneratorState(sequence);

            var executor     = new FakeRawSqlCommandBuilder(blockSize);
            var sqlGenerator = new SqlServerUpdateSqlGenerator(new SqlServerSqlGenerationHelper(), new SqlServerTypeMapper());

            var tests           = new Func <Task> [threadCount];
            var generatedValues = new List <long> [threadCount];

            for (var i = 0; i < tests.Length; i++)
            {
                var testNumber = i;
                generatedValues[testNumber] = new List <long>();
                tests[testNumber]           = async() =>
                {
                    for (var j = 0; j < valueCount; j++)
                    {
                        var connection = CreateConnection(serviceProvider);
                        var generator  = new SqlServerSequenceHiLoValueGenerator <long>(executor, sqlGenerator, state, connection);

                        var value = j % 2 == 0
                                ? await generator.NextAsync(null)
                                : generator.Next(null);

                        generatedValues[testNumber].Add(value);
                    }
                };
            }

            var tasks = tests.Select(Task.Run).ToArray();

            foreach (var t in tasks)
            {
                await t;
            }

            return(generatedValues);
        }
Ejemplo n.º 17
0
        private bool TryDetectFramework(string content, PathType pathType, ChutzpahTestSettingsFile chutzpahTestSettings, out IFrameworkDefinition definition)
        {
            var strategies = new Func <IFrameworkDefinition>[]
            {
                // Check chutzpah settings
                () => frameworkDefinitions.FirstOrDefault(x => x.FrameworkKey.Equals(chutzpahTestSettings.Framework, StringComparison.OrdinalIgnoreCase)),

                // Check if we see an explicit reference to a framework file (e.g. <reference path="qunit.js" />)
                () => frameworkDefinitions.FirstOrDefault(x => x.FileUsesFramework(content, false, pathType)),

                // Check using basic heuristic like looking for test( or module( for QUnit
                () => frameworkDefinitions.FirstOrDefault(x => x.FileUsesFramework(content, true, pathType))
            };

            definition = strategies.Select(x => x()).FirstOrDefault(x => x != null);
            return(definition != null);
        }
Ejemplo n.º 18
0
        private void SetResult(EvaluationContext context, FunctionFoundEventArgs <Derivatives <Func <double> > > args, IFunction <double, double> doubleFunction)
        {
            var argumentCount = args.ArgumentCount;

            var variableCount = 1;

            for (var i = 0; i < argumentCount; i++)
            {
                variableCount = Math.Max(variableCount, args[i].Count);
            }

            var result = new DoubleDerivatives(variableCount);

            var arguments = new Func <double> [argumentCount];

            for (var i = 0; i < argumentCount; i++)
            {
                var iLocal = i;
                arguments[i] = () => args[iLocal][0]();
            }

            result[0] = () =>
            {
                var argumentValues = arguments.Select(arg => arg()).ToArray();

                return(doubleFunction.Logic(string.Empty, argumentValues, context));
            };

            if (doubleFunction is IDerivativeFunction <double, double> derivativeFunction)
            {
                var derivatives = new Lazy <Derivatives <Func <double> > >(() => derivativeFunction.Derivative(string.Empty, args, context));

                for (var i = 1; i <= variableCount; i++)
                {
                    var derivativeIndex = i;

                    if (IsDerivativeDefined(args, derivativeIndex))
                    {
                        result[i] = () => GetDerivativeValue(args, derivativeIndex, argumentCount, derivatives);
                    }
                }
            }

            args.Result = result;
        }
Ejemplo n.º 19
0
        public async Task Can_use_sequence_end_to_end_from_multiple_contexts_concurrently_async()
        {
            var serviceProvider = new ServiceCollection()
                                  .AddEntityFramework()
                                  .AddSqlServer()
                                  .ServiceCollection
                                  .BuildServiceProvider();

            using (var context = new BronieContext(serviceProvider, "ManyBronies"))
            {
                context.Database.EnsureDeleted();
                context.Database.EnsureCreated();

                // TODO: Integrate sequence generation into Migrations
                CreateDatabaseSequence(context, context.Database.Connection);
            }

            const int threadCount = 50;

            var tests = new Func <Task> [threadCount];

            for (var i = 0; i < threadCount; i++)
            {
                var closureProvider = serviceProvider;
                tests[i] = () => AddEntitiesAsync(closureProvider, "ManyBronies");
            }

            var tasks = tests.Select(Task.Run).ToArray();

            foreach (var t in tasks)
            {
                await t;
            }

            using (var context = new BronieContext(serviceProvider, "ManyBronies"))
            {
                var pegasuses = await context.Pegasuses.ToListAsync();

                for (var i = 0; i < 50; i++)
                {
                    Assert.Equal(threadCount, pegasuses.Count(p => p.Name == "Rainbow Dash " + i));
                    Assert.Equal(threadCount, pegasuses.Count(p => p.Name == "Fluttershy " + i));
                }
            }
        }
Ejemplo n.º 20
0
    public static object FindTheNotFittingElement(object[] series)
    {
        var rules = new Func <object[], object>[]
        {
            s => s.GroupBy(o => o.GetType()).FirstOrDefault(g => g.Count() == 1)?.Single(), // dif type

            s => s.GroupBy(o => o).Is(c => c.Count() == 2)?.FirstOrDefault(g => g.Count() == 1)?.Single(),

            s => s.Are(i => i is int)?.Cast <int>().GroupBy(i => i % 2).FirstOrDefault(e => e.Count() == 1)?.Single(), // odd or even

            s => s.Are(i => i is int)?.Cast <int>().GroupBy(i => i < 0).FirstOrDefault(e => e.Count() == 1)?.Single(), // < 0 || > 0

            s => s.Are(c => c is char)?.Cast <char>().GroupBy(char.IsLetter).FirstOrDefault(e => e.Count() == 1)?.Single(),

            s => s.Are(c => c is char)?.Cast <char>().GroupBy(char.IsLower).FirstOrDefault(e => e.Count() == 1)?.Single()
        };

        return(rules.Select(rule => rule(series)).First(rule => rule != null));
    }
Ejemplo n.º 21
0
        public static IEnumerable <SourceTransformation> UnrollNested(IEnumerable <SourceTransformation> transformations)
        {
            IEnumerable <SourceTransformation> sortedTransformations = transformations.OrderBy(n => n.Context.Context);
            int maxEnding = transformations.Max(n => n.Context.End);

            Func <string, string>[] numeratedTransformations = new Func <string, string> [maxEnding];

            //this is ineffecient as the same transformation for the length of two will divide into two different transformations
            foreach (SourceTransformation transformation in sortedTransformations)
            {
                for (int i = transformation.Context.Start; i < transformation.Context.End; i++)
                {
                    numeratedTransformations[i] = transformation.Apply;
                }
            }

            IEnumerable <SourceTransformation> perCharTransformation = numeratedTransformations.Select((n, index) => new SourceTransformation(new SourceContext(index, 1), n)).Where(m => m.Transformation != null);

            return(perCharTransformation);
        }
Ejemplo n.º 22
0
        private static string FindCMake()
        {
            var methods = new Func <string>[]
            {
                () => PathUtils.Which("cmake"),
                () => RuntimeInformation.IsOSPlatform(OSPlatform.Windows) ? PathUtils.GuessPath(new string[] {
                    "%ProgramW6432%\\CMake\\bin\\cmake.exe",
                    "%ProgramFiles%\\CMake\\bin\\cmake.exe",
                    "%ProgramFiles(x86)%\\CMake\\bin\\cmake.exe"
                }) : null,
                () => PathUtils.GuessPath(VsInstances.GetAll().Select(x => Path.Combine(x.InstallationPath, "Common7", "IDE", "CommonExtensions", "Microsoft", "CMake", "CMake", "bin", "cmake.exe")))
            };
            var result = methods.Select(x =>
            {
                try
                {
                    return(x());
                }
#pragma warning disable CA1031 // Do not catch general exception types
                catch (Exception)
                {
                    return(null);
                }
#pragma warning restore CA1031 // Do not catch general exception types
            }).FirstOrDefault(x => x != null);

            if (result != null)
            {
                try
                {
                    result = Path.GetFullPath(result);
                }
#pragma warning disable CA1031 // Do not catch general exception types
                catch (Exception)
                {
                    result = null;
                }
#pragma warning restore CA1031 // Do not catch general exception types
            }
            return(result);
        }
    public async Task <JsonResult> ValidateName(string name)
    {
        //the external validator
        var externalValidators = new Func <string, Task <bool> >[]
        {
            ExternalValidator1,
            ExternalValidator2,
            ExternalValidator3
        };
        //execute each asynchronously and wait for all to finish
        var externalValidatorTasks = externalValidators.Select(i => i(name)).ToArray();
        await Task.WhenAll(externalValidatorTasks);

        //return "invalid!" if any validation failed
        if (externalValidatorTasks.Any(i => !i.Result))
        {
            return(Json("invalid!", JsonRequestBehavior.AllowGet));
        }
        //name is valid
        return(Json(true, JsonRequestBehavior.AllowGet));
    }
Ejemplo n.º 24
0
        public async Task Can_use_sequence_end_to_end_from_multiple_contexts_concurrently_async()
        {
            var serviceProvider = new ServiceCollection()
                                  .AddEntityFrameworkNpgsql()
                                  .BuildServiceProvider();

            using (var context = new BronieContext(serviceProvider, TestStore.Name))
            {
                context.Database.EnsureCreatedResiliently();
            }

            const int threadCount = 50;

            var tests = new Func <Task> [threadCount];

            for (var i = 0; i < threadCount; i++)
            {
                var closureProvider = serviceProvider;
                tests[i] = () => AddEntitiesAsync(closureProvider, TestStore.Name);
            }

            var tasks = tests.Select(Task.Run).ToArray();

            foreach (var t in tasks)
            {
                await t;
            }

            using (var context = new BronieContext(serviceProvider, TestStore.Name))
            {
                var pegasuses = await context.Pegasuses.ToListAsync();

                for (var i = 0; i < 10; i++)
                {
                    Assert.Equal(threadCount, pegasuses.Count(p => p.Name == "Rainbow Dash " + i));
                    Assert.Equal(threadCount, pegasuses.Count(p => p.Name == "Fluttershy " + i));
                }
            }
        }
Ejemplo n.º 25
0
        public async Task Can_use_sequence_end_to_end_from_multiple_contexts_concurrently_async()
        {
            var serviceProvider = new ServiceCollection()
                                  .AddEntityFramework()
                                  .AddInMemoryStore()
                                  .UseLoggerFactory <LoggerFactory>()
                                  .ServiceCollection
                                  .BuildServiceProvider();

            const int threadCount = 50;

            var tests = new Func <Task> [threadCount];

            for (var i = 0; i < threadCount; i++)
            {
                var closureProvider = serviceProvider;
                tests[i] = () => AddEntitiesAsync(closureProvider);
            }

            var tasks = tests.Select(Task.Run).ToArray();

            foreach (var t in tasks)
            {
                await t;
            }

            using (var context = new BronieContext(serviceProvider))
            {
                var pegasuses = await context.Pegasuses.ToListAsync();

                for (var i = 0; i < 50; i++)
                {
                    Assert.True(pegasuses.All(p => p.Id > 0));
                    Assert.Equal(threadCount, pegasuses.Count(p => p.Name == "Rainbow Dash " + i));
                    Assert.Equal(threadCount, pegasuses.Count(p => p.Name == "Fluttershy " + i));
                }
            }
        }
Ejemplo n.º 26
0
        /// <summary>
        /// Look for Visual Studio
        /// </summary>
        /// <param name="runningInVisualStudio">True if running in Visual Studio</param>
        /// <returns>Path to Visual Studio install root.</returns>
        private static string GetVisualStudioPath(out bool runningInVisualStudio)
        {
            var processNameCommandLine    = s_getProcessFromCommandLine();
            var processNameCurrentProcess = s_getProcessFromRunningProcess();

            // Check to see if we're running inside of Visual Studio
            runningInVisualStudio = IsProcessInList(processNameCommandLine, s_visualStudioProcess) ||
                                    IsProcessInList(processNameCurrentProcess, s_visualStudioProcess);

            // Define the order in which we will look for Visual Studio. Stop when the first instance
            // is found.
            var possibleLocations = new Func <string>[]
            {
                () => TryGetVsFromProcess(processNameCommandLine),
                () => TryGetVsFromProcess(processNameCurrentProcess),
                () => TryGetVsFromEnvironment(),
                () => TryGetVsFromInstalled(),
                () => TryGetVsFromMSBuildLocation(processNameCommandLine),
                () => TryGetVsFromMSBuildLocation(processNameCurrentProcess)
            };

            return(possibleLocations.Select(location => location()).FirstOrDefault(path => !string.IsNullOrEmpty(path)));
        }
Ejemplo n.º 27
0
    public bool Verify()
    {
        print(RelativePath);

        var verifiers = new Func <bool>[]
        {
            PathExists,
            CheckConfigJSON
        };

        var texts   = transform.Find("ConfigInfo");
        var results = verifiers.Select((x, i) =>
        {
            var val     = x.Invoke();
            var t       = texts.transform.GetChild(i).GetChild(0).GetComponent <Text>();
            t.text      = val.ToString().ToUpper();
            t.color     = val ? Color.green : Color.red;
            t.fontStyle = FontStyle.Bold;
            return(val);
        });

        return(results.All(x => x));
    }
Ejemplo n.º 28
0
        /// <summary>
        /// Class constructor.
        /// </summary>
        static JsonReaderUtils()
        {
            var readSizes = new int[][]
            {
                new int[] { Int32.MaxValue },
                new int[] { 1 },
                new int[] { 1, 7, 101 }
            };

            Func<TextReader, AssertionHandler, JsonReader>[] creatorFuncs = new Func<TextReader, AssertionHandler, JsonReader>[]
            {
                (textReader, assert) => new JsonReader(textReader, assert, ODataFormat.Json, isIeee754Compatible: true),
                (textReader, assert) => new BufferingJsonReader(textReader, ODataConstants.DefaultMaxRecursionDepth, assert, ODataFormat.Json, isIeee754Compatible: true),
                (textReader, assert) => 
                {
                    BufferingJsonReader reader = new BufferingJsonReader(textReader, ODataConstants.DefaultMaxRecursionDepth, assert, ODataFormat.Json, isIeee754Compatible: true);
                    reader.StartBuffering();
                    return reader;
                },
            };

            allTestConfigurations = readSizes.SelectMany(rs =>
                creatorFuncs.Select(f => new JsonReaderTestConfiguration { ReadSizes = rs, JsonReaderCreatorFunc = f }));
        }
        public static bool IsConform(IEquationBuilder subject)
        {
            var callingTests = new Action<IEquationBuilder>[] {
                s => s.Value(0),
                s => s.Literal("x"),
                s => s.Add(),
                s => s.Divide(),
                s => s.Divide(b => { }),
                s => s.Parentheses(b => { })
            };

            Func<Action<IEquationBuilder>, bool> callingTestWrapper = test => {
                var passed = true;
                try
                {
                    test(subject);
                }
                catch (RuntimeBinderException)
                {
                    passed = false;
                }
                return passed;
            };

            var searchingTest = new Func<IEquationBuilder, MethodInfo>[]
                {
                    s => s.GetType().GetMethod("CreateItem", new Type[] { typeof(IIdentifier) }),
                    s => s.GetType().GetMethod("CreateItem", new Type[] { typeof(IIdentifier), typeof(IItem).MakeByRefType() })
                };

            Func<Func<IEquationBuilder, MethodInfo>, bool> searchingTestWrapper = test => test(subject) != null;

            return callingTests.Select(callingTestWrapper)
                .Concat(searchingTest.Select(searchingTestWrapper))
                .All(result => result == true);
        }
        protected override int GetProviderTypeFromNativeType(string nativeType)
        {
            var typeRules = new Func <string, int?>[]
            {
                name => name.IndexOf("INT", StringComparison.OrdinalIgnoreCase) >= 0
                    ? SQLITE_INTEGER
                    : (int?)null,
                name => name.IndexOf("CHAR", StringComparison.OrdinalIgnoreCase) >= 0 ||
                name.IndexOf("CLOB", StringComparison.OrdinalIgnoreCase) >= 0 ||
                name.IndexOf("TEXT", StringComparison.OrdinalIgnoreCase) >= 0
                    ? SQLITE_TEXT
                    : (int?)null,
                name => name.IndexOf("BLOB", StringComparison.OrdinalIgnoreCase) >= 0
                    ? SQLITE_BLOB
                    : (int?)null,
                name => name.IndexOf("REAL", StringComparison.OrdinalIgnoreCase) >= 0 ||
                name.IndexOf("FLOA", StringComparison.OrdinalIgnoreCase) >= 0 ||
                name.IndexOf("DOUB", StringComparison.OrdinalIgnoreCase) >= 0
                    ? SQLITE_FLOAT
                    : (int?)null
            };

            return(typeRules.Select(r => r(nativeType)).FirstOrDefault(r => r != null) ?? SQLITE_TEXT);
        }
        public string[] GenerateSql(IStructureSchema structureSchema, IndexesTableNames names, IndexesTableStatuses statuses)
        {
            if (statuses.AllExists)
            {
                return(new string[0]);
            }

            var structureTableName    = structureSchema.GetStructureTableName();
            var sqlTemplateNameSuffix = GetSqlTemplateNameSuffix(structureSchema.IdAccessor.IdType);
            var generators            = new Func <string>[]
            {
                () => !statuses.IntegersTableExists
                                        ? GenerateSqlFor("CreateIntegersIndexes", sqlTemplateNameSuffix, structureTableName, names.IntegersTableName)
                                        : string.Empty,
                () => !statuses.FractalsTableExists
                                        ? GenerateSqlFor("CreateFractalsIndexes", sqlTemplateNameSuffix, structureTableName, names.FractalsTableName)
                                        : string.Empty,
                () => !statuses.BooleansTableExists
                                        ? GenerateSqlFor("CreateBooleansIndexes", sqlTemplateNameSuffix, structureTableName, names.BooleansTableName)
                                        : string.Empty,
                () => !statuses.DatesTableExists
                                        ? GenerateSqlFor("CreateDatesIndexes", sqlTemplateNameSuffix, structureTableName, names.DatesTableName)
                                        : string.Empty,
                () => !statuses.GuidsTableExists
                                        ? GenerateSqlFor("CreateGuidsIndexes", sqlTemplateNameSuffix, structureTableName, names.GuidsTableName)
                                        : string.Empty,
                () => !statuses.StringsTableExists
                                        ? GenerateSqlFor("CreateStringsIndexes", sqlTemplateNameSuffix, structureTableName, names.StringsTableName)
                                        : string.Empty,
                () => !statuses.TextsTableExists
                                        ? GenerateSqlFor("CreateTextsIndexes", sqlTemplateNameSuffix, structureTableName, names.TextsTableName)
                                        : string.Empty
            };

            return(generators.Select(generator => generator()).Where(s => !string.IsNullOrWhiteSpace(s)).ToArray());
        }
        public async Task Send(NamespaceContext context, IPipe <NamespaceContext> next)
        {
            await context.CreateQueue(_settings.QueueDescription).ConfigureAwait(false);

            var subscriptions = new Func <Task> [0];

            if (_subscriptions.Length > 0)
            {
                subscriptions = await Task.WhenAll(_subscriptions.Select(s => CreateSubscription(context, context.NamespaceManager, s)))
                                .ConfigureAwait(false);
            }

            context.GetOrAddPayload(() => _settings);

            try
            {
                await next.Send(context).ConfigureAwait(false);
            }
            finally
            {
                if (_settings.RemoveSubscriptions)
                {
                    try
                    {
                        await Task.WhenAll(subscriptions.Select(x => x())).ConfigureAwait(false);
                    }
                    catch (Exception ex)
                    {
                        if (_log.IsWarnEnabled)
                        {
                            _log.Warn($"Failed to remove one or more subsriptions from the endpoint: {_settings.QueueDescription.Path}", ex);
                        }
                    }
                }
            }
        }
Ejemplo n.º 33
0
        public void SelectSelect_SourceIsAnArray_ExecutionIsDefered()
        {
            bool funcCalled = false;
            Func<int>[] source = new Func<int>[] { () => { funcCalled = true; return 1; } };

            IEnumerable<int> query = source.Select(d => d).Select(d => d());
            Assert.False(funcCalled);
        }
Ejemplo n.º 34
0
		public Gender DetectByRules(string name, Func<string, Gender>[] rules)
		{
			if (name.Length < 2)
				return Gender.Unknown;
			foreach (var gender in rules.Select(rule => rule.Invoke(name)).Where(gender => gender != Gender.Unknown))
			{
				return gender;
			}
			return Gender.Unknown;
		}
Ejemplo n.º 35
0
        /// <summary>
        /// Look for Visual Studio
        /// </summary>
        /// <param name="runningInVisualStudio">True if running in Visual Studio</param>
        /// <returns>Path to Visual Studio install root.</returns>
        private static string GetVisualStudioPath(out bool runningInVisualStudio)
        {
            var processNameCommandLine = s_getProcessFromCommandLine();
            var processNameCurrentProcess = s_getProcessFromRunningProcess();

            // Check to see if we're running inside of Visual Studio
            runningInVisualStudio = IsProcessInList(processNameCommandLine, s_visualStudioProcess) ||
                                    IsProcessInList(processNameCurrentProcess, s_visualStudioProcess);

            // Define the order in which we will look for Visual Studio. Stop when the first instance
            // is found.
            var possibleLocations = new Func<string>[]
            {
                () => TryGetVsFromProcess(processNameCommandLine),
                () => TryGetVsFromProcess(processNameCurrentProcess),
                () => TryGetVsFromEnvironment(),
                () => TryGetVsFromInstalled(),
                () => TryGetVsFromMSBuildLocation(processNameCommandLine),
                () => TryGetVsFromMSBuildLocation(processNameCurrentProcess)
            };

            return possibleLocations.Select(location => location()).FirstOrDefault(path => !string.IsNullOrEmpty(path));
        }
Ejemplo n.º 36
0
 /// <summary>
 /// 引数に指定された基底と重みの線形結合を取る。
 /// </summary>
 public static Func<double, double> LinearCombination(Func<double, double>[] basis, double[] weights)
 {
     Debug.Assert(basis.Length == weights.Length, "There are not enough basis or weights for linear combination!");
     return x => basis.Select((b, i) => weights[i] * b(x)).Sum();
 }
Ejemplo n.º 37
0
    public void Apply(ConventionContext context)
    {
        const string prefix = "Handle";

        if (context.ModelType == null)
        {
            // This would happen if the convention were applied to CommandLineApplication.
            // Conventions are applied by all created subcommands, so we need this check.
            return;
        }

        // Use reflection to find "Handle" methods.
        var handleMethods = context.ModelType
                            .GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)
                            .Where(m => m.Name.StartsWith(prefix, StringComparison.Ordinal));

        foreach (var method in handleMethods)
        {
            var subcommandName = method.Name.Substring(prefix.Length).ToLowerInvariant();
            // Create a subcommand for each.
            context.Application.Command(subcommandName, cmd =>
            {
                // Translate the method parameters into arguments and options
                var parameters = method.GetParameters();

                // define a matching array of functions that will produce the values to pass into the method
                var paramValueFactories = new Func <object> [parameters.Length];

                for (var i = 0; i < parameters.Length; i++)
                {
                    var param = parameters[i];

                    // treat method parameters with default values as options
                    if (param.HasDefaultValue)
                    {
                        // if command type == bool, make it a switch. Otherwise, accept a single value.
                        var type = param.ParameterType == typeof(bool)
                            ? CommandOptionType.NoValue
                            : CommandOptionType.SingleValue;

                        var template           = "--" + param.Name.ToLowerInvariant();
                        var opt                = cmd.Option(template, "", type);
                        paramValueFactories[i] = () =>
                        {
                            if (param.ParameterType == typeof(bool))
                            {
                                return(opt.HasValue());
                            }
                            if (!opt.HasValue())
                            {
                                return(param.DefaultValue);
                            }
                            return(opt.Value());
                        };
                    }
                    else
                    {
                        // otherwise it is a required argument.
                        var arg = cmd.Argument(param.Name, "").IsRequired();
                        paramValueFactories[i] = () => arg.Value;
                    }
                }

                // when this subcommand is selected, invoke the method on the model instance
                cmd.OnExecuteAsync(async cancellationToken =>
                {
                    // get an instance of the model type from CommandLineApplication<TModel>
                    var modelInstance = context.ModelAccessor.GetModel();
                    var methodArgs    = paramValueFactories.Select(f => f.Invoke()).ToArray();
                    var value         = method.Invoke(modelInstance, methodArgs);
                    if (value is int retVal)
                    {
                        return(retVal);
                    }
                    if (value is Task <int> retTask)
                    {
                        return(await retTask);
                    }
                    if (value is Task retWait)
                    {
                        await retWait;
                    }
                    return(0);
                });
            });
        }
    }
Ejemplo n.º 38
0
        static void TestFullAi()
        {
            var aiToTest = new Func <PlayerDecisionMaker>[]
            {
                //() => new PlayerDecisionMaker(new GreedyCardValueUtilityMoveMaker(-1), PlacementMaker.TightDoublerInstance),
                //() => new PlayerDecisionMaker(new GreedyCardValueUtilityMoveMaker(0), PlacementMaker.TightDoublerInstance),
                //() => new PlayerDecisionMaker(new GreedyCardValueUtilityMoveMaker(1), PlacementMaker.TightDoublerInstance),
                //() => new PlayerDecisionMaker(new GreedyCardValueUtilityMoveMaker(2), PlacementMaker.TightDoublerInstance),
                //
                //() => new PlayerDecisionMaker(new GreedyCardValueUtilityMoveMaker(-1), PlacementMaker.ExhaustiveMostFuturePlacementsInstance1_6),
                //() => new PlayerDecisionMaker(new GreedyCardValueUtilityMoveMaker(0), PlacementMaker.ExhaustiveMostFuturePlacementsInstance1_6),
                //() => new PlayerDecisionMaker(new GreedyCardValueUtilityMoveMaker(1), PlacementMaker.ExhaustiveMostFuturePlacementsInstance1_6),
                //() => new PlayerDecisionMaker(new GreedyCardValueUtilityMoveMaker(2), PlacementMaker.ExhaustiveMostFuturePlacementsInstance1_6),

                //() => new PlayerDecisionMaker(new QuickRandomSearchMoveMaker(6, 1000), PlacementMaker.ExhaustiveMostFuturePlacementsInstance1_6),
                //() => new PlayerDecisionMaker(new QuickRandomSearchMoveMaker(10, 2000), PlacementMaker.ExhaustiveMostFuturePlacementsInstance1_6),
                //() => new PlayerDecisionMaker(new QuickRandomSearchMoveMaker(20, 5000), PlacementMaker.ExhaustiveMostFuturePlacementsInstance1_6),
                //() => new PlayerDecisionMaker(new QuickRandomSearchMoveMaker(30, 10000), PlacementMaker.ExhaustiveMostFuturePlacementsInstance1_6),

                //() => new PlayerDecisionMaker(new MoveOnlyMonteCarloTreeSearchMoveMaker(1000, TuneableUtilityMoveMaker.Tuning1), PlacementMaker.ExhaustiveMostFuturePlacementsInstance1_6),

                () => new PlayerDecisionMaker(new MoveOnlyMonteCarloTreeSearchMoveMaker(10000, TuneableUtilityMoveMaker.Tuning1), PlacementMaker.ExhaustiveMostFuturePlacementsInstance1_6),
                () => new PlayerDecisionMaker(new MoveOnlyMonteCarloTreeSearchMoveMaker(10000, TuneableUtilityMoveMaker.Tuning1), new PlacementMaker(new BestEvaluatorStrategy(TuneablePattern2x2BoardEvaluator.Tuning1))),

                () =>
                {
                    var p = new PreplacerStrategy(new EvaluatorTreeSearchPreplacer(TuneablePattern2x2BoardEvaluator.Tuning1, 4, 4, true));
                    var m = new MoveOnlyMonteCarloTreeSearchWithPreplacerMoveMaker(10000, TuneableUtilityMoveMaker.Tuning1, p);
                    return(new PlayerDecisionMaker(m, new PlacementMaker(p)));
                },

                () => new PlayerDecisionMaker(new AlphaBetaMoveMaker(15, TuneableByBoardPositionUtilityCalculator.Tuning1), PlacementMaker.ExhaustiveMostFuturePlacementsInstance1_6),
                () => new PlayerDecisionMaker(new AlphaBetaMoveMaker(15, TuneableByBoardPositionUtilityCalculator.Tuning1), new PlacementMaker(new BestEvaluatorStrategy(TuneablePattern2x2BoardEvaluator.Tuning1))),
                //
                //() =>
                //{
                //	var p = new PreplacerStrategy(new EvaluatorTreeSearchPreplacer(new Pattern2x2BoardEvaluator(), 4, 4, true));
                //	var m = new MoveOnlyMinimaxWithAlphaBetaPruningWithPreplacerMoveMaker(13, TuneableByBoardPositionUtilityCalculator.Tuning1, p);
                //	return new PlayerDecisionMaker(m, new PlacementMaker(p));
                //},

                () =>
                {
                    var p = new PreplacerStrategy(new EvaluatorTreeSearchPreplacer(TuneablePattern2x2BoardEvaluator.Tuning1, 4, 4, true));
                    var m = new MoveOnlyAlphaBetaWithPreplacerMoveMaker(15, TuneableByBoardPositionUtilityCalculator.Tuning1, p);
                    return(new PlayerDecisionMaker(m, new PlacementMaker(p)));
                },
            };

            const int  TotalRuns            = 500;
            const bool enableConsoleLogging = false;

            //TODO: Play each AI against each other AI 100 times and print a table of results

            var totalWins      = new int[aiToTest.Length, aiToTest.Length];
            var totalTimeTaken = new long[aiToTest.Length];

            Console.WriteLine($"Running {aiToTest.Length * (aiToTest.Length - 1) / 2} * {TotalRuns} Games");
            int gameNumber = 0;

            for (var a = 0; a < aiToTest.Length; a++)
            {
                for (var b = a; b < aiToTest.Length; b++)
                {
                    if (a == b)
                    {
                        continue;
                    }

                    long aiATime = 0;
                    long aiBTime = 0;
                    var  aiA     = aiToTest[a];
                    var  aiB     = aiToTest[b];
                    Console.WriteLine($"{++gameNumber} {aiA().Name} vs {aiB().Name}");

                    Parallel.For(0, TotalRuns, new ParallelOptions {
                        MaxDegreeOfParallelism = 6
                    }, (run) =>
                                 //for (var run = 0; run < TotalRuns; run++)
                    {
                        var state            = new SimulationState(SimulationHelpers.GetRandomPieces(run / 2), 0);
                        ConsoleLogger logger = null;
                        if (enableConsoleLogging)
                        {
                            state.Logger = logger = new ConsoleLogger(state);
                        }
                        //state.Fidelity = SimulationFidelity.NoPiecePlacing;
                        //Let each Ai have half of the goes first and half second
                        var runner = new SimulationRunner(state, run % 2 == 0 ? aiA() : aiB(), run % 2 == 1 ? aiA() : aiB());

                        while (!state.GameHasEnded)
                        {
                            runner.PerformNextStep();
                            if (logger != null)
                            {
                                logger.PrintBoards(true);
                            }
                        }

                        var aWin = run % 2 == state.WinningPlayer;

                        lock (totalWins)
                        {
                            if (aWin)
                            {
                                totalWins[a, b]++;
                            }
                            else
                            {
                                totalWins[b, a]++;
                            }
                        }

                        Interlocked.Add(ref aiATime, runner.Stopwatches[run % 2].ElapsedMilliseconds);
                        Interlocked.Add(ref aiBTime, runner.Stopwatches[(run + 1) % 2].ElapsedMilliseconds);
                        //Console.WriteLine(aWin);
                    }
                                 );
                    Console.WriteLine(totalWins[a, b]);

                    totalTimeTaken[a] += aiATime;
                    totalTimeTaken[b] += aiBTime;
                }
            }

            //Calculate the total points for each
            var total = Enumerable.Range(0, aiToTest.Length).Select(ai => Enumerable.Range(0, aiToTest.Length).Sum(opponent => totalWins[ai, opponent])).ToArray();

            //Dump a CSV with the results
            var filename = "result_" + DateTimeOffset.Now.Ticks + ".csv";
            var res      = new List <string>();

            res.Add("," + string.Join(", ", aiToTest.Select(ai => ai().Name)) + ",Win%,Rank,Total Time");
            for (var a = 0; a < aiToTest.Length; a++)
            {
                var line = aiToTest[a]().Name;
                for (var b = 0; b < aiToTest.Length; b++)
                {
                    if (a == b)
                    {
                        line += ",";
                    }
                    else
                    {
                        line += "," + totalWins[a, b];
                    }
                }

                //Win%, rank, time
                line += "," + (total[a] / (float)(aiToTest.Length - 1) * 100 / TotalRuns).ToString("0.0");
                line += "," + (aiToTest.Length - total.Count(c => c < total[a]));
                line += "," + totalTimeTaken[a];

                res.Add(line);
            }

            Console.WriteLine("Saving results as " + filename);
            File.WriteAllLines(filename, res);

            Process.Start(filename);
        }
        public void AtomResourceCollectionMetadataTest()
        {
            var testCases = new[]
            {
                // No title specified - an empty one is used as it's required by the spec.
                new
                {
                    CustomizeMetadata = (Action<ODataEntitySetInfo>)(collection => {
                        AtomResourceCollectionMetadata metadata = collection.Atom();
                    }),
                    Xml = "<Collection><title xmlns='http://www.w3.org/2005/Atom'/></Collection>"
                },
                // Simple title (other titles are tested in AtomTextConstructMetadataTests)
                new
                {
                    CustomizeMetadata = (Action<ODataEntitySetInfo>)(collection => {
                        AtomResourceCollectionMetadata metadata = collection.Atom();
                        metadata.Title = new AtomTextConstruct { Text = "collection title" };
                    }),
                    Xml = "<Collection><title type='text' xmlns='http://www.w3.org/2005/Atom'>collection title</title></Collection>"
                },
                // With accept
                new
                {
                    CustomizeMetadata = (Action<ODataEntitySetInfo>)(collection => {
                        AtomResourceCollectionMetadata metadata = collection.Atom();
                        metadata.Title = "collection title";
                        metadata.Accept = "mime/type";
                    }),
                    Xml = "<Collection><title type='text' xmlns='http://www.w3.org/2005/Atom'>collection title</title><accept xmlns='http://www.w3.org/2007/app'>mime/type</accept></Collection>"
                },
                // With empty accept
                new
                {
                    CustomizeMetadata = (Action<ODataEntitySetInfo>)(collection => {
                        AtomResourceCollectionMetadata metadata = collection.Atom();
                        metadata.Title = "collection title";
                        metadata.Accept = string.Empty;
                    }),
                    Xml = "<Collection><title type='text' xmlns='http://www.w3.org/2005/Atom'>collection title</title><accept xmlns='http://www.w3.org/2007/app'></accept></Collection>"
                },
                // With categories
                new
                {
                    CustomizeMetadata = (Action<ODataEntitySetInfo>)(collection => {
                        AtomResourceCollectionMetadata metadata = collection.Atom();
                        metadata.Title = "collection title";
                        metadata.Categories = new AtomCategoriesMetadata();
                    }),
                    Xml = "<Collection><title type='text' xmlns='http://www.w3.org/2005/Atom'>collection title</title><categories xmlns='http://www.w3.org/2007/app' /></Collection>"
                },
                // With accept and categories
                new
                {
                    CustomizeMetadata = (Action<ODataEntitySetInfo>)(collection => {
                        AtomResourceCollectionMetadata metadata = collection.Atom();
                        metadata.Title = "collection title";
                        metadata.Accept = "mime/type";
                        metadata.Categories = new AtomCategoriesMetadata();
                    }),
                    Xml = "<Collection><title type='text' xmlns='http://www.w3.org/2005/Atom'>collection title</title><accept xmlns='http://www.w3.org/2007/app'>mime/type</accept><categories xmlns='http://www.w3.org/2007/app' /></Collection>"
                },
            };

            Func<ODataEntitySetInfo>[] collectionCreators = new Func<ODataEntitySetInfo>[]
            {
                () => new ODataEntitySetInfo { Url = new Uri("http://odata.org/url") },
                () => { var collection = new ODataEntitySetInfo { Url = new Uri("http://odata.org/url") }; collection.SetAnnotation(new AtomResourceCollectionMetadata()); return collection; }
            };
            var testDescriptors = testCases.SelectMany(testCase =>
                collectionCreators.Select(collectionCreator =>
                {
                    ODataEntitySetInfo collection = collectionCreator();
                    testCase.CustomizeMetadata(collection);
                    ODataServiceDocument serviceDocument = new ODataServiceDocument { EntitySets = new[] { collection } };
                    return new PayloadWriterTestDescriptor<ODataServiceDocument>(
                        this.Settings,
                        new[] { serviceDocument },
                        tc => new AtomWriterTestExpectedResults(this.Settings.ExpectedResultSettings)
                        {
                            Xml = testCase.Xml,
                            FragmentExtractor = result =>
                                new XElement("Collection",
                                    result
                                        .Element(TestAtomConstants.AtomPublishingXNamespace + TestAtomConstants.AtomPublishingWorkspaceElementName)
                                        .Element(TestAtomConstants.AtomPublishingXNamespace + TestAtomConstants.AtomPublishingCollectionElementName)
                                        .Elements())
                        });
                }));

            this.CombinatorialEngineProvider.RunCombinations(
                testDescriptors,
                this.WriterTestConfigurationProvider.AtomFormatConfigurations.Where(tc => !tc.IsRequest),
                (testDescriptor, testConfiguration) =>
                {
                    testConfiguration = testConfiguration.Clone();
                    testConfiguration.MessageWriterSettings.SetServiceDocumentUri(ServiceDocumentUri);

                    TestWriterUtils.WriteAndVerifyTopLevelContent(
                        testDescriptor,
                        testConfiguration,
                        (messageWriter) => messageWriter.WriteServiceDocument(testDescriptor.PayloadItems.Single()),
                        this.Assert,
                        baselineLogger: this.Logger);
                });
        }
Ejemplo n.º 40
0
        private bool TryDetectFramework(PathInfo path, ChutzpahTestSettingsFile chutzpahTestSettings, out IFrameworkDefinition definition)
        {
            // TODO: Deprecate the fallback approach
            Lazy<string> fileText = new Lazy<string>(() =>
            {
                string firstTestFileText;
                if (path.Type == PathType.Url)
                {
                    firstTestFileText = httpClient.GetContent(path.FullPath);
                }
                else
                {
                    firstTestFileText = fileSystem.GetText(path.FullPath);
                }

                return firstTestFileText;
            });


            var strategies = new Func<IFrameworkDefinition>[]
            {
                // Check chutzpah settings
                () => frameworkDefinitions.FirstOrDefault(x => x.FrameworkKey.Equals(chutzpahTestSettings.Framework, StringComparison.OrdinalIgnoreCase)),

                // Check if we see an explicit reference to a framework file (e.g. <reference path="qunit.js" />)
                () => frameworkDefinitions.FirstOrDefault(x => x.FileUsesFramework(fileText.Value, false, path.Type)),

                // Check using basic heuristic like looking for test( or module( for QUnit
                () => frameworkDefinitions.FirstOrDefault(x => x.FileUsesFramework(fileText.Value, true, path.Type))
            };

            definition = strategies.Select(x => x()).FirstOrDefault(x => x != null);
            return definition != null;
        }
Ejemplo n.º 41
0
        public void Apply(ConventionContext context)
        {
            if (context.ModelType == null)
            {
                return;
            }
            //BindingFlags.Public | BindingFlags.Instance
            var handleMethods = context.ModelType.GetMethods()
                                .Where(m => m.Name.StartsWith(Utilities.Mode_4, StringComparison.Ordinal));

            foreach (var method in handleMethods)
            {
                var methodAttribute = method.GetCustomAttribute(typeof(ClassCommandInfo)) as ClassCommandInfo;
                var subCommandName  = methodAttribute == null?method.Name.ToLower() : methodAttribute.CommandName;

                var subCommmandDescription = methodAttribute == null ? $"description is about {method.Name.ToLower()}" : methodAttribute.CommandDescription;


                context.Application.Command(subCommandName, cmd =>
                {
                    cmd.Description = subCommmandDescription;

                    var parameters = method.GetParameters();

                    var paramValueFactories = new Func <object> [parameters.Length];

                    for (var i = 0; i < parameters.Length; i++)
                    {
                        var param = parameters[i];

                        var paramDescription = methodAttribute.ArgsInfo != null ? methodAttribute.ArgsInfo.SingleOrDefault(arg => arg.name == param.Name.ToLower()).description : null;

                        if (param.HasDefaultValue)
                        {
                            var template = $"--{param.Name.ToLowerInvariant()} || -{param.Name.ToLowerInvariant()[0]}";

                            var opt = cmd.Option(template, paramDescription ?? "", CommandOptionType.SingleValue);

                            paramValueFactories[i] = () =>
                            {
                                if (!opt.HasValue())
                                {
                                    return(param.DefaultValue);
                                }
                                return(opt.Value());
                            };
                        }
                        else
                        {
                            var arg = cmd.Argument(param.Name, paramDescription ?? "").IsRequired();

                            paramValueFactories[i] = () => arg.Value;
                        }
                    }
                    cmd.OnExecuteAsync(async cancellationToken =>
                    {
                        var modelInstance = context.ModelAccessor.GetModel();
                        var methodArgs    = paramValueFactories.Select(f => f.Invoke()).ToArray();
                        //first add to record and next invoke
                        if (RecordQueries.GetRecordState())
                        {
                            RecordQueries.AddNewCommad((modelInstance, method, methodArgs));
                        }
                        var value = method.Invoke(modelInstance, methodArgs);
                        if (value is int retVal)
                        {
                            return(retVal);
                        }
                        if (value is Task <int> retTask)
                        {
                            return(await retTask);
                        }
                        if (value is Task retWait)
                        {
                            await retWait;
                        }
                        return(0);
                    });
                });
            }
        }
Ejemplo n.º 42
0
        public void CollectionExtensions_Delegation_Resolve()
        {
            var targetArr = new[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };

            var target = new Func<int>[10];

            for (int i = 0; i < 10; i++)
            {
                var idx = i;
                target[i] = () => targetArr[idx];
            }

            var result = target.Select(x => x).Resolve();


            for (int i = 0; i < 10; i++)
            {
                targetArr[i] *= 2;
            }

            result = target.Select(x => x).Resolve();

            foreach (var items in Enumerable.Range(0, 10).Zip(result, Tuple.Create))
                Assert.AreEqual(items.Item1 * 2, items.Item2);
        }
        // [ConditionalFact] Currently disabled due to GitHub issue #266
        public async Task Can_use_sequence_end_to_end_from_multiple_contexts_concurrently_async()
        {
            var serviceProvider = new ServiceCollection()
                .AddEntityFrameworkSqlServer()
                .BuildServiceProvider();

            using (var context = new BronieContext(serviceProvider, "ManyBronies"))
            {
                context.Database.EnsureDeleted();
                context.Database.EnsureCreated();
            }

            const int threadCount = 50;

            var tests = new Func<Task>[threadCount];
            for (var i = 0; i < threadCount; i++)
            {
                var closureProvider = serviceProvider;
                tests[i] = () => AddEntitiesAsync(closureProvider, "ManyBronies");
            }

            var tasks = tests.Select(Task.Run).ToArray();

            foreach (var t in tasks)
            {
                await t;
            }

            using (var context = new BronieContext(serviceProvider, "ManyBronies"))
            {
                var pegasuses = await context.Pegasuses.ToListAsync();

                for (var i = 0; i < 50; i++)
                {
                    Assert.Equal(threadCount, pegasuses.Count(p => p.Name == "Rainbow Dash " + i));
                    Assert.Equal(threadCount, pegasuses.Count(p => p.Name == "Fluttershy " + i));
                }
            }
        }
Ejemplo n.º 44
0
 private static IEnumerable<string> CreateTokensIterator(TextReader self, TextReaderRocksOptions options, Func<char?, char, bool>[] categories)
 {
     try {
         var cats = categories.Select (
                 c => Lambda.F ((StringBuilder buf, char ch) =>
                     c (buf.Length == 0 ? ((char?) null) : (char?) buf [buf.Length-1], ch)));
         foreach (var t in Chars (self).Tokens (
                     new StringBuilder (),
                     (buf, c) => buf.Append (c),
                     buf => {
                         var r = buf.ToString ();
                         buf.Length = 0;
                         return Tuple.Create (r, buf);
                     },
                     cats.ToArray ()))
             yield return t;
     } finally {
         if ((options & TextReaderRocksOptions.CloseReader) != 0) {
             self.Close ();
             self.Dispose ();
         }
     }
 }
        public async Task Multiple_threads_can_use_the_same_generator_async()
        {
            var configMock = new Mock<DbContextConfiguration>();
            configMock.Setup(m => m.Connection).Returns(new Mock<RelationalConnection>().Object);

            var entryMock = new Mock<StateEntry>();
            entryMock.Setup(m => m.Configuration).Returns(configMock.Object);

            var executor = new FakeSqlStatementExecutor(10);
            var generator = new SqlServerSequenceValueGenerator(executor, "Foo", 10);

            const int threadCount = 50;
            const int valueCount = 35;

            var tests = new Func<Task>[threadCount];
            var generatedValues = new List<long>[threadCount];
            for (var i = 0; i < tests.Length; i++)
            {
                var testNumber = i;
                generatedValues[testNumber] = new List<long>();
                tests[testNumber] = async () =>
                    {
                        for (var j = 0; j < valueCount; j++)
                        {
                            generatedValues[testNumber].Add((long)await generator.NextAsync(entryMock.Object, CreateProperty(typeof(long))));
                        }
                    };
            }

            var tasks = tests.Select(Task.Run).ToArray();

            foreach (var t in tasks)
            {
                await t;
            }

            // Check that each value was generated once and only once
            var checks = new bool[threadCount * valueCount];
            foreach (var values in generatedValues)
            {
                Assert.Equal(valueCount, values.Count);
                foreach (var value in values)
                {
                    checks[value] = true;
                }
            }

            Assert.True(checks.All(c => c));
        }
        public async Task Multiple_threads_can_use_the_same_generator_async()
        {
            var incrementingValue   = 0L;
            var dbConfigurationMock = new Mock <DbContextConfiguration>();
            var redisDatabaseMock   = new Mock <RedisDatabase>(dbConfigurationMock.Object);

            redisDatabaseMock
            .Setup(db => db.GetNextGeneratedValueAsync(
                       It.IsAny <IProperty>(), It.IsAny <long>(), It.IsAny <string>(), It.IsAny <CancellationToken>()))
            .Returns <IProperty, long, string, CancellationToken>((p, l, s, c) =>
            {
                var originalValue  = incrementingValue;
                incrementingValue += l;
                return(Task.FromResult(originalValue));
            });

            var generator = new RedisSequenceValueGenerator(redisDatabaseMock.Object, "TestSequenceName", 1);

            var property = _model.GetEntityType(typeof(AnEntity)).GetProperty("Long");

            const int threadCount = 50;
            const int valueCount  = 35;

            var tests           = new Func <Task> [threadCount];
            var generatedValues = new List <long> [threadCount];

            for (var i = 0; i < tests.Length; i++)
            {
                var testNumber = i;
                generatedValues[testNumber] = new List <long>();
                tests[testNumber]           = async() =>
                {
                    var stateEntry = TestHelpers.CreateStateEntry <AnEntity>(_model);

                    for (var j = 0; j < valueCount; j++)
                    {
                        await generator.NextAsync(stateEntry, property);

                        generatedValues[testNumber].Add((long)stateEntry[property]);
                    }
                };
            }

            var tasks = tests.Select(Task.Run).ToArray();

            foreach (var t in tasks)
            {
                await t;
            }

            // Check that each value was generated once and only once
            var checks = new bool[threadCount * valueCount];

            foreach (var values in generatedValues)
            {
                Assert.Equal(valueCount, values.Count);
                foreach (var value in values)
                {
                    checks[value] = true;
                }
            }

            Assert.True(checks.All(c => c));
        }
Ejemplo n.º 47
0
        public void NavigationLinkMetadataWriterTest()
        {
            string testRelation = "http://docs.oasis-open.org/odata/ns/related/SampleLinkName";
            string testIncorrectRelation = "http://odata.org/relation/1";
            string testTitle = "SampleLinkName";
            string testIncorrectTitle = "Test link 1";
            string testHref = "http://odata.org/link";
            string testIncorrectHref = "http://odata.org/links/1";
            string testHrefLang = "de-AT";
            int? testLength = 999;
            string testMediaType = "application/atom+xml;type=feed";
            string testIncorrectMediaType = "image/png";

            var testCases = new[]
                {
                    new 
                    {
                        CustomizeLink = new Action<ODataNavigationLink>(
                            (link) =>
                                {
                                    AtomLinkMetadata metadata = link.Atom();
                                    metadata.Relation = testRelation;
                                    metadata.Title = testTitle;
                                    metadata.Href = new Uri(testHref);
                                    metadata.HrefLang = testHrefLang;
                                    metadata.Length = testLength;
                                    metadata.MediaType = testMediaType;
                                    link.Url = metadata.Href;
                                }),
                        Xml = @"<link rel=""" + testRelation + @""" type = """ + testMediaType + @""" title=""" + testTitle + @""" href=""" + testHref + @""" hreflang=""" + testHrefLang + @""" length=""" + testLength.Value + @"""  xmlns=""" + TestAtomConstants.AtomNamespace + @""" />",
                        ExpectedException = (ExpectedException)null
                    },
                    new 
                    {
                        CustomizeLink = new Action<ODataNavigationLink>(
                            (link) =>
                                {
                                    AtomLinkMetadata metadata = link.Atom();
                                    metadata.Relation = testRelation;
                                    metadata.Title = testTitle;
                                    metadata.Href = new Uri(testIncorrectHref);
                                    metadata.HrefLang = testHrefLang;
                                    metadata.Length = testLength;
                                    metadata.MediaType = testMediaType;
                                }),
                        Xml = (string)null,
                        ExpectedException = ODataExpectedExceptions.ODataException("ODataAtomWriterMetadataUtils_LinkHrefsMustMatch", "http://odata.org/link", "http://odata.org/links/1"),
                    },
                    new 
                    {
                        CustomizeLink = new Action<ODataNavigationLink>(
                            (link) =>
                                {
                                    AtomLinkMetadata metadata = link.Atom();
                                    metadata.Relation = testIncorrectRelation;
                                    metadata.Title = testTitle;
                                    metadata.Href = new Uri(testHref);
                                    metadata.HrefLang = testHrefLang;
                                    metadata.Length = testLength;
                                    metadata.MediaType = testMediaType;
                                }),
                        Xml = (string)null,
                        ExpectedException = ODataExpectedExceptions.ODataException("ODataAtomWriterMetadataUtils_LinkRelationsMustMatch", "http://docs.oasis-open.org/odata/ns/related/SampleLinkName", "http://odata.org/relation/1"),
                    },
                    new 
                    {
                        CustomizeLink = new Action<ODataNavigationLink>(
                            (link) =>
                                {
                                    AtomLinkMetadata metadata = link.Atom();
                                    metadata.Relation = testRelation;
                                    metadata.Title = testTitle;
                                    metadata.Href = new Uri(testHref);
                                    metadata.HrefLang = testHrefLang;
                                    metadata.Length = testLength;
                                    metadata.MediaType = testIncorrectMediaType;
                                }),
                        Xml = (string)null,
                        ExpectedException = ODataExpectedExceptions.ODataException("ODataAtomWriterMetadataUtils_LinkMediaTypesMustMatch", "application/atom+xml;type=feed", "image/png"),
                    },
                    new 
                    {
                        CustomizeLink = new Action<ODataNavigationLink>(
                            (link) =>
                                {
                                    AtomLinkMetadata metadata = link.Atom();
                                    metadata.Relation = testRelation;
                                    metadata.Title = testIncorrectTitle;
                                    metadata.Href = new Uri(testHref);
                                    metadata.HrefLang = testHrefLang;
                                    metadata.Length = testLength;
                                    metadata.MediaType = testMediaType;
                                }),
                        Xml = (string)null,
                        ExpectedException = ODataExpectedExceptions.ODataException("ODataAtomWriterMetadataUtils_LinkTitlesMustMatch", "SampleLinkName", "Test link 1"),
                    },
                    new 
                    {
                        CustomizeLink = new Action<ODataNavigationLink>(
                            (link) =>
                                {
                                    AtomLinkMetadata metadata = link.Atom();
                                    metadata.Relation = testRelation;
                                    metadata.Title = null;
                                    metadata.Href = new Uri(testHref);
                                    metadata.HrefLang = null;
                                    metadata.Length = null;
                                    metadata.MediaType = null;
                                }),
                        Xml = @"<link rel=""" + testRelation + @""" type = """ + testMediaType + @""" title=""" + testTitle + @""" href=""" + testHref + @""" xmlns=""" + TestAtomConstants.AtomNamespace + @""" />",
                        ExpectedException = (ExpectedException)null
                    },
                };

            Func<XElement, XElement> fragmentExtractor = (e) => e;

            // Convert test cases to test descriptions
            Func<ODataNavigationLink>[] linkCreators = new Func<ODataNavigationLink>[]
            {
                () => ObjectModelUtils.CreateDefaultCollectionLink(),
                () => { var link = ObjectModelUtils.CreateDefaultCollectionLink(); link.SetAnnotation(new AtomLinkMetadata()); return link; }
            };
            var testDescriptors = testCases.SelectMany(testCase =>
                linkCreators.Select(linkCreator =>
                {
                    ODataNavigationLink link = linkCreator();
                    testCase.CustomizeLink(link);
                    return new PayloadWriterTestDescriptor<ODataItem>(this.Settings, link, testConfiguration =>
                        new AtomWriterTestExpectedResults(this.Settings.ExpectedResultSettings) { Xml = testCase.Xml, ExpectedException2 = testCase.ExpectedException, FragmentExtractor = fragmentExtractor });
                }));

            this.CombinatorialEngineProvider.RunCombinations(
                testDescriptors.PayloadCases(WriterPayloads.NavigationLinkPayloads),
                this.WriterTestConfigurationProvider.AtomFormatConfigurations,
                (testDescriptor, testConfiguration) =>
                {
                    testConfiguration = testConfiguration.Clone();
                    testConfiguration.MessageWriterSettings.SetServiceDocumentUri(ServiceDocumentUri);

                    TestWriterUtils.WriteAndVerifyODataPayload(testDescriptor.DeferredLinksToEntityReferenceLinksInRequest(testConfiguration), testConfiguration, this.Assert, this.Logger);
                });
        }
Ejemplo n.º 48
0
        public void EntryMetadataWriterTest()
        {
            const string testPublished = "2010-10-20T20:10:00Z";
            AtomTextConstruct testRights = new AtomTextConstruct { Text = "Copyright Data Fx team." };
            AtomTextConstruct testSummary = new AtomTextConstruct { Text = "Test summary." };
            AtomTextConstruct testTitle = new AtomTextConstruct { Text = "Test title" };
            const string testUpdated = "2010-11-01T00:04:00Z";
            const string testIcon = "http://odata.org/icon";
            const string testSourceId = "http://odata.org/id/random";
            const string testLogo = "http://odata.org/logo";
            AtomTextConstruct testSubtitle = new AtomTextConstruct { Text = "Test subtitle." };

            const string testAuthorName = "Test Author 1";
            const string testAuthorEmail = "*****@*****.**";
            const string testAuthorUri = "http://odata.org/authors/1";

            var testAuthors = new AtomPersonMetadata[]
                {
                    new AtomPersonMetadata()
                    {
                        Email = testAuthorEmail,
                        Name = testAuthorName,
                        Uri = new Uri(testAuthorUri)
                    }
                };

            var testAuthors2 = new AtomPersonMetadata[0];

            const string testCategoryTerm = "Test category 1 term";
            const string testCategoryLabel = "Test category 1 label";
            const string testCategoryScheme = "http://odata.org/categories/1";

            var testCategories = new AtomCategoryMetadata[]
                {
                    new AtomCategoryMetadata()
                    {
                        Term = testCategoryTerm,
                        Label = testCategoryLabel,
                        Scheme = testCategoryScheme
                    }
                };

            const string testContributorName = "Test Contributor 1";
            const string testContributorEmail = "*****@*****.**";
            const string testContributorUri = "http://odata.org/contributors/1";

            var testContributors = new AtomPersonMetadata[]
                {
                    new AtomPersonMetadata()
                    {
                        Email = testContributorEmail,
                        Name = testContributorName,
                        Uri = new Uri(testContributorUri)
                    }
                };

            const string testGeneratorName = "Test generator";
            const string testGeneratorUri = "http://odata.org/generator";
            const string testGeneratorVersion = "3.0";

            var testGenerator = new AtomGeneratorMetadata()
                {
                    Name = testGeneratorName,
                    Uri = new Uri(testGeneratorUri),
                    Version = testGeneratorVersion
                };

            const string testLinkRelation = "http://odata.org/links/1";
            const string testLinkTitle = "Test link 1";
            const string testLinkHref = "http://odata.org/links/1";
            const string testLinkHrefLang = "de-AT";
            int? testLinkLength = 999;
            const string testLinkMediaType = "image/png";

            var testLinks = new AtomLinkMetadata[] 
                {
                    new AtomLinkMetadata()
                    {
                        Relation = testLinkRelation,
                        Title = testLinkTitle,
                        Href = new Uri(testLinkHref),
                        HrefLang = testLinkHrefLang,
                        Length = testLinkLength,
                        MediaType = testLinkMediaType
                    }
                };

            AtomFeedMetadata testSource = new AtomFeedMetadata()
            {
                Authors = testAuthors,
                Categories = testCategories,
                Contributors = testContributors,
                Generator = testGenerator,
                Icon = new Uri(testIcon),
                SourceId = new Uri(testSourceId),
                Links = testLinks,
                Logo = new Uri(testLogo),
                Rights = testRights,
                Subtitle = testSubtitle,
                Title = testTitle,
                Updated = DateTimeOffset.Parse(testUpdated)
            };

            Func<string, Func<XElement, XElement>> fragmentExtractor = (localName) => (e) => e.Element(TestAtomConstants.AtomXNamespace + localName);

            // TODO, ckerer: specify an Id via metadata if the entry does not specify one; we first have to decide what rules
            //               we want to apply to merging of metadata and ODataLib OM data.
            var testCases = new[] {
                new { // specify an author via metadata
                    CustomizeMetadata = new Action<AtomEntryMetadata>(metadata => metadata.Authors = testAuthors),
                    Xml = string.Join(
                        "$(NL)",
                        @"<author xmlns=""" + TestAtomConstants.AtomNamespace + @""">",
                        @"  <name>" + testAuthorName + @"</name>",
                        @"  <uri>" + testAuthorUri + @"</uri>",
                        @"  <email>" + testAuthorEmail + @"</email>",
                        @"</author>"),
                    Extractor = fragmentExtractor(TestAtomConstants.AtomAuthorElementName)
                },
                new { // specify an empty author array via metadata
                    CustomizeMetadata = new Action<AtomEntryMetadata>(metadata => metadata.Authors = testAuthors2),
                    Xml = string.Join(
                        "$(NL)",
                        @"<author xmlns=""" + TestAtomConstants.AtomNamespace + @""">",
                        @"  <name />",
                        @"</author>"),
                    Extractor = fragmentExtractor(TestAtomConstants.AtomAuthorElementName)
                },
                new { // specify no authors via metadata
                    CustomizeMetadata = new Action<AtomEntryMetadata>(metadata => metadata.Authors = null),
                    Xml = string.Join(
                        "$(NL)",
                        @"<author xmlns=""" + TestAtomConstants.AtomNamespace + @""">",
                        @"$(Indent)<name />",
                        @"</author>"),
                    Extractor = fragmentExtractor(TestAtomConstants.AtomAuthorElementName)
                },
                new { // specify a category via metadata
                    CustomizeMetadata = new Action<AtomEntryMetadata>(metadata => metadata.Categories = testCategories),
                    Xml = @"<category term=""" + testCategoryTerm + @""" scheme=""" + testCategoryScheme + @""" label=""" + testCategoryLabel + @""" xmlns=""" + TestAtomConstants.AtomNamespace + @""" />",
                    Extractor = fragmentExtractor(TestAtomConstants.AtomCategoryElementName)
                },
                new { // specify a contributor via metadata
                    CustomizeMetadata = new Action<AtomEntryMetadata>(metadata => metadata.Contributors = testContributors),
                    Xml = string.Join(
                        "$(NL)",
                        @"<contributor xmlns=""" + TestAtomConstants.AtomNamespace + @""">",
                        @"  <name>" + testContributorName + @"</name>",
                        @"  <uri>" + testContributorUri + @"</uri>",
                        @"  <email>" + testContributorEmail + @"</email>",
                        @"</contributor>"),
                    Extractor = fragmentExtractor(TestAtomConstants.AtomContributorElementName)
                },
                new { // specify a link via metadata
                    CustomizeMetadata = new Action<AtomEntryMetadata>(metadata => metadata.Links = testLinks),
                    Xml = @"<link rel=""" + testLinkRelation + @""" type = """ + testLinkMediaType + @""" title=""" + testLinkTitle + @""" href=""" + testLinkHref + @""" hreflang=""" + testLinkHrefLang + @""" length=""" + testLinkLength + @"""  xmlns=""" + TestAtomConstants.AtomNamespace + @"""/>",
                    Extractor = new Func<XElement, XElement>(
                            (e) => e.Elements(TestAtomConstants.AtomXNamespace + TestAtomConstants.AtomLinkElementName)
                                    .Where(l => l.Attribute(TestAtomConstants.AtomLinkRelationAttributeName).Value != TestAtomConstants.AtomSelfRelationAttributeValue)
                                    .Single())
                },
                new { // specify a published date via metadata
                    CustomizeMetadata = new Action<AtomEntryMetadata>(metadata => metadata.Published = DateTimeOffset.Parse(testPublished)),
                    Xml = @"<published xmlns=""" + TestAtomConstants.AtomNamespace + @""">" + testPublished + @"</published>",
                    Extractor = fragmentExtractor(TestAtomConstants.AtomPublishedElementName)
                },
                new { // specify rights via metadata
                    CustomizeMetadata = new Action<AtomEntryMetadata>(metadata => metadata.Rights = testRights),
                    Xml = @"<rights type=""text"" xmlns=""" + TestAtomConstants.AtomNamespace + @""">" + testRights.Text + @"</rights>",
                    Extractor = fragmentExtractor(TestAtomConstants.AtomRightsElementName)
                },
                new { // specify a source via metadata
                    CustomizeMetadata = new Action<AtomEntryMetadata>(metadata => metadata.Source = testSource),
                    Xml = string.Join(
                        "$(NL)",
                        @"<source xmlns=""" + TestAtomConstants.AtomNamespace + @""">",
                        @"  <id>" + testSourceId + "</id>",
                        @"  <title type=""text"">" + testTitle.Text + @"</title>",
                        @"  <subtitle type=""text"">" + testSubtitle.Text + @"</subtitle>",
                        @"  <updated>" + testUpdated + @"</updated>",
                        @"  <link rel=""" + testLinkRelation + @""" type = """ + testLinkMediaType + @""" title=""" + testLinkTitle + @""" href=""" + testLinkHref + @""" hreflang=""" + testLinkHrefLang + @""" length=""" + testLinkLength + @"""/>",
                        @"  <category term=""" + testCategoryTerm + @""" scheme=""" + testCategoryScheme + @""" label=""" + testCategoryLabel + @""" />",
                        @"  <logo>" + testLogo + @"</logo>",
                        @"  <rights type=""text"">" + testRights.Text + @"</rights>",
                        @"  <contributor>",
                        @"    <name>" + testContributorName + @"</name>",
                        @"    <uri>" + testContributorUri + @"</uri>",
                        @"    <email>" + testContributorEmail + @"</email>",
                        @"  </contributor>",
                        @"  <generator uri=""" + testGeneratorUri + @""" version=""" +testGeneratorVersion + @""">" + testGeneratorName + @"</generator>",
                        @"  <icon>" + testIcon + @"</icon>",
                        @"  <author>",
                        @"    <name>" + testAuthorName + @"</name>",
                        @"    <uri>" + testAuthorUri + @"</uri>",
                        @"    <email>" + testAuthorEmail + @"</email>",
                        @"  </author>",
                        @"</source>"),
                    Extractor = fragmentExtractor(TestAtomConstants.AtomSourceElementName)
                },
                new { // specify default feed metadata as source
                    CustomizeMetadata = new Action<AtomEntryMetadata>(metadata => metadata.Source = new AtomFeedMetadata()),
                    Xml = string.Join(
                        "$(NL)",
                        @"<source xmlns=""" + TestAtomConstants.AtomNamespace + @""">",
                        @"  <id />",
                        @"  <title />",
                        @"  <updated />",
                        @"</source>"),
                    Extractor = new Func<XElement, XElement>(result => {
                        var source = fragmentExtractor(TestAtomConstants.AtomSourceElementName)(result);
                        // Remove the value of updates as it can't be reliably predicted
                        source.Element(TestAtomConstants.AtomXNamespace + TestAtomConstants.AtomUpdatedElementName).Nodes().Remove();
                        return source;
                    })
                },
                new { // specify a summary via metadata
                    CustomizeMetadata = new Action<AtomEntryMetadata>(metadata => metadata.Summary = testSummary),
                    Xml = @"<summary type=""text"" xmlns=""" + TestAtomConstants.AtomNamespace + @""">" + testSummary.Text + @"</summary>",
                    Extractor = fragmentExtractor(TestAtomConstants.AtomSummaryElementName)
                },
                new { // specify a title via metadata
                    CustomizeMetadata = new Action<AtomEntryMetadata>(metadata => metadata.Title = testTitle),
                    Xml = @"<title type=""text"" xmlns=""" + TestAtomConstants.AtomNamespace + @""">" + testTitle.Text + @"</title>",
                    Extractor = fragmentExtractor(TestAtomConstants.AtomTitleElementName)
                },
                new { // specify an updated date via metadata
                    CustomizeMetadata = new Action<AtomEntryMetadata>(metadata => metadata.Updated = DateTimeOffset.Parse(testUpdated)),
                    Xml = @"<updated xmlns=""" + TestAtomConstants.AtomNamespace + @""">" + testUpdated + @"</updated>",
                    Extractor = fragmentExtractor(TestAtomConstants.AtomUpdatedElementName)
                },
            };

            // Convert test cases to test descriptions
            IEnumerable<Func<ODataEntry>> entryCreators = new Func<ODataEntry>[]
                {
                    () => ObjectModelUtils.CreateDefaultEntry(),
                    () => ObjectModelUtils.CreateDefaultEntryWithAtomMetadata(),
                };
            var testDescriptors = testCases.SelectMany(testCase =>
                entryCreators.Select(entryCreator =>
                {
                    ODataEntry entry = entryCreator();
                    AtomEntryMetadata metadata = entry.Atom();
                    this.Assert.IsNotNull(metadata, "Expected default entry metadata on a default entry.");
                    testCase.CustomizeMetadata(metadata);
                    return new PayloadWriterTestDescriptor<ODataItem>(this.Settings, entry, testConfiguration =>
                        new AtomWriterTestExpectedResults(this.Settings.ExpectedResultSettings) { Xml = testCase.Xml, FragmentExtractor = testCase.Extractor });
                }));

            this.CombinatorialEngineProvider.RunCombinations(
                testDescriptors.PayloadCases(WriterPayloads.EntryPayloads),
                this.WriterTestConfigurationProvider.AtomFormatConfigurations,
                (testDescriptor, testConfiguration) =>
                {
                    testConfiguration = testConfiguration.Clone();
                    testConfiguration.MessageWriterSettings.SetServiceDocumentUri(ServiceDocumentUri);

                    TestWriterUtils.WriteAndVerifyODataPayload(testDescriptor, testConfiguration, this.Assert, this.Logger);
                });
        }
Ejemplo n.º 49
0
		private Func<Task> createMultiTask(Func<Task>[] taskRunners)
		{
			return () =>
			{
				var tasks = taskRunners.Select(fn => fn());
				return Task.WhenAll(tasks);
			};
		}
Ejemplo n.º 50
0
        private bool TryDetectFramework(string content, PathType pathType, ChutzpahTestSettingsFile chutzpahTestSettings, out IFrameworkDefinition definition)
        {
            var strategies = new Func<IFrameworkDefinition>[]
            {
                // Check chutzpah settings
                () => frameworkDefinitions.FirstOrDefault(x => x.FrameworkKey.Equals(chutzpahTestSettings.Framework, StringComparison.OrdinalIgnoreCase)),

                // Check if we see an explicit reference to a framework file (e.g. <reference path="qunit.js" />)
                () => frameworkDefinitions.FirstOrDefault(x => x.FileUsesFramework(content, false, pathType)),

                // Check using basic heuristic like looking for test( or module( for QUnit
                () => frameworkDefinitions.FirstOrDefault(x => x.FileUsesFramework(content, true, pathType))
            };

            definition = strategies.Select(x => x()).FirstOrDefault(x => x != null);
            return definition != null;
        }