Example #1
0
        private void PrintDescrepancies(List<Discrepancy> allDescrepancies)
        {
            if (allDescrepancies.Count < 1)
            {
                _logger.Info("No discrepancies between expected and actual results");
                return;
            }

            IEnumerable<Discrepancy> missingPages = allDescrepancies.Where(d => d.DiscrepencyType == DiscrepencyType.MissingPageFromResult);
            IEnumerable<Discrepancy> unexpectedPages = allDescrepancies.Where(d => d.DiscrepencyType == DiscrepencyType.UnexpectedPageInResult);
            IEnumerable<Discrepancy> unexpectedHttpStatusPages = allDescrepancies.Where(d => d.DiscrepencyType == DiscrepencyType.UnexpectedHttpStatus);

            foreach (Discrepancy discrepancy in missingPages)
            {
                _logger.InfoFormat("Missing:[{0}][{1}]", discrepancy.Expected.Url, discrepancy.Expected.HttpStatusCode);
            }
            foreach (Discrepancy discrepancy in unexpectedHttpStatusPages)
            {
                _logger.InfoFormat("Unexpected Http Status: [{0}] Expected:[{1}] Actual:[{2}]", discrepancy.Actual.Url, discrepancy.Expected.HttpStatusCode, discrepancy.Actual.HttpStatusCode);
            }
            foreach(Discrepancy discrepancy in unexpectedPages)
            {
                _logger.InfoFormat("Unexpected Page:[{0}][{1}]", discrepancy.Actual.Url, discrepancy.Actual.HttpStatusCode);
            }
        }
        public void FixStartAndEnd()
        {
            // Use a known date for the start of the set
            var startOfSet = DateTime.Now;
            var events = new List<LongLineSetHaulEvent>()
            {
                new LongLineSetHaulEvent()
                {
                    Sethaul = "S",
                    LogDate = startOfSet
                },
                new LongLineSetHaulEvent()
                {
                    Sethaul = "S",
                    LogDate = startOfSet.AddMinutes(5)
                },
                new LongLineSetHaulEvent()
                {
                    Sethaul = "H",
                    LogDate = startOfSet.AddMinutes(10)
                },
                new LongLineSetHaulEvent()
                {
                    Sethaul = "H",
                    LogDate = startOfSet.AddMinutes(15)
                }
            };

            LongLineSetHaulEvent.SetStartAndEnd(events);
            Assert.AreEqual(0, events.Where(e => !e.ActivityType.HasValue).Count());
            Assert.AreEqual(startOfSet, events.Where(e => HaulActivityType.StartOfSet.Equals(e.ActivityType)).First().LogDate.Value);
        }
Example #3
0
 public void MultipleSixSidedDiceRollsAreInCorrectRangeTest()
 {
     IDie sixSided = new SixSidedDie();
     int i = 0;
     List<int> totals = new List<int>();
     while (i < 1000)
     {
         int total = 0;
         for (int a = 0; a < 3; a++)
         {
             // Thread.Sleep(10);
             total += SixSidedDie.staticDieRoll;
         }
         totals.Add(total);
         i++;
     }
     List<int> totalsCount = new List<int>();
     for (int j = 0; j < 18; j++)
     {
         Console.WriteLine(string.Format("The number {0} has come up {1} time(s)", j, totals.Where(x => x == j).Count()));
         totalsCount.Add(totals.Where(x => x == j).Count());
     }
     Console.WriteLine(string.Join(",", totalsCount.ToArray()));
     string blah = string.Empty;
     //List<SixSidedDie> diceSet = new List<SixSidedDie>
     //{
     //    new SixSidedDie(),
     //    new SixSidedDie(),
     //    new SixSidedDie()
     //};
     //Assert.That(diceSet[0].DieRoll, Is.InRange(1, 6));
     //Assert.That(diceSet[1].DieRoll, Is.InRange(1, 6));
     //Assert.That(diceSet[2].DieRoll, Is.InRange(1, 6));
 }
