Beispiel #1
0
 public void SimpleFlatten()
 {
     List<string> Test = new List<string>();
     Test.Add("Howdy");
     Test.Add("Pal");
     var result = Test.SelectMany(x => x.ToCharArray());
     result.AssertSequenceEqual('H', 'o', 'w', 'd', 'y', 'P', 'a', 'l' );
 }
        public void SelectManyQueryReuse()
        {
            List<List<int>> data = new List<List<int>> { new List<int> { 1, 2 }, new List<int> { 3, 4 } };
            IEnumerable<int> enumerable = data.SelectMany(x => x);

            enumerable.AssertEqual(1, 2, 3, 4);

            data.Add(new List<int> { 5, 6 });
            enumerable.AssertEqual(1, 2, 3, 4, 5, 6);
        }
        public void Should_Generate_One_Request_Object_Per_Not_Get_Methods()
        {
            var generatorMethods = new Collection<ClientGeneratorMethod>();
            generatorMethods.Add(new ClientGeneratorMethod
                                 {
                                     Name = "m1",
                                     Verb = "get",
                                     ReturnType = "t1",
                                     UriParameters = new List<GeneratorParameter>()
                                 });

            generatorMethods.Add(new ClientGeneratorMethod
                                 {
                                     Name = "m2",
                                     Verb = "post",
                                     ReturnType = "t2",
                                     UriParameters = new List<GeneratorParameter>()
                                 });

            generatorMethods.Add(new ClientGeneratorMethod
                                 {
                                     Name = "m3",
                                     Verb = "put",
                                     ReturnType = "t3",
                                     UriParameters = new List<GeneratorParameter>()
                                 });

            var classes = new List<ClassObject>();
            classes.Add(new ClassObject
                        {
                            Name = "c1",
                            Methods = generatorMethods
                        });

            var generator = new ApiRequestObjectsGenerator();
            var apiObjects = generator.Generate(classes);

            Assert.AreEqual(2, apiObjects.Count());

            Assert.AreEqual("ApiRequest", classes.SelectMany(c => c.Methods).First(m => m.Name == "m1").RequestType);
            Assert.IsFalse(string.IsNullOrWhiteSpace(classes.SelectMany(c => c.Methods).First(m => m.Name == "m2").RequestType));
            Assert.IsFalse(string.IsNullOrWhiteSpace(classes.SelectMany(c => c.Methods).First(m => m.Name == "m3").RequestType));
        }
Beispiel #4
0
        public void Test()
        {
            string word = "blue hades";
            var problemnum = 2;
            int unitIndex = 2;
            int seedIndex = 5;

            var problem = ProblemsSet.GetProblem(problemnum);
            var originalUnit = problem.units[unitIndex];
            var prefix = new List<MoveType>();
            var spawnedUnit = Game.SpawnUnit(originalUnit, problem).Move(MoveType.SE).Move(MoveType.SW);
            var unit = spawnedUnit;
            var units = new List<Unit> { unit };

            foreach (var c in word)
            {
                var moveType = MoveTypeExt.Convert(c);
                unit = unit.Move(moveType.Value);
                units.Add(unit);
            }
            var minX = units.SelectMany(x => x.members).Min(t => t.x);
            while (minX < 0)
            {
                prefix.Add(MoveType.E);
                minX++;
            }
            while (minX > 0)
            {
                prefix.Add(MoveType.W);
                minX--;
            }
            prefix.Add(MoveType.SE);
            prefix.Add(MoveType.SW);

            var game = new SolverGame(problem, problem.sourceSeeds[seedIndex], new string[0]);
            game.Step();
            var danananananananananananananan = "danananananananananananananan";
            game.ApplyUnitSolution(danananananananananananananan);
            if (game.state != GameBase.State.End && game.state != GameBase.State.WaitUnit)
                throw new InvalidOperationException(string.Format("Invalid game state: {0}", game.state));
            game.Step();
            Assert.That(game.spawnedUnitIndex, Is.EqualTo(unitIndex));
            var staticPowerPhraseBuilder = new StaticPowerPhraseBuilder();
            var solution = staticPowerPhraseBuilder.Build(prefix) + word;
            Console.Out.WriteLine(danananananananananananananan + solution);
            game.ApplyUnitSolution(solution);

            var output = new Output
            {
                problemId = problemnum,
                seed = problem.sourceSeeds[seedIndex],
                solution = danananananananananananananan + solution
            };
        }
        public void ShouldScheduleFixturesForAllTeams()
        {
            KnockoutStageSeason season = A.KnockoutStageSeason.WithPairCount(4).Scheduled().Activated().Build();

            var fixtures = new List<Fixture>();
            season.ScheduleFixtures(f => fixtures.Add(f));

            var fixtureTeams = fixtures.SelectMany(f => new Team[] { f.Team1, f.Team2 }).ToArray();

            Assert.That(fixtureTeams, Is.EquivalentTo(season.Teams));
        }
