public void Test()
        {
            var rand = new Random(3);

            List<string> list1 = new List<string>();
            WeakList<string> list2 = new WeakList<string>();

            for (int x = 0; x < 1000; x++)
            {
                var str = x.ToString();
                list1.Add(str);
                list2.Add(str);

                if (!list1.SequenceEqual(list2))
                    throw new Exception("Lists are not the same.");
            }

            for (int x = 1000; x < 2000; x++)
            {
                var str = x.ToString();
                var removeItem = list1[rand.Next(list1.Count)];
                list1.Remove(removeItem);
                list2.Remove(removeItem);

                if (!list1.SequenceEqual(list2))
                    throw new Exception("Lists are not the same.");

                list1.Add(str);
                list2.Add(str);

                if (!list1.SequenceEqual(list2))
                    throw new Exception("Lists are not the same.");
            }

            for (int x = 0; x < 100; x++)
            {
                list1.RemoveAt(rand.Next(list1.Count));
                GC.Collect();

                if (!list1.SequenceEqual(list2))
                    throw new Exception("Lists are not the same.");
            }


            list2.Clear();
            foreach (var data in list2)
                throw new Exception();
        }
Example #2
0
        public void TestDifferingLists()
        {
            var x = new List<int> {1, 2, 3, 4, 5, 6};
            var y = new List<int> {1, 2, 3, 4, 5, 7};

            ApproveException(() => x.SequenceEqual(y));
        }
        public void RemoveWithEmptyItems()
        {
            ICollection<int> col = new List<int> { 1, 2, 3 };

            col.Remove(new int[] { });
            Assert.IsTrue(col.SequenceEqual(new [] { 1, 2, 3 }));
        }
        public void RemoveAll()
        {
            ICollection<int> col = new List<int> { 1, 2, 3, 4, 5 };

            col.RemoveAll(x => x % 2 == 0);
            Assert.IsTrue(col.SequenceEqual(new [] { 1, 3, 5 }));
        }
        public void RemoveItems()
        {
            ICollection<int> col = new List<int> { 1, 2, 3, 4, 5 };

            col.Remove(new int[] { 2, 4 });
            Assert.IsTrue(col.SequenceEqual(new [] { 1, 3, 5 }));
        }
Example #6
0
        public void story_data_is_observed_during_invocation()
        {
            var data = new List<KeyValuePair<string, object>>()
            {
                new KeyValuePair<string, object>("bool_value", true),
                new KeyValuePair<string, object>("int_value", 123),
                new KeyValuePair<string, object>("string_value", "test!"),
            };

            var handlerRules = new Ruleset<IStory, IStoryHandler>()
            {
                Rules = {
                    new PredicateRule(
                        _ => true,                                                              // always run for story
                        _ => new ActionHandler(
                            (story) => Assert.AreEqual(0, story.Data.Count()),                  // make sure OnStart() is invoked with zero data items.
                            (story, task) => Assert.IsTrue(data.SequenceEqual(story.Data)))     // make sure OnStop() is invoked with 3 data items.
                    ),
                },
            };

            new Story("testStory", handlerRules).Run(story =>
            {
                foreach (var kvp in data)
                {
                    story.Data[kvp.Key] = kvp.Value;
                }
            });
        }
        public void RemoveWithNullItems()
        {
            ICollection<int> col = new List<int> { 1, 2, 3 };

            col.Remove((int[])null);
            Assert.IsTrue(col.SequenceEqual(new [] { 1, 2, 3 }));
        }
        public void TestGetRandomItemsInNonUniformDistribution()
        {
            var items = GetNonUniformlyDistributedItems(10).ToList();
            var randomItemRetriever = new RandomItemRetriever<IProbabilityWeightedItem>(_randomGenerator, items);

            var actualItems = Enumerable.Range(0, 10)
                            .Select(counter => randomItemRetriever.NextItem())
                            .ToList();

            var expectedItems = new List<IProbabilityWeightedItem>
                                    {
                                        items[0],
                                        items[1],
                                        items[1],
                                        items[2],
                                        items[2],
                                        items[2],
                                        items[3],
                                        items[3],
                                        items[3],
                                        items[3]
                                    };

            Assert.IsTrue(expectedItems.SequenceEqual(actualItems));
        }
        public void ParseTest(List<TimePeriodToken> TimePeriodTokens, List<Shift> expectedShifts)
        {
            var parser = new ShiftsFactory(TimePeriodTokens, task, date, interval, exceedingAllowed);

            var actualShifts = parser.Parse();

            Assert.IsTrue(expectedShifts.SequenceEqual<Shift>(actualShifts));
        }