Example #4
0
    public void SortTest ()
    {            
      IChannel fakeIChannel = Isolate.Fake.Instance<IChannel>();

      Card fakeCard1 =  Isolate.Fake.Instance<Card>();
      Isolate.WhenCalled(() => fakeCard1.Priority).WillReturn(3);

      Card fakeCard2 = Isolate.Fake.Instance<Card>();
      Isolate.WhenCalled(() => fakeCard2.Priority).WillReturn(2);

      Card fakeCard3 = Isolate.Fake.Instance<Card>();
      Isolate.WhenCalled(() => fakeCard3.Priority).WillReturn(1);

      var cardDetails = new List<CardDetail>();
      var card = new CardDetail(1, fakeCard1, fakeIChannel, false, 0);
      cardDetails.Add(card);
      card = new CardDetail(2, fakeCard2, fakeIChannel, false, 0);
      cardDetails.Add(card);
      card = new CardDetail(3, fakeCard3, fakeIChannel, true, 1);
      cardDetails.Add(card);

      cardDetails.Sort();

      List<CardDetail> freeCards =
          cardDetails.Where(t => t.NumberOfOtherUsers == 0 || (t.NumberOfOtherUsers > 0 && t.SameTransponder)).ToList();
      List<CardDetail> availCards = cardDetails.Where(t => t.NumberOfOtherUsers > 0 && !t.SameTransponder).ToList();
    }
        public void AcceptsWithExportTypeMatchesImportType()
        {
            var types = new List<TypeDefinition>();
            var createTypeIdentity = IdentityFactory(types, new Dictionary<Type, TypeIdentity>());

            var repository = new Mock<ISatisfyPluginRequests>();
            {
                repository.Setup(r => r.IdentityByName(It.IsAny<string>()))
                    .Returns<string>(n => types.Where(t => t.Identity.AssemblyQualifiedName.Equals(n)).Select(t => t.Identity).FirstOrDefault());
                repository.Setup(r => r.TypeByIdentity(It.IsAny<TypeIdentity>()))
                    .Returns<TypeIdentity>(id => types.Where(t => t.Identity.Equals(id)).FirstOrDefault());
                repository.Setup(r => r.IsSubTypeOf(It.IsAny<TypeIdentity>(), It.IsAny<TypeIdentity>()))
                    .Returns<TypeIdentity, TypeIdentity>((parent, child) => IsSubTypeOf(types, parent, child));
            }

            var importEngine = new PartImportEngine(repository.Object);

            var importDefinition = PropertyBasedImportDefinition.CreateDefinition(
                "A",
                createTypeIdentity(typeof(int)),
                ImportCardinality.ExactlyOne,
                true,
                CreationPolicy.NonShared,
                typeof(string).GetProperty("Length"),
                createTypeIdentity);
            var exportDefinition = PropertyBasedExportDefinition.CreateDefinition(
                "A",
                typeof(string).GetProperty("Length"),
                createTypeIdentity);

            Assert.IsTrue(importEngine.Accepts(importDefinition, exportDefinition));
        }
        private static List<string> OrderNumbersYearwise(List<string> numbers)
        {
            var yearOrderedNumbers = new List<string>();
            foreach (var number in numbers)
            {
                if (int.Parse(number) > 31) {
                    yearOrderedNumbers.Add(number);
                }
            }
            yearOrderedNumbers.AddRange(numbers.Where(n => int.Parse(n) <= 31));

            var monthOrderedNumbers = new List<string>();

            if (numbers.Any((n => int.Parse(n) > 31)))
            {
                foreach (var number in yearOrderedNumbers)
                {
                    if (int.Parse(number) > 12)
                        monthOrderedNumbers.Add(number);
                }
            }

            monthOrderedNumbers.AddRange(numbers.Where(n => int.Parse(n) <= 12));

            return monthOrderedNumbers;
        }
Example #7
0
        public void Using_linq()
        {
            IList<Product> products = new List<Product>();

            products
                .Where(p => p.Manufacturer == "Rossom");

            products
                .Where(p => p.ReleaseDate <= DateTime.Now);
        }