Beispiel #6
0
        public void Flatten()
        {
            var listA = new List<int> { 1, 2, 3, 4, 5 };
            var listB = new List<int> { 6, 7, 8, 9, 10 };
            var listC = new List<int> { 11, 12, 13, 14, 15 };

            var lists = new List<List<int>> { listA, listB, listC };

            var theList = lists.SelectMany(x => x);

            theList.Print();
        }
        public void LotsOfConcurrentMapRedRequestsShouldWork()
        {
            var keys = new List<string>();

            for (var i = 1; i < 11; i++)
            {
                var key = "key" + i;
                var doc = new RiakObject(MapReduceBucket, key, new { value = i });
                keys.Add(key);

                var result = Client.Put(doc, new RiakPutOptions { ReturnBody = true });
                result.IsSuccess.ShouldBeTrue();
            }

            var input = new RiakBucketKeyInput();
            keys.ForEach(k => input.Add(new RiakObjectId(MapReduceBucket, k)));

            var query = new RiakMapReduceQuery()
                .Inputs(input)
                .MapJs(m => m.Source(@"function(o){return[1];}"))
                .ReduceJs(r => r.Name(@"Riak.reduceSum").Keep(true));
            query.Compile();

            var results = new List<RiakResult<RiakMapReduceResult>>[ThreadCount];
            Parallel.For(0, ThreadCount, i =>
                {
                    results[i] = DoMapRed(query);
                });

            var failures = 0;
            foreach (var r in results.SelectMany(l => l))
            {
                if (r.IsSuccess)
                {
                    var resultValue = JsonConvert.DeserializeObject<int[]>(r.Value.PhaseResults.ElementAt(1).Values.First().FromRiakString())[0];
                    resultValue.ShouldEqual(10);
                    //r.Value.PhaseResults.ElementAt(1).GetObject<int[]>()[0].ShouldEqual(10);
                }
                else
                {
                    // the only acceptable result is that it ran out of retries when
                    // talking to the cluster (trying to get a connection)
                    r.ResultCode.ShouldEqual(ResultCode.NoRetries);
                    ++failures;
                }
            }

            Console.WriteLine("Total of {0} out of {1} failed to execute due to connection contention", failures, ThreadCount * ActionCount);
        }
