protected Product(string name, string brand, decimal price, GenderType genderType)
 {
     this.Name = name;
     this.Brand = brand;
     this.Gender = genderType;
     this.Price = price;
 }

 public Driver(string name, GenderType gender)
 {
     this.id = DataGenerator.GenerateId();
     this.Name = name;
     this.Gender = gender;
     this.vehicles = new List<IMotorVehicle>();
 }

        private static List<RawCompetitor> CreateRawCompetitor(string[] names, List<RawCompetitor> competitorsRaw, BrokerType brokerType, LanguageType languageType, SportType sportType, GenderType genderType)
        {
            var existNames = competitorsRaw.Select(cr => cr.Name).ToList();
            names = names
                .Where(name => !existNames.Contains(name))
                .ToArray();
            if (names.Any()) {
                var lastCompetitorUniqueID = competitorsRaw.Any()
                    ? competitorsRaw.First().CompetitoruniqueID
                    : default(int);
                var raw = competitorsRaw;
                names
                    .Where(name => !raw.Any(c => c.Name.Equals(name, StringComparison.InvariantCultureIgnoreCase)))
                    .Each(name => {
                        RawCompetitor competitorRaw = null;
                        try {
                            competitorRaw = BrokerEntityIfaceCreator.CreateEntity<RawCompetitor>(brokerType, languageType, sportType, genderType, LinkEntityStatus.Unlinked, new[] { name },
                                competitor => {
                                    if (lastCompetitorUniqueID != default(int)) {
                                        competitor.CompetitoruniqueID = lastCompetitorUniqueID;
                                        competitor.Linkstatus = LinkEntityStatus.LinkByStatistics | LinkEntityStatus.Linked;
                                    }
                                });
                            competitorRaw.Save();
                            raw.Add(competitorRaw);
                        } catch (Exception ex) {
                            _logger.Error("{0}\r\n{1}", competitorRaw?.ToString(), ex);
                            throw;
                        }
                    });
            }

            return competitorsRaw;
        }

        public Toothpaste(string name, string brand, decimal price, GenderType gender, IList<string> ingredients)
            : base(name, brand, price, gender)
        {
            this.IngredientsList = ingredients;

            this.Ingredients = string.Join(", ", this.IngredientsList);
        }

 public Shampoo(string name, string brand, decimal price, GenderType gender, uint milliliters, UsageType usage)
     : base(name, brand, price, gender)
 {
     this.Milliliters = milliliters;
     this.Usage = usage;
     this.Price *= this.Milliliters;
 }

 public User(string name, string password)
 {
     this.name = name;
     this.password = password;
     this.sex = GenderType.MALE;
     this.chars = new Dictionary<byte, List<uint>>();
 }

 protected Product(string name, string brand, decimal price, GenderType gender)
 {
     Name = name;
     Brand = brand;
     Price = price;
     Gender = gender;
 }

 private static List<RawCompetitor> GetRawCompetitorInt(BrokerType brokerType, LanguageType languageType, SportType sportType, GenderType genderType, string[] names)
 {
     if (genderType == GenderType.Unknown) {
         _logger.Error("{0}: {1}", names.StrJoin(", "), genderType);
     }
     var competitorsRaw = RawCompetitor.DataSource.FilterByLanguage(languageType).FilterBySportType(sportType).FilterByBroker(brokerType)
                                         .FilterByNameCompetitor(names)
                                         .FilterByGender(genderType,
                 RawCompetitor.Fields.CompetitoruniqueID,
                 RawCompetitor.Fields.Name,
                 RawCompetitor.Fields.Linkstatus);
     if (competitorsRaw.Count > 1) {
         var groupBy = competitorsRaw.Where(c => c.CompetitoruniqueID != default(int)).GroupBy(c => c.CompetitoruniqueID).ToArray();
         if (groupBy.Length > 1) {
             _logger.Error("{0} {1} {2} {3} {4} <=> {5}", brokerType, sportType, genderType,
                 competitorsRaw.Select(cr => cr.ID).StrJoin(", "), names.StrJoin(", "), groupBy.Select(g => g.Select(ge => ge.Name).StrJoin(", ")).StrJoin(" | "));
             return groupBy.First().ToList();
         }
         if (groupBy.Length == 1) {
             foreach (var rawCompetitor in competitorsRaw.Where(cr => cr.CompetitoruniqueID == default(int))) {
                 rawCompetitor.CompetitoruniqueID = groupBy[0].Key;
                 rawCompetitor.Save();
             }
         }
     }
     return CreateRawCompetitor(names, competitorsRaw, brokerType, languageType, sportType, genderType);
 }

 public Honorific(string name, string abbreviation, GenderType genderType, HonorificType type)
 {
     Name = name;
       Abbreviation = abbreviation;
       GenderType = genderType;
       Type = type;
 }

 public Employee(string employeeID,
     string firstName,
     string middleName,
     string lastName,
     string jobTitle,
     GenderType gender,
     MaritalStatusType maritalStatus,
     DateTime birthDate,
     DateTime hireDate,
     string homePone,
     string workPhone,
     decimal salary,
     Department department)
     : base()
 {
     this.EmployeeID = employeeID;
     this.FirstName = firstName;
     this.LastName = lastName;
     this.Gender = gender;
     this.MaritalStatus = maritalStatus;
     this.JobTitle = jobTitle;
     this.BirthDate = birthDate;
     this.HireDate = hireDate;
     this.HomePhone = homePone;
     this.WorkPhone = workPhone;
     this.Salary = salary;
     this.Department = department;
 }

 public Driver(string name, GenderType gender)
     : base()
 {
     this.name = name;
     this.gender = gender;
     this.vehicles = new List<IMotorVehicle>();
 }

 public Product(string name, string brand, decimal price, GenderType gender)
 {
     this.Name = name;
     this.Brand = brand;
     this.Price = price;
     this.Gender = gender;
 }

        public Toothpaste(string name, string brand, decimal price, GenderType gender, IList<string> ingredientsList)
            :base(name, brand, price, gender)
        {
            this.ingredientList = ingredientsList;

            ValidationListOfIngredients(ingredientsList);
        }

        public void ParseGenderType_ReturnsCorrectString(GenderType genderType, string expected)
        {
            //act
            var result = EnumFactory.ParseGenderType(genderType);

            //assert
            result.Should().Be(expected);
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="genderType"></param>
        /// <returns></returns>
        public string FirstName(GenderType genderType = GenderType.Any)
        {
            var firstNames = _data.FirstNames.ToList();
              if (genderType != GenderType.Any)
            return Pick(firstNames.Where(x => x.GenderType == genderType).ToList()).Name;

              return Pick(firstNames).Name;
        }

 public ICreature CreateEnemy(string name, GenderType gender)
 {
     return new Enemy(
         name,
         Enemy.InitialEnemyAttack,
         Enemy.InitialEnemyHealth,
         gender);
 }

 /// <summary>
 /// instantiate a guest and set intial properties
 /// </summary>
 /// <param name="name">guest name</param>
 /// <param name="gender">guest gender</param>
 /// <param name="race">guest race</param>
 /// <param name="currentRoomNumber">room location as an index of the hall array</param>
 public Staff(
     string name,
     GenderType gender,
     RaceType race,
     int currentRoomNumber)
     : base(name, gender, race, currentRoomNumber)
 {
 }

        public void EnumHelper_Parse_ReturnsCorrectEnum(string value, GenderType genderType)
        {
            //act
            var result = EnumHelper<GenderType>.Parse(value);

            //assert
            result.Should().Be(genderType);
        }

 public IToothpaste CreateToothpaste(
     string name, 
     string brand, 
     decimal price, 
     GenderType gender, 
     IList<string> ingredients)
 {
     return new Toothpaste(name, brand, price, gender, ingredients);
 }

        public Shampoo(string name, string brand, decimal price, uint mililiters, GenderType gender, UsageType usageType)
            : base(name, brand, price, gender)
        {
            Validator.CheckIfNull(mililiters, string.Format(GlobalErrorMessages.ObjectCannotBeNull, "Mililiters"));
            Validator.CheckIfNull(usageType, string.Format(GlobalErrorMessages.ObjectCannotBeNull, "UsageType"));

            this.Usage = usageType;
            this.Milliliters = mililiters;
        }