Example #8
0
        public void Test()
        {
            // Arrange
              var list = new List<Player>();

              // Quarterbacks
              for (var i = 0; i < 20; i++)
              {
            var player = GeneratePlayer(30, 40, "Quarterback");
            list.Add(player);
              }

              // Runnigbacks
              for (var i = 0; i < 20; i++)
              {
            var player = GeneratePlayer(10, 20, "Runningback");
            list.Add(player);
              }

              // Kickers
              for (var i = 0; i < 20; i++)
              {
            var player = GeneratePlayer(1, 2, "Kicker");
            list.Add(player);
              }

              // Act
              var results = new List<Player>();
              for (var i = 0; i < 40; i++)
              {
            var player = _sut.Choose(list);
            player.Position = i + 1;

            results.Add(player);
            list.Remove(player);
              }

              // Assert
              var quarterBacks = results.Where(x => x.PlayerType == "Quarterback").ToList();
              var runnigBacks = results.Where(x => x.PlayerType == "Runningback").ToList();
              var kickers = results.Where(x => x.PlayerType == "Kicker").ToList();
              quarterBacks.Count().ShouldBeGreaterThanOrEqualTo(runnigBacks.Count());
              runnigBacks.Count().ShouldBeGreaterThanOrEqualTo(kickers.Count());

              var topTenQuarterbacks = quarterBacks.Count(x => x.Position <= 10);
              var topTenRunningbacks = runnigBacks.Count(x => x.Position <= 10);
              var topTenKickers = kickers.Count(x => x.Position <= 10);
              topTenQuarterbacks.ShouldBeGreaterThan(topTenRunningbacks);
              topTenRunningbacks.ShouldBeGreaterThanOrEqualTo(topTenKickers);
        }
Example #9
0
		public void ColorChange_Should_SpanColorRange(ActionParams actionData)
		{
			var sut = new LedWrapper ();

			var result = sut.GetActionOutput (actionData);

			// detemining that ColorChange spans color range uniformly is tricky because of dynamic precision in C++ code
			// Instead, verify that increments happen uniformly and that start, middle and end colors are correct

			result [0].Should ().Be (actionData.colorFrom);
			result [actionData.effectiveResultsCount / 2].MaxDifference (actionData.colorFrom.MoveCloserTo (actionData.colorTo, 0.5)).Should ().BeLessOrEqualTo (2, "Middle color can be different only by a small margin");
			result [actionData.effectiveResultsCount - 1].Should ().Be (actionData.colorTo);

			List<int> diffs = new List<int> ();
			for (int i = 1; i < actionData.effectiveResultsCount; i++) 
			{
				var delta = result [i].MaxDifference (result [i - 1]);
				diffs.Add (delta);
			}
			var notNullDiffs = diffs.Where (i => i != 0).ToList();
			(notNullDiffs.Average() - notNullDiffs.Max()).Should ().BeLessThan (2, "Color increments should be uniform and can vary only due to rounding errors"); 
			(notNullDiffs.Average() - notNullDiffs.Min()).Should ().BeLessThan (2);

			var minDifferentValuesCount = actionData.duration / (Math.Max (actionData.tickLength, 32)); // precision is never less than 32ms
			notNullDiffs.Count.Should ().BeGreaterOrEqualTo (Math.Min(actionData.colorTo.MaxDifference(actionData.colorFrom) / 2, minDifferentValuesCount - 2));
		}
        public static void AssertFieldsAreNotNull( Controller controller )
        {
            var allReadOnlyFields = new List<FieldInfo>();

            Type controllerType = controller.GetType();
            while ( controllerType != null )
            {
                var fields =
                    controllerType
                        .GetFields( BindingFlags.NonPublic | BindingFlags.Instance )
                        .Where( x => x.IsInitOnly );
                allReadOnlyFields.AddRange( fields );
                controllerType = controllerType.BaseType;
            }

            var fieldsWithNullValue = allReadOnlyFields
                .Where( x => x.GetValue( controller ) == null )
                .ToList();

            if ( fieldsWithNullValue.Count > 0 )
            {
                Console.WriteLine( "The Following " + fieldsWithNullValue.Count + " fields are not set" );
                fieldsWithNullValue.ForEach( x => Console.WriteLine( x.Name ) );
                Assert.Fail();
            }
        }
        public void can_compare_model_and_entity()
        {
            ISingleCriterionBuilder<TestSearchModel, IMakesSound> criteria =
                new ListPropertyCriteria<TestSearchModel,IMakesSound> ( x => x.Says );

            var model = new TestSearchModel {
                Says = new List<string> {
                    new Cat().Says,
                    new Person().Says
                }
            };

            var list = new List<IMakesSound> {
                new Person (),
                new Dog (),
                new Cat ()
            };

            Assert.That ( criteria.CanProvideExpression (model));

            var expr = criteria.GetPredicateExpression (model).Compile ();
            var filtered = list.Where(expr).ToList ();

            Assert.That(filtered.Count, Is.EqualTo(2));
            Assert.That(filtered.Count(x => x is Dog), Is.EqualTo(0));
        }