Beispiel #8
0
        public void WillOuterJoinTwoSets()
        {
            //arrange
            var data1 = new List<int>() {3, 13, 7};
            var data2 = new List<int>() {8, 7, 13, 24};

            //act
            //var join = data1.Join(data2, x => x, y => y, (x, y) => x);
            var join = data1.GroupJoin(data2, x => x, y => y, (x, y) => new {Foo = x, Bars = y});
                //.SelectMany(x => x.Bars.DefaultIfEmpty());
            var j1 = data1.SelectMany(x => data2.Where(y => y == x).DefaultIfEmpty(), (x, y) => y);
            //data1.LeftOuterJoin()

            //assert
            j1.Count().ShouldEqual(5);
        }
        public void ShouldWork()
        {
            var ready = false;
            var bytes = new List<byte[]>();
            var obs = new ObservableFromFile(@"samples\example_1.txt");
            obs.Subscribe(bytes.Add, e => { }, () => { ready = true; });
            while (!ready)
            {
                Thread.Sleep(10);
            }

            var array = bytes.SelectMany(b => b)
                             .Skip(3) // ignore the first 3bytes
                             .ToArray();
            var result = Encoding.UTF8.GetString(array).Replace("\n", " ").Replace("\r\n", " ");
            var expected = String.Join(" ", Enumerable.Range(1, 9));
            result.Should().Be.EqualTo(expected);
        }
        public void Original()
        {
            var allCsvs = new List<Csv>
            {
            new Csv
                {
                    CommaSepList = "1,2,3,4,,5"
                },
            new Csv
                {
                    CommaSepList = "4,5,7,,5,,"
                },
            };

            int[] intArray = allCsvs
            .SelectMany(c => c.CommaSepList.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries))
            .Select(int.Parse)
            .ToArray();
        }
        public void RequestCustomValidatorErrorCode_When_all_have_unique_value_Then_test_passed()
        {
            RequestValidatorErrorMessagesDictionary.Register<ProductRequestCustomValidatorErrorCode>();
            RequestValidatorErrorMessagesDictionary.Register<PartnerRequestCustomValidatorErrorCode>();
            RequestValidatorErrorMessagesDictionary.Register<RequestValidatorErrorCode>();
            RequestValidatorErrorMessagesDictionary.Register<CommonErrorCode>();

            var types = new List<Type>();
            types.Add(typeof(ProductRequestCustomValidatorErrorCode));
            types.Add(typeof(PartnerRequestCustomValidatorErrorCode));
            types.Add(typeof(RequestValidatorErrorCode));
            types.Add(typeof (CommonErrorCode));

            var codeConsts =
                types.SelectMany(t => t.GetFields(BindingFlags.Public | BindingFlags.Static | BindingFlags.FlattenHierarchy)
                                        .Where(f => f.IsLiteral && f.FieldType == typeof(int) && f.DeclaringType == t)).ToList();

            Assert.AreEqual(codeConsts.Count, codeConsts.Select(s => (int)s.GetValue(null)).Distinct().Count(), "Error codes are not unique");
            Assert.AreEqual(codeConsts.Count, RequestValidatorErrorMessagesDictionary.Instance.Count, "Fetched error codes count is not correct");
            Assert.Pass(codeConsts.Count+" unique error codes");
        }
        public void Given_IsSensitive_is_true_then_PersonalRiskAssessment_not_returned()
        {
            //GIVEN
            var pras = new List<PersonalRiskAssessment>();
            var pra = PersonalRiskAssessment.Create("title", "reference", _companyId, new UserForAuditing() { Id = Guid.NewGuid() });
            pra.Sensitive = true;
            pra.RiskAssessmentSite = new Site();
            pras.Add(pra);

            var target = GetTarget();

            target.Setup(x => x.PersonalRiskAssessments())
                .Returns(pras.AsQueryable);

            target.Setup(x => x.RiskAssessmentReviews())
               .Returns(pras.SelectMany(x => x.Reviews).AsQueryable);

            var result = target.Object.Search(null, _companyId, null, null, null, null, null, _user.Id, false, false, 1, 10, RiskAssessmentOrderByColumn.Title, OrderByDirection.Ascending);

            //THEN
            Assert.That(result.Count(), Is.EqualTo(0));
        }
        public void RequestCustomValidatorErrorCode_When_all_have_stringValueAttribute_Then_test_passed()
        {
            RequestValidatorErrorMessagesDictionary.Register<ProductRequestCustomValidatorErrorCode>();
            RequestValidatorErrorMessagesDictionary.Register<PartnerRequestCustomValidatorErrorCode>();
            RequestValidatorErrorMessagesDictionary.Register<RequestValidatorErrorCode>();
            RequestValidatorErrorMessagesDictionary.Register<CommonErrorCode>();

            var types = new List<Type>();
            types.Add(typeof(ProductRequestCustomValidatorErrorCode));
            types.Add(typeof(PartnerRequestCustomValidatorErrorCode));
            types.Add(typeof(RequestValidatorErrorCode));
            types.Add(typeof(CommonErrorCode));

            var codeConsts =
                types.SelectMany(t => t.GetFields(BindingFlags.Public | BindingFlags.Static | BindingFlags.FlattenHierarchy)
                                        .Where(f => f.IsLiteral && f.FieldType == typeof(int) && f.DeclaringType == t)).ToList();

            foreach (var codeConst in codeConsts)
            {
                Assert.IsTrue(codeConst.CustomAttributes
                    .SingleOrDefault(s => s.AttributeType == typeof(StringValueAttribute)) != null);
            }
        }
