public void TestCountValidPassportsStrictValid()
        {
            string[] rawPassports       = PassportValidator.GetInputData(FilePathTestDataStrict);
            int      nuOfValidPassports = PassportValidator.CountValidPassportsStrict(rawPassports);

            Assert.AreEqual(4, nuOfValidPassports);
        }
        public void TestCountValidPassportsEmpty()
        {
            string[] rawPassports       = new string[] { "xx:yy" };
            int      nuOfValidPassports = PassportValidator.CountValidPassports(rawPassports);

            Assert.AreEqual(0, nuOfValidPassports);
        }
        public void TestValidatePassportStrict(int iTestDataPassport, bool expectedValid)
        {
            string[] rawPassports = PassportValidator.GetInputData(FilePathTestDataStrict);
            Dictionary <string, string> parsedPassport = PassportValidator.ParseRawPassport(rawPassports[iTestDataPassport]);
            bool passportValid = PassportValidator.ValidatePassportStrict(parsedPassport);

            Assert.AreEqual(expectedValid, passportValid);
        }
        public void FindAnserDayFourPuzzleOne()
        {
            string[] rawPassports       = PassportValidator.GetInputData(FilePathInputData);
            int      nuOfValidPassports = PassportValidator.CountValidPassports(rawPassports);

            Console.WriteLine("Number of valid passports: " + nuOfValidPassports);
            Assert.AreEqual(228, nuOfValidPassports);
        }
        public void TestParsePassport()
        {
            string[] rawPassports = PassportValidator.GetInputData(FilePathTestData);
            Dictionary <string, string> parsedPassport = PassportValidator.ParseRawPassport(rawPassports[0]);

            Assert.AreEqual(8, parsedPassport.Count);
            Assert.IsTrue(parsedPassport.ContainsKey("ecl"));
            Assert.IsTrue(parsedPassport.ContainsValue("gry"));
        }
        public void FindAnserDayFourPuzzleTwo()
        {
            string[] rawPassports       = PassportValidator.GetInputData(FilePathInputData);
            int      nuOfValidPassports = PassportValidator.CountValidPassportsStrict(rawPassports);

            Console.WriteLine("Number of valid passports: " + nuOfValidPassports);

            // Assert.IsTrue(nuOfValidPassports < 176);
            // Assert.AreEqual(185, nuOfValidPassports);
            Assert.Warn("Not solved");
        }
Esempio n. 7
0
        public static int CountValidPassportsStrict(string[] rawPassports)
        {
            int noOfValidPasswords = 0;

            foreach (string rawPassport in rawPassports)
            {
                Dictionary <string, string> parsedPassport = PassportValidator.ParseRawPassport(rawPassport);
                if (PassportValidator.ValidatePassportStrict(parsedPassport))
                {
                    noOfValidPasswords++;
                }
            }

            return(noOfValidPasswords);
        }
Esempio n. 8
0
        public static bool ValidatePassportStrict(Dictionary <string, string> parsedPassport)
        {
            bool passportIsValid = true;

            // First test with the simple Validator
            if (!PassportValidator.ValidatePassport(parsedPassport))
            {
                passportIsValid = false;
            }

            // Second, invalidate by Regex
            else if (!PassportValidator.ValidatePassportRegex(parsedPassport))
            {
                passportIsValid = false;
            }

            return(passportIsValid);
        }
Esempio n. 9
0
        public int Solve(IEnumerable <string> input, PassportValidator validator)
        {
            var passport = new Passport();

            foreach (var line in input)
            {
                if (line == "")
                {
                    validator.Validate(passport);
                    passport = new Passport();
                }
                else
                {
                    passport.AddLine(line);
                }
            }
            validator.Validate(passport);
            return(validator.Count);
        }
Esempio n. 10
0
        public static bool ValidatePassportRegex(Dictionary <string, string> parsedPassport)
        {
            bool passportIsValid = true;

            // Obtain the passport rules
            // TODO: This sghould only be new once. Maybe make into an instance variable?
            string[] rawPassportTemplateRegex = InputDataHandler.ReadFileAsArray(FilePathPassportRulesRegex, string.Empty);
            Dictionary <string, string> passportTemplateRegex = PassportValidator.ParseRawPassport(rawPassportTemplateRegex[0]);

            // Compare value for a kay with the allowed Regex expression
            // Loop over all template keys in case of an incomplete passport being supplied as argument
            foreach (KeyValuePair <string, string> currentFieldTemplate in passportTemplateRegex)
            {
                // Don't care about cid, skip to checking next field
                // TODO: Refactor to create all passport keys when reading the passport
                if (currentFieldTemplate.Key == "cid")
                {
                    continue;
                }

                string value = string.Empty;
                if (parsedPassport.TryGetValue(currentFieldTemplate.Key, out value))
                {
                    if (!Regex.IsMatch(value, currentFieldTemplate.Value))
                    {
                        passportIsValid = false;

                        // Console.WriteLine("Passport invalidated by: " + currentFieldTemplate.Key + ":" + value);
                    }
                }
                else
                {
                    // If a passport doesn't include the template key it is atomatically invalid
                    // TODO: Handle cid
                    // TODO: Refactor the simple invalidator to use this method?
                    passportIsValid = false;
                }
            }

            return(passportIsValid);
        }
 public void TestGetInputData()
 {
     string[] rawPassports = PassportValidator.GetInputData(FilePathTestData);
     Assert.AreEqual(4, rawPassports.GetLength(0));
 }