Example #12
0
 public static void FailOnNegatives(List<int> numbers)
 {
     var negatives = numbers.Where(n => n < 0).ToList();
     if (negatives.Any())
         throw new ArgumentException(
             "negatives not allowed: " + string.Join(", ", negatives));
 }
        public void Calculate_When1DiscountAppliesMoreThanOnceAndThereAreAdditionalDiscountableItems_ReturnsCorrectCost()
        {
            const decimal expected = 1m;
            var products = new List<Product>
            {
                new Product {Id = 1, Name = "Butter", UnitPrice = 0.80m},
                new Product {Id = 1, Name = "Butter", UnitPrice = 0.80m},
                new Product {Id = 1, Name = "Butter", UnitPrice = 0.80m},
                new Product {Id = 1, Name = "Butter", UnitPrice = 0.80m},
                new Product {Id = 3, Name = "Bread", UnitPrice = 1.00m},
                new Product {Id = 3, Name = "Bread", UnitPrice = 1.00m},
                new Product {Id = 3, Name = "Bread", UnitPrice = 1.00m},
                new Product {Id = 3, Name = "Bread", UnitPrice = 1.00m},
                new Product {Id = 3, Name = "Bread", UnitPrice = 1.00m},
                new Product {Id = 3, Name = "Bread", UnitPrice = 1.00m},
                new Product {Id = 3, Name = "Bread", UnitPrice = 1.00m},
                new Product {Id = 3, Name = "Bread", UnitPrice = 1.00m}
            };

            _discountOfferRepositoryMock.Setup(m => m.GetDiscountOffers()).Returns(new List<DiscountOffer>
                {
                    new DiscountOffer { ProductBoughtId = 1, NumberToBuy = 2, ProductDiscountedId = 3, PercentageOff = 0.5m }
                });

            var actual = _discountOfferCalculatorService.Calculate(products);

            Assert.That(actual, Is.EqualTo(expected));
            Assert.That(products.Count(p => p.Name == "Bread" && p.Processed) == 2);
            Assert.That(products.Count(p => p.Name == "Bread" && p.Processed == false) == 6);
            Assert.That(products.Where(p => p.Name == "Butter").All(p => p.Processed == false));
        }
Example #14
0
        public void Query_search_will_only_find_default_Putty_result()
        {
            // Arrange
            var plugin = new PuttyPlugin();
            var query = new Query(Keyword + " asdf");

            var fakeSessions = new List<PuttySession>
            {
                new PuttySession { Identifier = "*****@*****.**", Protocol = "ssh", Username = "******", Hostname = "foobar.com" },
                new PuttySession { Identifier = "*****@*****.**", Protocol = "ssh", Username = "******", Hostname = "foobar.com" },
                new PuttySession { Identifier = "*****@*****.**", Protocol = "ssh", Username = "******", Hostname = "muh.com" },
            };
            plugin.PuttySessionService = new FakePuttySessionService { FakeResult = fakeSessions };

            var expectedResult = new List<Result> { _defaultPuttyResultItem };

            // Act
            var result = plugin.Query(query);

            // Assert
            Assert.AreEqual(result.Count, expectedResult.Count);

            foreach (var sessionResult in result)
            {
                Assert.IsNotNull(
                    expectedResult.Where(x => x.Title == sessionResult.Title && x.SubTitle == sessionResult.SubTitle && x.IcoPath == sessionResult.IcoPath));
            }
        }
Example #15
0
        public void CreateTree()
        {
            var bar0 = new Bar(1, null);
            var bar1 = new Bar(2, null);
            var bar0_0 = new Bar(3, 1);
            var bar0_1 = new Bar(4, 1);
            var bar_0_0_0 = new Bar(5, 3);

            var list = new List<Bar>()
                {
                    bar0,
                    bar1,
                    bar0_0,
                    bar0_1,
                    bar_0_0_0
                };

            //Create the tree
            var tree = TreeExtensions.CreateTree(list.Where(b => b.ParentId == null),
                list,
                (p, c) => c.ParentId != null && c.ParentId.Value == p.Id);

            Assert.AreSame(bar0, tree.Nodes[0].Item);

            Assert.AreSame(bar1, tree.Nodes[1].Item);

            Assert.AreSame(bar0_1, tree.Nodes[0].Nodes[1].Item);
        }