Beispiel #14
0
        private void SeedStackOverflowData(IDbConnectionFactory dbConnectionFactory)
        {
            var client = new JsonServiceClient();
            int numberOfPages = 80;
            int pageSize = 100;
            var dbQuestions = new List<Question>();
            var dbAnswers = new List<Answer>();
            try
            {
                for (int i = 1; i < numberOfPages + 1; i++)
                {
                    //Throttle queries
                    Thread.Sleep(100);
                    var questionsResponse =
                        client.Get("https://api.stackexchange.com/2.2/questions?page={0}&pagesize={1}&site={2}&tagged=servicestack"
                                .Fmt(i, pageSize, "stackoverflow"));

                    QuestionsResponse qResponse;
                    using (new ConfigScope())
                    {
                        var json = questionsResponse.ReadToEnd();
                        qResponse = json.FromJson<QuestionsResponse>();
                        dbQuestions.AddRange(qResponse.Items.Select(q => q.ConvertTo<Question>()));
                    }

                    var acceptedAnswers =
                        qResponse.Items
                        .Where(x => x.AcceptedAnswerId != null)
                        .Select(x => x.AcceptedAnswerId).ToList();

                    var answersResponse = client.Get("https://api.stackexchange.com/2.2/answers/{0}?sort=activity&site=stackoverflow"
                        .Fmt(acceptedAnswers.Join(";")));

                    using (new ConfigScope())
                    {
                        var json = answersResponse.ReadToEnd();
                        var aResponse = JsonSerializer.DeserializeFromString<AnswersResponse>(json);
                        dbAnswers.AddRange(aResponse.Items.Select(a => a.ConvertTo<Answer>()));
                    }
                }
            }
            catch (Exception ex)
            {
                //ignore
            }

            //Filter duplicates
            dbQuestions = dbQuestions.GroupBy(q => q.QuestionId).Select(q => q.First()).ToList();
            dbAnswers = dbAnswers.GroupBy(a => a.AnswerId).Select(a => a.First()).ToList();
            var questionTags = dbQuestions.SelectMany(q =>
                q.Tags.Select(t => new QuestionTag { QuestionId = q.QuestionId, Tag = t }));

            using (var db = dbConnectionFactory.OpenDbConnection())
            {
                db.InsertAll(dbQuestions);
                db.InsertAll(dbAnswers);
                db.InsertAll(questionTags);
            }
        }
        private void _SetupLargeDataset()
        {
            _largeDataset = new List<string>();
            HashSet<SearchResult> searchResults = new HashSet<SearchResult>();
            StreamReader reader = new StreamReader(@"results.csv");
            reader.ReadLine(); //do not process header

            while (!reader.EndOfStream)
            {
                string line = reader.ReadLine();
                string[] entries = line.Split(new [] {','}, System.StringSplitOptions.None);
                SearchResult sr = new SearchResult(entries[0]);
                searchResults.Add(sr);
            }

            _largeDataset.AddRange(searchResults.Where(x => !string.IsNullOrEmpty(x.Name)).Select(x => x.Name));
            List<string> intermediateDataSet = new List<string>();
            intermediateDataSet.AddRange(_largeDataset.SelectMany(x => x.Split(new[] {' '})));

            _sortedDataSet = new SortedList(
                intermediateDataSet.Where(x => !string.IsNullOrWhiteSpace(x)).
                                    Select(x => x.ToLower().Trim()).
                                    Distinct().
                                    ToDictionary(str => str));
        }
        public void Model_Latest()
        {
            LuMiiCorpus corpus = new LuMiiCorpus();
            List<Sentence> all = new List<Sentence>();
            foreach (string resource in ModelLatestData)
                all.AddRange(corpus.Load(this.GetType().Assembly.GetManifestResourceStream(resource)).ToArray());

            LuMiiTagger tagger = new LuMiiTagger();
            tagger.Load();
            tagger.Tag(all);

            Token[] tokens = all.SelectMany(t => t).ToArray();
            double accuracy = (double)tokens.Count(t => t.IsTagCorrect) / tokens.Count();

            Assert.Greater(accuracy, 0.99);
        }
        public void TagSpeed()
        {
            string trainResource = Analyzed2Train;
            string testResource = Analyzed2Test;
            int maxTokenCount = 1000000;
            double minAccuracy = 0.93;

            Sentence[] train = LoadAnalyzedCorpus(trainResource);
            Sentence[] test = LoadAnalyzedCorpus(testResource);

            List<Sentence> all = new List<Sentence>();
            int allTokenCount = 0;
            while (allTokenCount < maxTokenCount)
            {
                Sentence s = new Sentence();

                foreach (Sentence sentence in test)
                {
                    foreach (Token token in sentence)
                    {
                        s.Add(new Token(token));
                        allTokenCount++;
                        if (allTokenCount >= maxTokenCount) break;
                    }

                    if (allTokenCount >= maxTokenCount) break;
                }

                all.Add(s);

                if (allTokenCount >= maxTokenCount) break;
            }

            Assert.AreEqual(maxTokenCount, all.SelectMany(t => t).Count());

            LuMiiTagger tagger = new LuMiiTagger();
            tagger.Train(train);

            Stopwatch timer = new Stopwatch();
            timer.Start();
            tagger.Tag(all);
            timer.Stop();

            Token[] tokens = all.SelectMany(t => t).ToArray();
            double accuracy = (double)tokens.Count(t => t.IsTagCorrect) / tokens.Count();

            Assert.AreEqual(maxTokenCount, tokens.Length);

            Debug.WriteLine("Accuracy: {0:0.00}%", accuracy * 100);
            Debug.WriteLine("Tokens: {0}%", tokens.Length);
            Debug.WriteLine("Tag duration: {0} or {1:0} ms", timer.Elapsed, timer.ElapsedMilliseconds);
            Debug.WriteLine("Tag speed: {0:0.00} tokens/s", tokens.Length / timer.Elapsed.TotalSeconds);

            Assert.Greater(accuracy, minAccuracy);
            Assert.Less(accuracy, 0.97);
        }