Example #10
0
        public void SetEquality()
        {
            var a = new List<int> { 1, 2, 3 };
            var b = new List<int> { 1, 2, 3 };

            var result = a.SequenceEqual(b);

            Assert.IsTrue(result);
        }
        public void TaskFactoryMakeShiftTest(Model.Task test, 
            List<ShiftsSpecification> shiftSpecList, 
            List<Model.Shift> expectedShifts)
        {
            var parser = new TaskFactory();
            var actualShifts = parser.MakeShifts(test, shiftSpecList);

            Assert.IsTrue(expectedShifts.SequenceEqual(actualShifts));
        }
        public void WorkerFactoryMakeIndisposedTest(Model.Worker test,
            List<IndisposedSpecification> indisposedSpecList,
            List<Model.Indisposed> expectedIndisposeds)
        {
            var parser = new WorkerFactory();
            var actualShifts = parser.MakeIndisposeds(test, indisposedSpecList);

            Assert.IsTrue(expectedIndisposeds.SequenceEqual(actualShifts));
        }
        public void ScanTest(string shiftsField, List<TimePeriodToken> expectedTokens)
        {
            var scanner = new TimePeriodScanner(shiftsField);

            scanner.Scan();
            var actualTokens = scanner.Tokens;

            Assert.IsTrue(expectedTokens.SequenceEqual<TimePeriodToken>(actualTokens));
        }
Example #14
0
        public void PedidoTemProdutoCliente()
        {
            var clientes = new List<Cliente> { new Cliente("Gabriel") };
            var produto = new Produto("batata", 2.99m);

            var pedido = new Pedido(produto, clientes);

            Assert.AreEqual(produto, pedido.Produto);
            Assert.IsTrue(clientes.SequenceEqual(pedido.Clientes), "clientes");
        }
        public void TestValidateAllValidRecords()
        {
            List<RawStudentInfo> records = new List<RawStudentInfo>
            {
                new RawStudentInfo{FirstName="John", LastName="Conn", Age="20", Sex = "Male"},
                new RawStudentInfo{FirstName="Sarah", LastName="Libouee", Age="25", Sex = "Female"},
                new RawStudentInfo{FirstName="Lucia", LastName="Fabi", Age="22", Sex = "Female"}
            };

            Assert.IsTrue(records.SequenceEqual(stService.GetRecords(records, "En-US").ValidRecords));
        }
        public void Can_Be_Enumerated()
        {
            var expectedDirectoryNames = new List<string>{ "1000", "1001" };
            var expectedUrls = expectedDirectoryNames.Select(GetUrl);

            expectedDirectoryNames.ForEach(name => CreateDirectory(name));

            var directories = Sut.GetDirectories("").ToList();

            Assert.That(expectedDirectoryNames.SequenceEqual(directories), String.Join(",", directories));
        }
        public void GetLocalReferencesTest()
        {
            var expected = new List<string>
            {
                "DummyAssembly1.dll",
                "DummyAssembly2.dll",
            };

            var actual = AssemblyAnalyzer.GetLocalReferences("DummyApplication.exe");

            Assert.IsTrue(expected.SequenceEqual(actual));
        }
Example #18
0
 private static void Test(TypeModel m)
 {
     var list = new List<object> { new A { Id = "Abracadabra" }, new B { Id = "Focuspocus" }, new A { Id = "Abracadabra" }, };
     using (var ms = new MemoryStream())
     {
         m.Serialize(ms, list);
         ms.Position = 0;
         var list2 = (List<object>)m.Deserialize(ms, null, typeof(List<object>));
         Debug.Assert(list.SequenceEqual(list2));
         File.WriteAllBytes(@"output.dump", ms.ToArray());
     }
 }
        public void Each_ExecuteCorrectNumberOfTimesWithCorrectValue()
        {
            var items = new List<int>();

            Enumerable.Range(1, 10)
                .SmartLoop()
                .Each(items.Add)
                .Execute();

            Assert.AreEqual(10, items.Count);
            Assert.IsTrue(items.SequenceEqual(Enumerable.Range(1, 10)));
        }