Example #16
0
        public void HandleMatchesForPlayerQuery_ShouldReturnMatchesPlayerWasMemberOf()
        {
            // Arrange
            var random = new Random();
            var nzl = setUpHelper.SetUpCountry("New Zealand");
            var aus = setUpHelper.SetUpCountry("Australia");

            setUpHelper.PopulateCountryPlayerPool(nzl.Name);
            setUpHelper.PopulateCountryPlayerPool(aus.Name);

            var matches = new List<Match>();

            for (var i = 0; i < 5 +random.Next(4); i++)
            {
                var matchID = setUpHelper.SetUpMatch(nzl, aus);
                var match = Resolve<IRepository<Match>>().GetById(matchID);
                matches.Add(match);
            }

            var randomMatch = matches.ElementAt(random.Next(matches.Count - 1));
            var selectedPlayerIndex = random.Next(randomMatch.Team1.Members.Count() - 1);
            var selectedPlayer = randomMatch.Team1.Members.ElementAt(selectedPlayerIndex);

            var expectedResult = matches.Where(m => m.Teams.Any(t => t.Members.Contains(selectedPlayer))).ToArray();

            // Act
            var result = queryHandler.Handle(new MatchesForPlayerQuery(selectedPlayer.Id));

            // Assert
            result.Should().BeEquivalentTo(expectedResult);
            result.First().Team1.Members.Should().BeEquivalentTo(expectedResult.First().Team1.Members);
        }
Example #17
0
        public void MatchTest()
        {
            var sources = new List<string>()
            {
                "file open in browser-test",
                "Install Package",
                "add new bsd",
                "Inste",
                "aac",
            };


            var results = new List<Wox.Plugin.Result>();
            foreach (var str in sources)
            {
                results.Add(new Plugin.Result()
                {
                    Title = str,
                    Score = FuzzyMatcher.Create("inst").Evaluate(str).Score
                });
            }

            results = results.Where(x => x.Score > 0).OrderByDescending(x => x.Score).ToList();

            Assert.IsTrue(results.Count == 3);
            Assert.IsTrue(results[0].Title == "Inste");
            Assert.IsTrue(results[1].Title == "Install Package");
            Assert.IsTrue(results[2].Title == "file open in browser-test");
        }