Beispiel #18
0
        public void Map_MockedInternalMappers_Redirects()
        {
            BaseMapper<TestClassB, TestClassD>[] mapperMocks =
                A.CollectionOfFake<BaseMapper<TestClassB, TestClassD>>(5).ToArray();
            var results = new List<IEnumerable<MemberMappingInfo<TestClassB, TestClassD>>>();
            for (int i = 0; i < mapperMocks.Length; ++i)
            {
                var res = new[]
                {
                    A.Fake<MemberMappingInfo<TestClassB, TestClassD>>(
                        o => o.WithArgumentsForConstructor(
                            new object[]
                            {
                                Guid.NewGuid().ToString(),
                                Guid.NewGuid().ToString()
                            }))
                };

                results.Add(res);
                A.CallTo(() => mapperMocks[i].GetMappings())
                    .Returns(res);
            }

            var target = new CompositeMapper<TestClassB, TestClassD>(mapperMocks);
            var source = new TestClassB();
            var result = new TestClassD();

            target.Map(source, result);

            foreach (var m in results.SelectMany(e => e))
            {
                A.CallTo(() => m.Map(source, result)).MustHaveHappened();
            }
        }
        public void ReuseStorage()
        {
            const int ThreadCount = 16;

            // have to reset so other tests don't clober
            ConcurrentProfileStorageCollection.AllocationCount = 0;

            using (var conn = Create())
            {
                var profiler = new TestProfiler2();
                conn.RegisterProfiler(profiler);

                var perThreadContexts = new List<object>();
                for (var i = 0; i < 16; i++)
                {
                    perThreadContexts.Add(new object());
                }

                var threads = new List<Thread>();

                var results = new List<IEnumerable<IProfiledCommand>>[16];
                for (var i = 0; i < 16; i++)
                {
                    results[i] = new List<IEnumerable<IProfiledCommand>>();
                }

                for (var i = 0; i < ThreadCount; i++)
                {
                    var ix = i;
                    var thread =
                        new Thread(
                            delegate()
                            {
                                for (var k = 0; k < 10; k++)
                                {
                                    var ctx = perThreadContexts[ix];
                                    profiler.RegisterContext(ctx);

                                    conn.BeginProfiling(ctx);
                                    var db = conn.GetDatabase(ix);

                                    var allTasks = new List<Task>();

                                    for (var j = 0; j < 1000; j++)
                                    {
                                        allTasks.Add(db.StringGetAsync("hello" + ix));
                                        allTasks.Add(db.StringSetAsync("hello" + ix, "world" + ix));
                                    }

                                    Task.WaitAll(allTasks.ToArray());

                                    results[ix].Add(conn.FinishProfiling(ctx));
                                }
                            }
                        );

                    threads.Add(thread);
                }

                threads.ForEach(t => t.Start());
                threads.ForEach(t => t.Join());

                // only 16 allocations can ever be in flight at once
                var allocCount = ConcurrentProfileStorageCollection.AllocationCount;
                Assert.IsTrue(allocCount <= ThreadCount, allocCount.ToString());

                // correctness check for all allocations
                for (var i = 0; i < results.Length; i++)
                {
                    var resList = results[i];
                    foreach (var res in resList)
                    {
                        Assert.IsNotNull(res);

                        var numGets = res.Count(r => r.Command == "GET");
                        var numSets = res.Count(r => r.Command == "SET");

                        Assert.AreEqual(1000, numGets);
                        Assert.AreEqual(1000, numSets);
                        Assert.IsTrue(res.All(cmd => cmd.Db == i));
                    }
                }

                // no crossed streams
                var everything = results.SelectMany(r => r).ToList();
                for (var i = 0; i < everything.Count; i++)
                {
                    for (var j = 0; j < everything.Count; j++)
                    {
                        if (i == j) continue;

                        if (object.ReferenceEquals(everything[i], everything[j]))
                        {
                            Assert.Fail("Profilings were jumbled");
                        }
                    }
                }
            }
        }
        public void Should_Set_Response_Types()
        {
            var generatorMethods = new Collection<ClientGeneratorMethod>();
            generatorMethods.Add(new ClientGeneratorMethod
            {
                Name = "m1",
                Verb = "get",
                ReturnType = "t1",
                UriParameters = new List<GeneratorParameter>()
            });

            generatorMethods.Add(new ClientGeneratorMethod
            {
                Name = "m2",
                Verb = "post",
                ReturnType = "t2",
                UriParameters = new List<GeneratorParameter>()
            });

            generatorMethods.Add(new ClientGeneratorMethod
            {
                Name = "m3",
                Verb = "put",
                ReturnType = "t3",
                UriParameters = new List<GeneratorParameter>()
            });

            var classes = new List<ClassObject>();
            classes.Add(new ClassObject
            {
                Name = "c1",
                Methods = generatorMethods
            });

            Assert.IsTrue(string.IsNullOrWhiteSpace(classes.SelectMany(c => c.Methods).First(m => m.Name == "m1").ResponseType));
            Assert.IsTrue(string.IsNullOrWhiteSpace(classes.SelectMany(c => c.Methods).First(m => m.Name == "m2").ResponseType));
            Assert.IsTrue(string.IsNullOrWhiteSpace(classes.SelectMany(c => c.Methods).First(m => m.Name == "m3").ResponseType));

            var generator = new ApiResponseObjectsGenerator();
            generator.Generate(classes);

            Assert.IsFalse(string.IsNullOrWhiteSpace(classes.SelectMany(c => c.Methods).First(m => m.Name == "m1").ResponseType));
            Assert.IsFalse(string.IsNullOrWhiteSpace(classes.SelectMany(c => c.Methods).First(m => m.Name == "m2").ResponseType));
            Assert.IsFalse(string.IsNullOrWhiteSpace(classes.SelectMany(c => c.Methods).First(m => m.Name == "m3").ResponseType));

        }
