public void Intervals_Are_Constructable_From_Semitones()
        {
            var i = new Interval(5);

            Assert.Equal(5, i.Semitones);
            Assert.Equal(IntervalDistance.PerfectFourth, i.Distance);
        }

 /// <summary>
 /// Initializes a new instance of the AbstractEnvironmentComponent class.
 /// </summary>
 public AxisAlignedBoxEnvironmentComponentOld()
   : base(RS.AABoxEnvName, RS.AABoxEnvNickName,
       RS.AABoxEnvDescription, RS.icon_AABoxEnvironment, RS.AABoxEnvOldGuid)
 {
   Interval interval = new Interval(-RS.boxBoundsDefault, RS.boxBoundsDefault);
   box = new Box(Plane.WorldXY, interval, interval, interval);
 }

 /// <summary>
 /// Método estático encargado de la creación de objetos valor <see cref="IInterval"/>
 /// </summary>
 /// <remarks>
 /// Sin comentarios adicionales.
 /// </remarks>
 /// <param name="fromTime">
 /// Parámetro que indica la hora inicial del intervalo.
 /// </param>
 /// <param name="duration">
 /// Parámetro que indica la duración del intervalo.
 /// </param>
 /// <returns>
 /// Devuelve objeto de tipo <see cref="IInterval"/> creado.
 /// </returns>
 public static IInterval Create(DateTime? fromTime, TimeSpan duration)
 {
     // Creamos el objeto valor de periodo de vigencia.
     IInterval interval = new Interval(fromTime, duration);
     // Devolvemos el objeto valor creado.
     return interval;
 }

 public IList<Interval> Insert(IList<Interval> intervals, Interval newInterval) {
     IList<Interval> result = new List<Interval>();
     if(intervals.Count == 0){
         result.Add(newInterval);
         return result; 
     }
     bool first = true;
     for(int i=0; i<intervals.Count; i++){
         if(intervals[i].end<newInterval.start){
             result.Add(intervals[i]);
         }
         else if(intervals[i].start>newInterval.end){
             if(first){
                 result.Add(newInterval);
                 first = false;
             }
             result.Add(intervals[i]);
         }
         else{
             newInterval = new Interval(Math.Min(newInterval.start, intervals[i].start), Math.Max(newInterval.end, intervals[i].end));
         }
     }
         
         if(first){
             result.Add(newInterval);
             first = false;
         }
     return result;
 }

        protected ComparerResult CompareDecimals(Interval interval, decimal actual)
        {
            if (interval.Contains(actual))
                return ComparerResult.Equality;

            return new ComparerResult(interval.ToString());
        }

 public void Construct1()
 {
     var interval = new Interval();
     Assert.AreEqual(IntervalMode.Interpolate, interval.Mode);
     Assert.AreEqual(0, interval.Time);
     Assert.IsNull(interval.Value);
 }

        public void GetIntersectionTest()
        {
            var A = new Interval(0.0f, 5.0f);
            var B = new Interval(2.5f, 7.5f);
            var C = new Interval(6.0f, 10.0f);

            Interval Temp;

            Assert.IsTrue(A.GetIntersection(B, out Temp));
            Assert.AreEqual(new float[] { 2.5f, 5.0f }, Temp.ToArray());
            Assert.IsTrue(B.GetIntersection(A, out Temp));
            Assert.AreEqual(new float[] { 2.5f, 5.0f }, Temp.ToArray());

            Assert.IsTrue(A.GetIntersection(A, out Temp));
            Assert.AreEqual(A.ToArray(), Temp.ToArray());

            Assert.IsTrue(B.GetIntersection(C, out Temp));
            Assert.AreEqual(new float[] { 6.0f, 7.5f }, Temp.ToArray());
            Assert.IsTrue(C.GetIntersection(B, out Temp));
            Assert.AreEqual(new float[] { 6.0f, 7.5f }, Temp.ToArray());

            Assert.IsTrue(B.GetIntersection(B, out Temp));
            Assert.AreEqual(B.ToArray(), Temp.ToArray());

            A.GetIntersection(C, out Temp);
            C.GetIntersection(A, out Temp);

            Assert.IsFalse(A.GetIntersection(C, out Temp));
            Assert.IsFalse(C.GetIntersection(A, out Temp));
        }

        public void ConstructorDefault()
        {
            IInterval<int> interval = new Interval<int>(5, 10);

            Assert.AreEqual(5, interval.LowerBound);
            Assert.AreEqual(10, interval.UpperBound);
        }

        public void ConstructorWrongOrder()
        {
            IInterval<int> interval = new Interval<int>(10, 5);

            Assert.AreEqual(5, interval.LowerBound);
            Assert.AreEqual(10, interval.UpperBound);
        }

    //If touching, returns unit vector pointing from A towards B
    //else returns 0,0,0
    public static Vector3 CheckRoomTouch(Bounds a, Bounds b, float minOverlap)
    {
        Interval a_x = new Interval(a.min.x, a.max.x);
        Interval a_y = new Interval(a.min.y, a.max.y);
        Interval a_z = new Interval(a.min.z, a.max.z);

        Interval b_x = new Interval(b.min.x, b.max.x);
        Interval b_y = new Interval(b.min.y, b.max.y);
        Interval b_z = new Interval(b.min.z, b.max.z);

        int roomTouchX = Interval.CheckTouching(a_x, b_x);
        int roomTouchY = Interval.CheckTouching(a_y, b_y);
        int roomTouchZ = Interval.CheckTouching(a_z, b_z);

        bool roomOverlapX = Interval.CheckOverlap(a_x, b_x, minOverlap);
        bool roomOverlapY = Interval.CheckOverlap(a_y, b_y, minOverlap);
        bool roomOverlapZ = Interval.CheckOverlap(a_z, b_z, minOverlap);

        //-.-- -.-- --..
        if(roomOverlapX && roomOverlapY) return Vector3.forward * roomTouchZ;
        if(roomOverlapZ && roomOverlapY) return Vector3.right * roomTouchX;
        if(roomOverlapX && roomOverlapZ) return Vector3.up * roomTouchY;

        return Vector3.zero;
    }

 public void Construction_EqualStartAndEnd()
 {
     var interval = new Interval(SampleStart, SampleStart);
     Assert.AreEqual(SampleStart, interval.Start);
     Assert.AreEqual(SampleStart, interval.End);
     Assert.AreEqual(new Duration(0), interval.Duration);
 }

 // Constructor with initial values.
 public SurfaceEmitterType(Surface srf)
 {
   Interval interval = new Interval(0,1);
   srf.SetDomain(0, interval);
   srf.SetDomain(1, interval);
   this.srf = srf;
 }

        public void Test_AddInterval()
        {
            Interval[] empty = new Interval[] { };
            Interval[] result;
            SortingAlgorithms algo = new SortingAlgorithms();

            result = algo.AddInterval(empty,
                new Interval { start = 0, end = 2 }
                );
            Assert.AreEqual(1, result.Length);

            result = algo.AddInterval(result,
                new Interval { start = 3, end = 5 }
                );
            Assert.AreEqual(2, result.Length);

            result = algo.AddInterval(result,
                new Interval { start = 4, end = 6 }
                );
            Assert.AreEqual(2, result.Length);

            result = algo.AddInterval(result,
                new Interval { start = 1, end = 4 }
                );
            Assert.AreEqual(1, result.Length);
        }

 /// <summary>
 /// Constructor.
 /// </summary>
 /// <param name="originalArrivingTime">Time when the vehicle originally planned to arrive at the intersection.</param>
 /// <param name="remainingDistance">Remaining distance of the vehicle to the intersection.</param>
 /// <param name="blockingTime">Time interval when the vehicle is going to block the intersection.</param>
 /// <param name="willWaitInFrontOfIntersection">Flag whether vehicle will wait befor intersection or proceed crossing it.</param>
 public CrossingVehicleTimes(double originalArrivingTime, double remainingDistance, Interval<double> blockingTime, bool willWaitInFrontOfIntersection)
 {
     this.originalArrivingTime = originalArrivingTime;
     this.remainingDistance = remainingDistance;
     this.blockingTime = blockingTime;
     this.willWaitInFrontOfIntersection = willWaitInFrontOfIntersection;
 }

 /// <summary>
 /// Initializes a new Box that mimics a BoundingBox struct. 
 /// <para>The orientation plane of the Box is coincident with the 
 /// World XY plane.</para>
 /// </summary>
 /// <param name="bbox">BoundingBox to mimic.</param>
 public Box(BoundingBox bbox)
 {
   m_plane = Plane.WorldXY;
   m_dx = new Interval(bbox.m_min.m_x, bbox.m_max.m_x);
   m_dy = new Interval(bbox.m_min.m_y, bbox.m_max.m_y);
   m_dz = new Interval(bbox.m_min.m_z, bbox.m_max.m_z);
 }

        public void NonEmpty_NotContainedInterval__ReturnsFalse()
        {
            // (-10; 10)
            var a = new Interval(-10, false, 10, false);
            // (-100; -10)
            var b = new Interval(-100, false, -10, false);

            Assert.IsFalse(a.IntersectsWith(b));
            Assert.IsFalse(b.IntersectsWith(a));

            // [-10; 10)
            a = new Interval(-10, true, 10, false);
            // (-100; -10)
            b = new Interval(-100, false, -10, false);

            Assert.IsFalse(a.IntersectsWith(b));
            Assert.IsFalse(b.IntersectsWith(a));

            // (-10; 10)
            a = new Interval(-10, false, 10, false);
            // (-100; -10]
            b = new Interval(-100, false, -10, true);

            Assert.IsFalse(a.IntersectsWith(b));
            Assert.IsFalse(b.IntersectsWith(a));
        }

        public string IntervalFrom(string startNote, int interval, Interval direction)
        {
            int i;
            for( i = 0; i < scale.Length; i++ )
            {
                if( scale[i] == startNote )
                    break;
            }
            if (i >= scale.Length)
                throw new Exception("Invalid start note provided!!!");

            if (direction == Interval.Up) // Move right
            {
                interval--;
                return scale[(i + interval) % 7];
            }
            else // Move left
            {
                interval--;
                while (interval > 0)
                {
                    i--;
                    if (i < 0)
                        i = 6;
                    interval--;
                }
                return scale[i];
            }
        }

 public void Construct3()
 {
     var interval = new Interval(1, "0.2");
     Assert.AreEqual(IntervalMode.Interpolate, interval.Mode);
     Assert.AreEqual(1, interval.Time);
     Assert.AreEqual("0.2", interval.Value);
 }

 public int Shall_the_result_be_correct_for_an_interval_that_has_been_built_in_reverse_order(Interval<int> value)
 {
     var tree = CreateTree(TestEntries().OrderBy(interval => interval.Start).Reverse());
     return tree
         .Search(value)
         .Count();
 }

        /// <summary>
        /// Generates a code containing all intervals in a list of intervals of DateTimes.
        /// </summary>
        /// <param name="allIntervals"> The intervals to generate code for. </param>
        /// <param name="varName"> The variable name to use. </param>
        /// <returns> Returns the generated code for the data. </returns>
        public static string GenerateCode(Interval<DateTime>[] allIntervals, string varName)
        {
            var dateToStr = (Func<DateTime, string>)(d => d == default(DateTime) ? "default(DateTime)" : d.ToString("'new DateTime('yyyy', 'MM', 'dd', 'HH', 'mm', 'ss')'"));

            var str = string.Format(
                @"
            #region {0} = ...
            // the following snapshot was generated from a good result using the method GenerateCode(""{0}"")
            var {0} = new []
                {{",
                     varName) + string.Join(
                @",
            ",
                allIntervals.Select(
                    i => string.Format(
                        @"
                    // {5}
                    new Interval<DateTime>({0}, PointState.{1}, {2}, PointState.{3}, isPositive: {4})",
                        dateToStr(i.Start),
                        i.StartState,
                        dateToStr(i.End),
                        i.EndState,
                        i.IsPositive ? "true" : "false",
                        i))) + @"
                };
            #endregion
            ";

            return str;
        }