public void addSubjectMarkToStudent(string subject, string studentNeptunCode, Mark mark)
 {
     if (this.trunk.ContainsKey(subject))
     {
         this.trunk[subject].addMarkToStudent(studentNeptunCode, mark);
     }
 }

 public void TestMarks( string fileName)
 {
     var stream = new FileStream(fileName, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
     var inputs = new StreamReader(stream).ReadToEnd().Split(new[] {"---\n"}, StringSplitOptions.None);
     foreach (var input in inputs.Skip(1))
     {
         var index = 0;
         var line = 0;
         var column = 0;
         while (index < input.Length && input[index] != '*')
             if (input[index++] == '\n')
             {
                 line++;
                 column = 0;
             }
             else
                 column++;
         var mark = new Mark
                        {
                            Name = fileName,
                            Index = index,
                            Line = line,
                            Column = column,
                            Buffer = new StringBuilder(input),
                            Pointer = index
                        };
         var snippet = mark.GetSnippet(2, 79);
         var lineCount = snippet.Count(c => c == '\n');
         Assert.AreEqual(lineCount, 1);
         var lines = snippet.Split('\n');
         Assert.Less(lines[0].Length, 82);
         Assert.AreEqual(lines[0][lines[1].Length - 1], '*');
     }
     stream.Close();
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="DocumentStart"/> class.
 /// </summary>
 /// <param name="version">The version.</param>
 /// <param name="tags">The tags.</param>
 /// <param name="isImplicit">Indicates whether the event is implicit.</param>
 /// <param name="start">The start position of the event.</param>
 /// <param name="end">The end position of the event.</param>
 public DocumentStart(VersionDirective version, TagDirectiveCollection tags, bool isImplicit, Mark start, Mark end)
     : base(start, end)
 {
     this.version = version;
     this.tags = tags;
     this.isImplicit = isImplicit;
 }

        public void TestConstructor_PassValidValues_ShouldSetValueAndSubjectCorrectly(float value, Subject subject)
        {
            var mark = new Mark(subject, value);

            Assert.AreEqual(mark.Subject, subject);
            Assert.AreEqual(mark.Value, value);
        }

 public static void ValidateMark(Mark mark)
 {
     if (!(mark.MarkValue >= 2.00M && mark.MarkValue <= 6.00M))
     {
         throw new MarkException();
     }
 }

 protected BasePlayer(string name, Mark mark)
 {
     EnsuresNameIsValid(name);
     EnsuresMarkIsValid(mark);
     _name = name;
     _mark = mark;
 }

        public void TestConstructor_PassValidValues_ShouldInitialiseCorrectly(float value, Subject subject)
        {
            var mark = new Mark(subject, value);

            Assert.IsNotNull(mark);
            Assert.IsInstanceOf<Mark>(mark);
        }

        private void btnSave_Click_1(object sender, RoutedEventArgs e)
        {
            SubjectName subject = GetSubjectName();
            TypeOfMarks markType = GetMarkType();

            Mark newMark = new Mark(decimal.Parse(txtMarkValue.Text), markType, student, new Subject(subject));

            // Validate the mark. If the mark is incorrect, throw exception.
            try
            {
                Validation.ValidateMark(newMark);

                ESchoolDiaryData.Marks.Add(newMark);
                studentWindow.lblSubjectContent.Content += lblSubject.Content.ToString();
                studentWindow.lblMarksTypeContent.Content += lblMarkType.Content.ToString();
                studentWindow.lblMarksValueContent.Content += string.Format("{0:0.00}", decimal.Parse(txtMarkValue.Text));

                MessageBox.Show("Mark added.");

                this.Close();
            }
            catch (MarkException markEx)
            {
                MessageBox.Show(markEx.Message);
            }
            finally
            {
                txtMarkValue.Clear();
            }
        }

 public virtual IGrid Fill(IPosition position, Mark mark)
 {
     var grid = new Mark[3, 3];
     Array.Copy(_grid, grid, _grid.Length);
     grid[position.Row, position.Col] = mark;
     return new Grid3X3(grid);
 }

        public async Task<int> Add(string authorId, int imageId, int value)
        {
            var assessingUser = this.users
                .All()
                .FirstOrDefault(u => u.Id == authorId);

            var imageToAttachMarkTo = this.images
                .All()
                .FirstOrDefault(i => i.Id == imageId);

            if (imageToAttachMarkTo == null || assessingUser == null)
            {
                return GlobalConstants.InvalidDbObjectReturnValue;
            }

            var markToAdd = new Mark()
            {
                GivenBy = assessingUser,
                IsDeleted = false,
                Value = value
            };

            imageToAttachMarkTo.Rating.Marks.Add(markToAdd);

            this.images.Update(imageToAttachMarkTo);

            await this.images.SaveChangesAsync();

            return markToAdd.Id;
        }

 private static bool IsRange(int index, Mark mark)
 {
     if (mark.HeadCharIndex >= index && mark.TailCharIndex <= index)
     {
         return true;
     }
     return false;
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="Scalar"/> class.
 /// </summary>
 /// <param name="anchor">The anchor.</param>
 /// <param name="tag">The tag.</param>
 /// <param name="value">The value.</param>
 /// <param name="style">The style.</param>
 /// <param name="isPlainImplicit">.</param>
 /// <param name="isQuotedImplicit">.</param>
 /// <param name="start">The start position of the event.</param>
 /// <param name="end">The end position of the event.</param>
 public Scalar(string anchor, string tag, string value, ScalarStyle style, bool isPlainImplicit, bool isQuotedImplicit, Mark start, Mark end)
     : base(anchor, tag, start, end)
 {
     this.value = value;
     this.style = style;
     this.isPlainImplicit = isPlainImplicit;
     this.isQuotedImplicit = isQuotedImplicit;
 }

        private void button1_Click(object sender, EventArgs e)
        {
            Mark m = new Mark("Chris");//constructor runs here.
            m.testThis();

            Mark j = new Mark();
            j.testThis();
        }

 public void addMarkToStudent(string neptunCode, Mark mark)
 {
     Student student = this.findStudent(neptunCode);
     if (student != null)
     {
         student.addMark(mark);
     }
 }

 public Student(string firstName, string secondName, Mark mark, Group group, Dictionary<Subject, Mark> subjectsMarks, DateTime birthDate)
 {
     _firstName = firstName;
     _secondName = secondName;
     _mark = mark;
     CurrentGroup = group;
     _subjectsMarks = subjectsMarks;
     _birthDate = birthDate;
 }

 public void SetMark(Subject subject, Mark mark)
 {
     foreach (var pair in _subjectsMarks)
     {
         if (pair.Key == subject)
         {
             _subjectsMarks[pair.Key] = mark;
         }
     }
 }

        /// <summary>
        /// mark question based on the number of responses
        /// </summary>
        /// <param name="markingSchema"></param>
        /// <param name="response"></param>
        /// <returns>
        /// calculated score
        /// </returns>
        public static int markQuestionTypeCount(Mark markingSchema, string response)
        {
            var score = 0;
            var responses = response.Split('|');

            // compare response
            if (Convert.ToInt32(markingSchema.answer) == responses.Length)
                score = Convert.ToInt32(markingSchema.mark);

            return score;
        }

        public Mark Create(CreateMarkCommand command)
        {
            var service = new Mark(command.Term, command.Job, command.Description);
            service.Validate();
            _repository.Create(service);

            if (Commit())
                return service;

            return null;
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="AnchorAlias"/> class.
        /// </summary>
        /// <param name="value">The value of the alias.</param>
        /// <param name="start">The start position of the event.</param>
        /// <param name="end">The end position of the event.</param>
        public AnchorAlias(string value, Mark start, Mark end)
            : base(start, end)
        {
            if(string.IsNullOrEmpty(value)) {
                throw new YamlException(start, end, "Anchor value must not be empty.");
            }

            if(!NodeEvent.anchorValidator.IsMatch(value)) {
                throw new YamlException(start, end, "Anchor value must contain alphanumerical characters only.");
            }
            
            this.value = value;
        }

		/// <summary>
		/// Gets the node with the specified anchor.
		/// </summary>
		/// <param name="anchor">The anchor.</param>
		/// <param name="throwException">if set to <c>true</c>, the method should throw an exception if there is no node with that anchor.</param>
		/// <param name="start">The start position.</param>
		/// <param name="end">The end position.</param>
		/// <returns></returns>
		public YamlNode GetNode(string anchor, bool throwException, Mark start, Mark end)
		{
			YamlNode target;
			if (anchors.TryGetValue(anchor, out target))
			{
				return target;
			}
			else if (throwException)
			{
				throw new AnchorNotFoundException(start, end, string.Format(CultureInfo.InvariantCulture, "The anchor '{0}' does not exists", anchor));
			}
			else
			{
				return null;
			}
		}