Beispiel #21
0
 public void LIVE_STRESS_TEST_multiple_producers_multiple_queues_one_consumer_per_queue()
 {
     var messagesPerProducer = 100;
     var producerCount = 1;
     var client = CreateLiveClient();
     var queues = new List<string>();
     foreach(var x in new[] { "a", "b", "c", "d" }) {
         var queue = "test-" + x + "-" + StringUtil.CreateAlphaNumericKey(4);
         client.CreateQueue(queue, new Result<AwsSqsResponse>()).Wait();
         queues.Add(queue);
     }
     try {
         var producers = new List<Result<List<string>>>();
         for(var i = 0; i < producerCount; i++) {
             var producer = i;
             producers.Add(Async.Fork(() => {
                 _log.DebugFormat("producer {0} started", producer);
                 var c = CreateLiveClient();
                 var msgs = new List<string>();
                 for(var j = 0; j < messagesPerProducer; j++) {
                     var msg = StringUtil.CreateAlphaNumericKey(1024);
                     foreach(var queue in queues) {
                         c.Send(queue, AwsSqsMessage.FromBody(msg), new Result<AwsSqsSendResponse>()).Wait();
                     }
                     msgs.Add(msg);
                     if(msgs.Count % 10 == 0) {
                         _log.DebugFormat("producer {0} sent {1}/{2} msgs", producer, msgs.Count, messagesPerProducer);
                     }
                 }
                 _log.DebugFormat("producer {0} finished", producer);
                 return msgs;
             }, new Result<List<string>>()));
         }
         var consumers = queues.ToDictionary(queue => queue, queue => Async.Fork(() => {
             _log.DebugFormat("consumer {0} started", queue);
             var c = CreateLiveClient();
             var msgs = new List<string>();
             var expected = messagesPerProducer * producerCount;
             var lastReport = 0;
             while(msgs.Count < expected) {
                 var received = c.ReceiveMax(queue, new Result<IEnumerable<AwsSqsMessage>>()).Wait();
                 var count = 0;
                 foreach(var msg in received) {
                     count++;
                     msgs.Add(msg.Body);
                     c.Delete(msg, new Result<AwsSqsResponse>()).Wait();
                 }
                 if(count > 0 && msgs.Count > lastReport + 10) {
                     _log.DebugFormat("consumer '{0}' received: {1}/{2}", queue, msgs.Count, expected);
                     lastReport = msgs.Count;
                 }
             }
             return msgs;
         }, new Result<List<string>>()));
         producers.Join(new Result()).Wait();
         consumers.Values.Join(new Result()).Wait();
         var allMessages = producers.SelectMany(x => x.Value).OrderBy(x => x).ToArray();
         foreach(var consumed in consumers) {
             var queue = consumed.Key;
             var messages = consumed.Value.Value.OrderBy(x => x).ToArray();
             Assert.AreEqual(allMessages, messages, string.Format("message list for queue '{0}' is wrong", queue));
         }
     } finally {
         foreach(var queue in queues) {
             _log.DebugFormat("cleaning up queue '{0}'", queue);
             client.DeleteQueue(queue, new Result<AwsSqsResponse>()).Wait();
         }
     }
 }
        public void Test()
        {
            var lista = new List<TestObj>() {};

            lista.SelectMany(x => x.Collection).ToDictionary(x => x.ToLower(), v => v);
        }
        public void should_flush_multiple_times(bool waitForCompletion)
        {
            var collection = new FlushableBlockingCollection<int>();

            var consumedItems = new List<int>();
            var consumerTask = Task.Run(() =>
            {
                foreach (var item in collection.GetConsumingEnumerable())
                {
                    consumedItems.Add(item);
                    Thread.Yield();
                }
                Console.WriteLine("Consumer done");
            });

            var flushedItems = new List<ConcurrentQueue<int>>();
            var flusherTask = Task.Run(() =>
            {
                for (var i = 0; i < 10; ++i)
                {
                    flushedItems.Add(collection.Flush(waitForCompletion));
                    Thread.Sleep(50);
                }
                Console.WriteLine("Flusher done");
            });

            var adderTask = Task.Run(() =>
            {
                foreach (var item in Enumerable.Range(0, 5000000).Select(x => 3 * x))
                {
                    collection.Add(item);
                    Thread.Yield();
                }
                Console.WriteLine("Adder done");
            });

            adderTask.Wait();

            collection.CompleteAdding();

            Task.WaitAll(consumerTask, flusherTask);

            var flushedItemCount = flushedItems.Sum(x => x.Count);
            Console.WriteLine("{0} flushed items", flushedItemCount);

            consumedItems.AddRange(flushedItems.SelectMany(x => x));
            consumedItems.Count.ShouldEqual(5000000);
        }
        public void SelectManyWithIndexAndResultSelectorQueryReuse()
        {
            List<List<int>> data = new List<List<int>> { new List<int> { 1, 2 }, new List<int> { 3, 4 } };
            IEnumerable<int> enumerable = data.SelectMany((x, i) => x, (s, c) => c * c);

            enumerable.AssertEqual(1, 4, 9, 16);

            data.Add(new List<int> { 5, 6 });
            enumerable.AssertEqual(1, 4, 9, 16, 25, 36);
        }
        public void Given_IsSensitive_and_not_created_by_user_and_not_assigned_to_latest_review_then_PersonalRiskAssessment_not_returned()
        {
            var pras = new List<PersonalRiskAssessment>();
            var pra = PersonalRiskAssessment.Create("title", "reference", _companyId, new UserForAuditing() { Id = Guid.NewGuid() });
            pra.Sensitive = true;
            pra.RiskAssessmentSite = new Site();
            pra.AddReview(new RiskAssessmentReview() {Id = 111, CreatedOn = DateTime.Now.AddDays(-10), ReviewAssignedTo = _employee});
            pra.AddReview(new RiskAssessmentReview() {Id=222, CreatedOn = DateTime.Now.AddDays(10),ReviewAssignedTo = new Employee() { User = new User() { Id = Guid.NewGuid() } } }); //the latest review no assigned to the user
            pras.Add(pra);

            var target = GetTarget();

            target.Setup(x => x.PersonalRiskAssessments())
                .Returns(pras.AsQueryable);

            target.Setup(x => x.RiskAssessmentReviews())
               .Returns(pras.SelectMany(x => x.Reviews).AsQueryable);

            var result = target.Object.Search(null, _companyId, null, null, null, null, null, _user.Id, false, false, 1, 10, RiskAssessmentOrderByColumn.Title, OrderByDirection.Ascending);

            //THEN
            Assert.That(result.Count(), Is.EqualTo(0));
        }