Example #20
0
        public void StringebisListEqual()
        {
            var l1 = new List<string>() { "a", "b", "c", "d", "f" };
            var l2 = new List<string>() { "a", "f", "c", "d"};
            l1.Sort();
            l2.Sort();

            foreach (var item in l2)
            {
                Console.WriteLine(item);
            }
            Console.WriteLine(l1.SequenceEqual(l2));
        }
        public void Can_Be_Enumerated_With_Filter_But_Filter_Is_Ignored()
        {
            var paths = new List<string>
            {
                "1001/test1.dat",
                "1001/test2.txt"
            };

            paths.ForEach(path => Sut.AddFile(path, CreateTestStream()));

            var files = Sut.GetFiles("1001/", "*.txt").ToList();
            Assert.That(paths.SequenceEqual(files), String.Join(",", files));
        }
Example #22
0
 public void CanConcatEventStreams()
 {
     var subject1 = new EventSubject<TestModel, int, IEventContext>();
     var subject2 = new EventSubject<TestModel, int, IEventContext>();
     var stream = EventObservable.Concat(subject1, subject2);
     List<int> received = new List<int>();
     stream.Observe((m, e, c) => received.Add(e));
     subject1.OnNext(_model, 1, _eventContext);
     subject2.OnNext(_model, 2, _eventContext);
     subject1.OnNext(_model, 3, _eventContext);
     subject2.OnNext(_model, 4, _eventContext);
     Assert.IsTrue(received.SequenceEqual(new[] {1, 2, 3, 4}));
 }
Example #23
0
        public void ForEach()
        {
            Spec.ForAny<int[]>(xs =>
            {
                var x = new List<int>();
                xs.AsQueryExpr().ForEach(num => x.Add(num)).Run();

                var y = new List<int>();
                xs.ToList().ForEach(num => y.Add(num));

                return x.SequenceEqual(y);
            }).QuickCheckThrowOnFailure();
        }