Example #18
0
        public void Roll1000TwentySidedTest()
        {
            StringBuilder resultstring = new StringBuilder();
            List<int> intList = new List<int>();
            resultstring.AppendLine("DieRoll");
            int length = 1000;
            for (int i = 0; i < length; i++)
            {

                TwentySidedDie td = new TwentySidedDie();
                intList.Add(td.DieRoll);
                Thread.Sleep(1000);
            }
            Dictionary<int, int> scoreDict = new Dictionary<int, int>();
            for (int i = 1; i < 21; i++)
            {
                scoreDict[i] = intList.Where(x => x == i).Count();

            }

            StringBuilder header = new StringBuilder();
            StringBuilder row = new StringBuilder();
            foreach (var item in scoreDict)
            {
                header.Append(item.Key + ",");
                row.Append(item.Value + ",");
            }

            using (StreamWriter sr = new StreamWriter("c:/testouput.csv"))
            {
                sr.WriteLine(header.ToString());
                sr.WriteLine(row.ToString());
            }
        }
        public void CanSearchForGamesViaLocationAndSportType()
        {
            var soccer = TestData.CreateSoccerGame();
            var basketball = TestData.CreateBasketballGame();
            var location1 = TestData.CreateLocationBend();
            var location2 = TestData.CreateLocationHamsterville();

            var soccerGame1 = new PickUpGame(DateTime.Now, soccer, location1);
            var soccerGame2 = new PickUpGame(DateTime.Now, soccer, location2);
            var basketballGame = new PickUpGame(DateTime.Now, basketball, location1);

            var listOfGames = new List<PickUpGame> { soccerGame1, soccerGame2, basketballGame };

            var request = new SearchForPickupGameRequest { Location = location1.Name, Sport = soccer.Name };

            _gameRepository.Setup(x => x.FindPickUpGameByLocation(It.Is<string>(d => d == location1.Name)))
                .Returns(listOfGames.Where(x => x.Location == location1.Name).ToList());

            var handler = new SearchForPickupGameRequestHandle(_gameRepository.Object);

            var response = handler.Handle(request);

            Assert.That(response.GamesFound.Count, Is.EqualTo(1));
            Assert.That(response.GamesFound[0].Location, Is.EqualTo(location1.Name));
            Assert.That(response.GamesFound[0].Sport, Is.EqualTo(soccer.Name));
        }
        public void AddIfNotExists_NotAddingExistsItem()
        {
            var source = new List<int> {1, 2, 3};
            source.AddIfNotExist(3);

            var all = source.Where(x => x == 3);
            all.Count().ShouldEqual(1);
        }
            public void Basic()
            {
                var queue = new MediaQueue();

                IList<NotifyCollectionChangedEventArgs> collectionChangedEvents = new List<NotifyCollectionChangedEventArgs>();
                IList<PropertyChangedEventArgs> propertyChangedEvents = new List<PropertyChangedEventArgs>();

                queue.CollectionChanged += (sender, e) => collectionChangedEvents.Add(e);
                queue.PropertyChanged += (sender, e) => propertyChangedEvents.Add(e);

                var tracks = new[]
                    {
                        new MediaFile(),
                        new MediaFile(),
                    };

                queue.Add(tracks[0]);

                Assert.AreEqual(1, queue.Count);
                Assert.AreEqual(tracks[0], queue.Current);
                Assert.AreEqual(0, queue.Index);
                Assert.AreEqual(RepeatType.None, queue.Repeat);
                Assert.AreEqual(false, queue.Shuffle);

                Assert.AreEqual(1, propertyChangedEvents.Where(e => e.PropertyName == "Current").Count());
                Assert.AreEqual(1, propertyChangedEvents.Where(e => e.PropertyName == "Index").Count());
                Assert.AreEqual(1, propertyChangedEvents.Where(e => e.PropertyName == "Count").Count());
                Assert.AreEqual(3, propertyChangedEvents.Count);
                Assert.AreEqual(1, collectionChangedEvents.Where(e => e.NewItems.Count == 1 && e.OldItems == null).Count());
                Assert.AreEqual(1, collectionChangedEvents.Count);

                queue.Add(tracks[1]);

                Assert.AreEqual(2, queue.Count);
                Assert.AreEqual(tracks[0], queue.Current);
                Assert.AreEqual(0, queue.Index);
                Assert.AreEqual(RepeatType.None, queue.Repeat);
                Assert.AreEqual(false, queue.Shuffle);

                Assert.AreEqual(1, propertyChangedEvents.Where(e => e.PropertyName == "Current").Count());
                Assert.AreEqual(1, propertyChangedEvents.Where(e => e.PropertyName == "Index").Count());
                Assert.AreEqual(2, propertyChangedEvents.Where(e => e.PropertyName == "Count").Count());
                Assert.AreEqual(4, propertyChangedEvents.Count);
                Assert.AreEqual(2, collectionChangedEvents.Where(e => e.NewItems.Count == 1 && e.OldItems == null).Count());
                Assert.AreEqual(2, collectionChangedEvents.Count);
            }
Example #22
0
        public void TestNameTest()
        {
            var ints = new List<int> {1, 2, 3, 4, 5, 6};

            var filtered = ints.Where(x => x >= ints.Max() - 2);

            Assert.IsTrue(new[]{4,5,6}.SequenceEqual(filtered));
        }
        public void ConvertIEnumerableToArray()
        {
            var list = new List<int> {1, 2};
            IEnumerable<int> enumerable = list.Where(x => x > 0).AsEnumerable();

            int[] result = enumerable.AsArray();

            Assert.AreEqual(2, result.Length);
        }
Example #24
0
        public void TestUsingStandardLinq()
        {
            var myList = new List<int>();
            myList.AddRange(new [] { 1, 2, 3, 4, 5 });

            var result = myList.Where(x => x > 3);

            Assert.That(result.Count(), Is.EqualTo(2));
        }
