public ITrackingSpan CreateTrackingSpan(Span span, SpanTrackingMode trackingMode, TrackingFidelityMode trackingFidelity) {
			if (trackingMode == SpanTrackingMode.Custom)
				throw new NotSupportedException();
			if (trackingFidelity == TrackingFidelityMode.UndoRedo)
				throw new NotSupportedException();
			return new TrackingSpan(this, span, trackingMode, trackingFidelity);
		}

		public MappingSpan(IBufferGraph bufferGraph, SnapshotSpan snapshotSpan, SpanTrackingMode trackingMode) {
			if (bufferGraph == null)
				throw new ArgumentNullException(nameof(bufferGraph));
			if (snapshotSpan.Snapshot == null)
				throw new ArgumentException();
			BufferGraph = bufferGraph;
			this.snapshotSpan = snapshotSpan;
			spanTrackingMode = trackingMode;
		}

        public TrackingSpanMock(ITextBuffer textBuffer, Span span, SpanTrackingMode trackingMode, TrackingFidelityMode trackingFidelity)
        {
            _span = span;

            TextBuffer = textBuffer;
            TrackingMode = trackingMode;
            TrackingFidelity = trackingFidelity;

            var mock = textBuffer as TextBufferMock;
            mock.BeforeChanged += OnBeforeTextBufferChanged;
        }

		public TrackingSpan(ITextVersion textVersion, Span span, SpanTrackingMode trackingMode, TrackingFidelityMode trackingFidelity) {
			if (textVersion == null)
				throw new ArgumentNullException(nameof(textVersion));
			if ((uint)span.End > (uint)textVersion.Length)
				throw new ArgumentOutOfRangeException(nameof(span));
			TextBuffer = textVersion.TextBuffer;
			TrackingFidelity = trackingFidelity;
			TrackingMode = trackingMode;
			this.textVersion = textVersion;
			this.span = span;
		}

        private static SnapshotSpan MapTo(IBufferGraphFactoryService bufferGraphFactoryService, SnapshotSpan span, ITextSnapshot snapshot, SpanTrackingMode spanTrackingMode)
        {
            if (span.Snapshot.TextBuffer == snapshot.TextBuffer)
                return span.TranslateTo(snapshot, spanTrackingMode);

            var graph = bufferGraphFactoryService.CreateBufferGraph(snapshot.TextBuffer);
            var mappingSpan = graph.CreateMappingSpan(span, spanTrackingMode);
            var mapped = mappingSpan.GetSpans(snapshot);
            if (mapped.Count == 1)
                return mapped[0];

            return new SnapshotSpan(mapped[0].Start, mapped[mapped.Count - 1].End);
        }

		/// <summary>
		/// Initializes a new instance of the <see cref="VersionedTextSpan"/> class.
		/// </summary>
		/// <exception cref="ArgumentNullException">
		/// <para><paramref name="buffer"/> is <see langword="null"/>.</para>
		/// -or-
		/// <para><paramref name="span"/> is <see langword="null"/>.</para>
		/// </exception>
		public VersionedTextSpan(TextBuffer buffer, Span span, SpanTrackingMode trackingMode)
		{
			if (buffer == null)
			{
				throw new ArgumentNullException("buffer");
			}

			if (span == null)
			{
				throw new ArgumentNullException("span");
			}

			this.Construct(buffer, buffer.Version, span.Start, span.Length, trackingMode);
		}

 public MockTrackingSpan(MockTextSnapshot snapshot, int start, int length, SpanTrackingMode trackingMode = SpanTrackingMode.EdgeExclusive) {
     _start = start;
     _length = length;
     _snapshot = snapshot;
     _trackingMode = trackingMode;
     switch(_trackingMode) {
         case SpanTrackingMode.EdgeExclusive:
             _startPoint = new MockTrackingPoint(snapshot, start, PointTrackingMode.Positive);
             _endPoint = new MockTrackingPoint(snapshot, start + length, PointTrackingMode.Negative);
             break;
         case SpanTrackingMode.EdgeInclusive:
             _startPoint = new MockTrackingPoint(snapshot, start, PointTrackingMode.Negative);
             _endPoint = new MockTrackingPoint(snapshot, start + length, PointTrackingMode.Positive);
             break;
         case SpanTrackingMode.EdgeNegative:
             _startPoint = new MockTrackingPoint(snapshot, start, PointTrackingMode.Negative);
             _endPoint = new MockTrackingPoint(snapshot, start + length, PointTrackingMode.Negative);
             break;
         case SpanTrackingMode.EdgePositive:
             _startPoint = new MockTrackingPoint(snapshot, start, PointTrackingMode.Positive);
             _endPoint = new MockTrackingPoint(snapshot, start + length, PointTrackingMode.Positive);
             break;
     }
 }

 public NormalizedSnapshotSpanCollection MapUpToSnapshot(SnapshotSpan span, SpanTrackingMode trackingMode, ITextSnapshot targetSnapshot) {
     throw new NotImplementedException();
 }

 public ITrackingSpan CreateTrackingSpan(Span span, SpanTrackingMode trackingMode) {
     return new MockTrackingSpan(this, span.Start, span.Length);
 }

 public ITrackingSpan CreateTrackingSpan(int start, int length, SpanTrackingMode trackingMode)
 {
     return TextBuffer.CurrentSnapshot.CreateTrackingSpan(start, length, trackingMode);
 }

		public ITrackingSpan CreateTrackingSpan(int start, int length, SpanTrackingMode trackingMode, TrackingFidelityMode trackingFidelity) =>
			Version.CreateTrackingSpan(start, length, trackingMode, trackingFidelity);

 public NormalizedSnapshotSpanCollection MapDownToFirstMatch(SnapshotSpan span, SpanTrackingMode trackingMode, Predicate<ITextSnapshot> match) {
     throw new NotImplementedException();
 }

 public IMappingSpan CreateMappingSpan(SnapshotSpan span, SpanTrackingMode trackingMode) {
     throw new NotImplementedException();
 }

		private void Construct(TextBuffer buffer, ITextVersion version, Int32 start, Int32 length, SpanTrackingMode trackingMode)
		{
			Int32 lengthOfVersion = buffer.GetLengthOfVersion(version);
			if ((start < 0) || (start > lengthOfVersion))
			{
				throw new ArgumentOutOfRangeException("start");
			}
			if ((length < 0) || ((start + length) > lengthOfVersion))
			{
				throw new ArgumentOutOfRangeException("length");
			}
			_buffer = buffer;
			_version = version;
			_start = start;
			_length = length;
			_trackingMode = trackingMode;
		}

 public NormalizedSnapshotSpanCollection MapDownToBuffer(SnapshotSpan span, SpanTrackingMode trackingMode, ITextBuffer targetBuffer) {
     throw new NotImplementedException();
 }

		private void Initialize(TextBuffer textBuffer, SpanTrackingMode trackingMode)
		{
			if (textBuffer == null)
			{
				throw new ArgumentNullException("textBuffer");
			}

			if (base.Start > textBuffer.Length)
			{
				throw new ArgumentOutOfRangeException("start");
			}

			if ((base.Start + base.Length) > textBuffer.Length)
			{
				throw new ArgumentOutOfRangeException("length");
			}

			this.TextBuffer = textBuffer;
			_version = textBuffer.Version;
			this.TrackingMode = trackingMode;
		}

		/// <summary>
		/// Initializes a new instance of the <see cref="TextSpan"/> class.
		/// </summary>
		/// <exception cref="ArgumentNullException"><paramref name="span"/> is <see langword="null"/>.</exception>
		public TextSpan(TextBuffer textBuffer, Span span, SpanTrackingMode trackingMode)
			: base(span)
		{
			this.Initialize(textBuffer, trackingMode);
		}

 public static ITrackingSpan CreateTrackingSpan(this SnapshotSpan snapshotSpan, SpanTrackingMode trackingMode)
 {
     return snapshotSpan.Snapshot.CreateTrackingSpan(snapshotSpan.Span, trackingMode);
 }

 public ITrackingSpan CreateTrackingSpan(Int32 start, Int32 length, SpanTrackingMode trackingMode)
 {
     throw new NotImplementedException();
 }

 public FakeTrackingSpan(Span span, SpanTrackingMode trackingMode)
 {
     this.span = span;
     this.trackingMode = trackingMode;
 }