public void CtorParametersAreInitialized(IFixture fixture, Name name)
 {
     fixture.Inject<IParameter>(new ParameterTest());
     fixture.Inject<ParameterMeta>(ParameterMeta.Create<IParameter>(name));
     var assertion = new ConstructorInitializedMemberAssertion(fixture);
     assertion.Verify(typeof(CmdApplicationConfiguration));
 }

 public void NullForCtorArgumentsThrowsException(IFixture fixture, Name name)
 {
     fixture.Inject<IParameter>(new ParameterTest());
     fixture.Inject<ParameterMeta>(ParameterMeta.Create<IParameter>(name));
     var assertion = new GuardClauseAssertion(fixture);
     assertion.Verify(typeof(CmdApplicationConfiguration).GetConstructors());
 }

		public FormalTypeParam(Position position, Name name, object defaultType, List<CustomAttribute> attributes)
			: base(position)
		{
			this.name = name;
			this.defaultType = defaultType;
			this.attributes = new CustomAttributes(attributes);
		}

        public static IEnumerable<Pair<Name, Name>> GetTerms(Name n1, Name n2, bool allowPartial)
        {
            if (!(allowPartial || n1.NumberOfTerms == n2.NumberOfTerms))
                return null;

            return n1.GetTerms().Zip(n2.GetTerms(), Tuples.Create);
        }

			public Expectation(Name expectedName, LeafIndex expectedLeafIndex)
			{
				Contract.Requires(expectedName != null);

				ExpectedName = expectedName;
				ExpectedLeafIndex = expectedLeafIndex;
			}

 public override BaseEvent SwapPerspective(Name oldPerspective, Name newPerspective)
 {
     Property = Property.SwapTerms(oldPerspective, newPerspective);
     NewValue = NewValue.SwapTerms(oldPerspective, newPerspective);
     base.SwapPerspective(oldPerspective, newPerspective);
     return this;
 }

 public override BaseEvent SwapPerspective(Name oldPerspective, Name newPerspective)
 {
     Action = Action.SwapTerms(oldPerspective, newPerspective);
     Target = Target.SwapTerms(oldPerspective, newPerspective);
     base.SwapPerspective(oldPerspective, newPerspective);
     return this;
 }

        public void Be_Able_To_Parse_A_Given_Line_To_A_Name_Model()
        {
            var expected = new Name
            {
                MutKod = MutKod.RecordNotChanged,
                NmNr = 2,
                NmMemo = "ABBOI2",
                NmEtiket = "ABBOKINASE 250.000IE INJPDR",
                NmNm40 = "ABBOKINASE",
                NmNaam = "ABBOKINASE INJECTIEPOEDER FLACON 250.000IE"
            };

            const string data =
                @"002000000002ABBOI2ABBOKINASE 250.000IE INJPDRABBOKINASE                              ABBOKINASE INJECTIEPOEDER FLACON 250.000IE        0000000000000000000000000";

            byte[] dataBytes = Encoding.UTF8.GetBytes(data);
            var memoryStream = new MemoryStream(dataBytes);
            var serializer = new GStandardFileSerializer<Name>();
            var lines = serializer.ReadLines(memoryStream);

            var model = lines.FirstOrDefault();
            Assert.IsNotNull(model);
            Assert.AreEqual(expected.MutKod, model.MutKod);
            Assert.AreEqual(expected.NmEtiket, model.NmEtiket);
            Assert.AreEqual(expected.NmMemo, model.NmMemo);
            Assert.AreEqual(expected.NmNaam, model.NmNaam);
            Assert.AreEqual(expected.NmNm40, model.NmNm40);
            Assert.AreEqual(expected.NmNr, model.NmNr);
        }

 public AppraisalRule(Name eventName, ConditionSet conditions = null)
 {
     m_id = Guid.NewGuid();
     EventName = eventName;
     Conditions = conditions ?? new ConditionSet();
     Desirability = Praiseworthiness = 0;
 }

		public static Brush getBrush(Name name, int num = 4)
		{
			var converter = new System.Windows.Media.BrushConverter();

			switch(name)
			{
				case Name.Red:			return (Brush)converter.ConvertFromString(RED[num]);
				case Name.Pink:			return (Brush)converter.ConvertFromString(PINK[num]);
				case Name.Purple:		return (Brush)converter.ConvertFromString(PURPLE[num]);
				case Name.DeepPurple:	return (Brush)converter.ConvertFromString(DEEP_PURPLE[num]);
				case Name.Indigo:		return (Brush)converter.ConvertFromString(INDIGO[num]);
				case Name.Blue:			return (Brush)converter.ConvertFromString(BLUE[num]);
				case Name.LightBlue:	return (Brush)converter.ConvertFromString(LIGHT_BLUE[num]);
				case Name.Cyan:			return (Brush)converter.ConvertFromString(CYAN[num]);
				case Name.Teal:			return (Brush)converter.ConvertFromString(TEAL[num]);
				case Name.Green:		return (Brush)converter.ConvertFromString(GREEN[num]);
				case Name.LightGreen:	return (Brush)converter.ConvertFromString(LIGHT_GREEN[num]);
				case Name.Lime:			return (Brush)converter.ConvertFromString(LIME[num]);
				case Name.Yellow:		return (Brush)converter.ConvertFromString(YELLOW[num]);
				case Name.Amber:		return (Brush)converter.ConvertFromString(AMBER[num]);
				case Name.Orange:		return (Brush)converter.ConvertFromString(ORANGE[num]);
				case Name.DeepOrange:	return (Brush)converter.ConvertFromString(DEEP_ORANGE[num]);
				case Name.Brown:		return (Brush)converter.ConvertFromString(BROWN[num]);
				case Name.Grey:			return (Brush)converter.ConvertFromString(GREY[num]);
				case Name.BlueGrey:		return (Brush)converter.ConvertFromString(BLUE_GREY[num]);
				case Name.Black:		return (Brush)converter.ConvertFromString("#FF000000");
			}

			return (Brush)converter.ConvertFromString("#FFFFFFFF");
		}

        public void Two_objects_with_the_same_names_should_be_equal(string lastName, string firstName)
        {
            var nameInstanceOne = new Name(lastName, firstName);
            var nameInstanceTwo = new Name(lastName, firstName);

            Assert.Equal(nameInstanceOne, nameInstanceTwo);
        }

		internal NodeStatusRequest(Name name)
		{
			QuestionName = name;
			QuestionType = Nbstat;
			IsRecurDesired = false;
			IsBroadcast = false;
		}

 public void WriteQuestion(Name name, RecordType qtype, RecordClass qclass = RecordClass.Internet)
 {
     WriteName(name);
     WriteUInt16((ushort)qtype);
     WriteUInt16((ushort)qclass);
     _questionCount++;
 }

 /* Also illustrates some String methods.
 */
 public static void Main()
 {
     Name aName = new Name("Henry", "Johnson");
     Address anAddress =
     new Address("1512 Harbor Blvd.", "Long Beach",
                         "CA", "99919");
     Console.Write("Enter an id string: ");
     String anId = Console.ReadLine();
     Person aPerson = new Person(anId,aName,anAddress);
     Console.WriteLine("Our person is ");
     Console.WriteLine(aPerson);
     Console.WriteLine("   with id {0}", aPerson.GetId());
     Console.WriteLine
        ("\n And now some tests using string methods");
     String address = anAddress.ToString();
     int i = address.IndexOf("Harbor");
     Console.WriteLine
        ("The index of Harbor in address is {0}", i);
     String z1 = "99919";
     int lenth = address.Length;
     Console.WriteLine("The length of address is {0}", l);
     String z2 = address.Substring(lenth-5,5);
     bool same = z2.Equals(z1);
     Console.WriteLine
         ("These two zip codes are the same? {0}", same);
     int less = z1.CompareTo("Harbor");
     Console.WriteLine("Compare returns {0}", less);
     String hat = "   hat   ";
     Console.WriteLine(hat+"rack");
     Console.WriteLine(hat.Trim() + "rack");
 }

 private string GetNameByEnum(Name name)
 {
     string result;
     switch (name)
     {
         case Name.DCS:
             result = "DCS";
             break;
         case Name.班次:
             result = "班次";
             break;
         case Name.报警周期:
             result = "报警周期";
             break;
         case Name.电表:
             result = "电表";
             break;
         case Name.峰谷平:
             result = "峰谷平";
             break;
         case Name.公共公式:
             result = "公共公式";
             break;
         case Name.公式:
             result = "公式";
             break;
         case Name.水泥品种:
             result = "水泥品种";
             break;
         default:
             result = "";
             break;
     }
     return result;
 }

 public void SutWithSameValuesAreEqual(Name name)
 {
     var aParameter = new NameOnlyParameter(name);
     var anotherParameter = new NameOnlyParameter(name);
     Assert.Equal(aParameter, anotherParameter);
     Assert.Equal(aParameter.GetHashCode(), anotherParameter.GetHashCode());
 }

 private FixedSchema(Name name, int size, Names names)
     : base(Type.FIXED, name, names)
 {
     if (size <= 0) throw new ArgumentOutOfRangeException("size", "size must be greater than zero.");
     
     this.size = size;
 }

 /// <summary>
 /// constructor accepting a string for the key
 /// </summary>
 /// <param name="type"></param>
 /// <param name="name"></param>
 /// <param name="keyString"></param>
 public SecurityKey(Type type, Name name, string keyString)
 {
     KeyBytes = Util.StringToByteArray(keyString);
     KeyString = keyString;
     KeyName = name;
     KeyType = type;
 }

 public Program()
 {
     names[0] = new Name("Joe", "Mayo");
     names[1] = new Name("John", "Hancock");
     names[2] = new Name("Jane", "Doe");
     names[3] = new Name("John", "Doe");
     names[4] = new Name("Jack", "Smith");
 }

        public bool Equals(Name other)
        {
            if (other == null) return false;

            if (ReferenceEquals(this, other)) return true;

            return other.FirstName == FirstName && other.LastName == LastName;
        }