Example #25
0
        public void TestUsingPredicate()
        {
            var myList = new List<int>();
            myList.AddRange(new[] { 1, 2, 3, 4, 5 });

            var result = myList.Where(PredicateMethods.GreaterThanThree);

            Assert.That(result.Count(), Is.EqualTo(2));
        }
Example #26
0
        public void Find_Absolute_Urls()
        {
            List<string> urls = new List<string>();
            CssUrlRewriting.RewriteCss(Hollywood_Css, (s) => { urls.Add(s); return s; });

            urls = urls.Where(s => s.IsAbsoluteUrl()).Output();

            Expect(urls.Count, Is.EqualTo(7));
        }
        public void WhereTestCaseNullCheck()
        {
            var target = new List<Int32> { 1, 10, 100, 1000 };
            ISpecification<Int32> specification = null;

            Action test = () => target.Where( specification );

            test.ShouldThrow<ArgumentNullException>();
        }
 public void TestAllWithLinq()
 {
     IList<AnEntity> al = new List<AnEntity>();
     al.Add(new AnEntity("A", "B"));
     al.Add(new AnEntity("C", "B"));
     al.Add(new AnEntity("A", "B"));
     Assert.That(al, MyHas.All.Property("PropertyB", "B"));
     Assert.That(al.Where(e => e.PropertyB == "B").Count(), Is.EqualTo(3));
 }
		public void PrinterConfigTests()
		{
			string staticDataPath = TestContext.CurrentContext.ResolveProjectPath(5, "MatterControl", "StaticData");

			StaticData.Instance = new FileSystemStaticData(staticDataPath);

			var profilesDirectory = new DirectoryInfo(Path.Combine(staticDataPath, "Profiles"));

			foreach (FileInfo file in profilesDirectory.GetFiles("*.printer", SearchOption.AllDirectories))
			{
				var printerSettings = PrinterSettings.LoadFile(file.FullName);

				// Assert that no UserLayer values exist in production .printer files
				Assert.AreEqual(0, printerSettings.UserLayer.Keys.Count, ".printer files should not contain UserLayer values");

				var layersToInspect = new List<PrinterSettingsLayer>();
				layersToInspect.Add(printerSettings.OemLayer);
				layersToInspect.AddRange(printerSettings.MaterialLayers);
				layersToInspect.AddRange(printerSettings.QualityLayers);

				// Validate each PrinterSettingLayer in the .printer file
				foreach (var layer in layersToInspect.Where(l => l.Keys.Any()))
				{
					firstLayerSpeedEqualsAcceptableValue(printerSettings, layer, file.FullName);

					firstLayerHeightLessThanNozzleDiameter(printerSettings, layer, file.FullName);

					layerHeightLessThanNozzleDiameter(printerSettings, layer, file.FullName);

					firstLayerExtrusionWidthAcceptableValue(printerSettings, layer, file.FullName);

					firstLayerExtrusionWidthNotZero(layer, file.FullName);

					bedSizeXYSeparatedByComma(layer, file.FullName);

					printCenterFormatSeparatedByComma(layer, file.FullName);

					testRetractLengthLessThanTwenty(layer, file.FullName);

					testExtruderCountGreaterThanZero(layer, file.FullName);

					minimumFanSpeedLessThanOrEqualToOneHundred(layer, file.FullName);

					maxFanSpeedNotGreaterThanOneHundred(layer, file.FullName);

					noCurlyBracketsInStartGcode(layer, file.FullName);

					noCurlyBracketsInEndGcode(layer, file.FullName);

					testBottomSolidLayersOneMM(layer, file.FullName);

					testFirstLayerTempNotInStartGcode(layer, file.FullName);

					testFirstLayerBedTemperatureNotInStartGcode(layer, file.FullName);
				}
			}
		}
Example #30
0
 private static void VerifyNoNegativeNumbers(List<int> numbers)
 {
     var negativeNumbers = numbers.Where(x => x < 0).ToList();
     if (negativeNumbers.Count > 0)
     {
         var message = "negatives not allowed";
         negativeNumbers.ForEach(x => message += " " + x);
         throw new ArgumentException(message);
     }
 }