Example #24
0
        public void PaymentDetailComparer_Returns_False_If_Are_Not_Equal()
        {
            var firstPaymentDetail = new PaymentDetail
            {
                Description = "Refaktura za wsdfode",
                MeasureUnit = "szt.",
                PricePerUnit = 53,
                Quantity = 1
            };

            var secondPaymentDetail = new PaymentDetail
            {
                Description = "czynsz",
                MeasureUnit = "szt.",
                PricePerUnit = 45333,
                Quantity = 5
            };

            var thirdPaymentDetail = new PaymentDetail
            {
                Description = "Refaktura za wode",
                MeasureUnit = "szt.",
                PricePerUnit = 53,
                Quantity = 1
            };

            var fourthPaymentDetail = new PaymentDetail
            {
                Description = "czynsz",
                MeasureUnit = "szt.",
                PricePerUnit = 45333,
                Quantity = 5
            };

            var aPaymentDetails = new List<PaymentDetail>
            {
                firstPaymentDetail,
                secondPaymentDetail
            };

            var bPaymentDetails = new List<PaymentDetail>
            {
                thirdPaymentDetail,
                fourthPaymentDetail
            };

            bool equalAB = aPaymentDetails.SequenceEqual(bPaymentDetails, new PaymentDetailComparer());

            Assert.IsFalse(equalAB);
        }
        public void ShouldNavigateMaze()
        {
            var expectedPath = new[]
                                   {
                                       CreatePath(1),
                                       CreatePath(4),
                                       CreatePath(7),
                                       CreatePath(6),
                                       CreatePath(5),
                                       CreatePath(4),
                                       CreatePath(8),
                                       CreatePath(9),
                                       CreatePath(8),
                                       CreatePath(10)
                                   };

            var path = new List<string>();

            var configuration = HttpHostConfiguration.Create()
                .SetResourceFactory((type, instanceContext, request) => new RoomResource(Maze.NewInstance(), Monsters.NullEncounters()), (instanceContext, obj) => { });

            // Workaround for serialization issue in Preview 4.
            // Must clear default XML formatter from Formatters before adding Atom formatter.
            var hostConfiguration = (HttpHostConfiguration) configuration;
            hostConfiguration.OperationHandlerFactory.Formatters.Clear();
            hostConfiguration.OperationHandlerFactory.Formatters.Insert(0, AtomMediaType.Formatter);

            using (var host = new HttpConfigurableServiceHost(typeof(RoomResource), configuration, new Uri("http://" + Environment.MachineName + ":8081/rooms/")))
            {
                host.Open();

                var moveCount = 0;
                var client = AtomClient.CreateDefault();

                IApplicationState state = new Started(new Uri("http://" + Environment.MachineName + ":8081/rooms/1"), ApplicationStateInfo.WithEndurance(5));
                while (!state.IsTerminalState && moveCount++ < 20)
                {
                    state = state.NextState(client);
                    if (state.GetType().Equals(typeof (Exploring)))
                    {
                        path.Add(state.CurrentResponse.RequestMessage.RequestUri.AbsoluteUri);
                    }
                }

                Assert.IsInstanceOf(typeof (GoalAchieved), state);
                Assert.IsTrue(path.SequenceEqual(expectedPath));

                host.Close();
            }
        }
        public void DefaultSortMethodSortsProperFirstByScoreSecondByName()
        {
            DefaultSort sorter = new DefaultSort();

            IPlayer first = new Player("Ivan", 2);
            IPlayer second = new Player("Angel", 1);
            IPlayer third = new Player("Angus", 1);

            IList<IPlayer> inputPlayers = new List<IPlayer> { first, third, second };

            IList<IPlayer> expectedPlayers = new List<IPlayer> { first, second, third };

            IList<IPlayer> actualPlayers = sorter.Sort(inputPlayers);

            Assert.IsTrue(expectedPlayers.SequenceEqual(actualPlayers), "The expected and the result lists of sorted Players are NOT equal!");
        }
        public void CanSetComponentExecutionOrder()
        {
            var updateOrder = new List<int>();
            DualityApp.AppData = new DualityAppData();
            Scene.SetComponentExecutionOrder(typeof(ComponentTwo), typeof(ComponentThree), typeof(ComponentOne));

            var gameObject = new GameObject();
            gameObject.AddComponent(new ComponentOne(updateOrder));
            gameObject.AddComponent(new ComponentTwo(updateOrder));
            gameObject.AddComponent(new ComponentThree(updateOrder));

            Scene.Current.AddObject(gameObject);
            Scene.Current.Update();

            Assert.True(updateOrder.SequenceEqual(new[] { 2, 3, 1 }));
        }
        public void ComponentsAreDeactivatedInExecutionOrder()
        {
            var updateOrder = new List<int>();
            var deactivationOrder = new List<int>();

            DualityApp.AppData = new DualityAppData();
            Scene.SetComponentExecutionOrder(typeof(ComponentTwo), typeof(ComponentOne), typeof(ComponentThree));

            var gameObject = new GameObject();
            gameObject.AddComponent(new ComponentOne(updateOrder, deactivationOrder));
            gameObject.AddComponent(new ComponentFour(updateOrder, deactivationOrder));

            Scene.Current.AddObject(gameObject);
            gameObject.Active = false;

            Assert.IsTrue(deactivationOrder.SequenceEqual(new[] { 1, 4 }));
        }
        public void UnspecifiedComponentsRunLastAndInTheOrderTheyWereAdded()
        {
            var updateOrder = new List<int>();
            DualityApp.AppData = new DualityAppData();
            Scene.SetComponentExecutionOrder(typeof(ComponentTwo), typeof(ComponentOne));

            var gameObject = new GameObject();
            gameObject.AddComponent(new ComponentOne(updateOrder));
            gameObject.AddComponent(new ComponentTwo(updateOrder));
            gameObject.AddComponent(new ComponentFour(updateOrder));
            gameObject.AddComponent(new ComponentThree(updateOrder));

            Scene.Current.AddObject(gameObject);
            Scene.Current.Update();

            Assert.True(updateOrder.SequenceEqual(new[] { 2, 1, 4, 3 }));
        }
Example #30
0
 public void AddRange()
 {
     var collection = new List<int>();
     // Adds and returns the number of added items
     Assert.AreEqual(4, Extensions.AddRange(collection, new[] { 0, 1, 2, 3 }));
     Assert.AreEqual(4, collection.Count);
     // Adds and allows to iterate over the items as they are added
     Assert.IsTrue(collection.AddRangeEnumerable(new[] { 10, 20, 30 }).SequenceEqual(new[] { 10, 20, 30 }));
     var count = collection.Count;
     Assert.AreEqual(7, count);
     foreach (var item in collection.AddRangeEnumerable(new[] { 100, 200, 300 }))
     {
         GC.KeepAlive(item);
         count++;
         Assert.AreEqual(count, collection.Count);
     }
     Assert.IsTrue(collection.SequenceEqual(new[] { 0, 1, 2, 3, 10, 20, 30, 100, 200, 300 }));
 }