internal static IFilePath GetBrotherFileWithName(IPath path, string fileName)
 {
     Debug.Assert(path != null);
     Debug.Assert(fileName != null); // Enforced by contract
     Debug.Assert(fileName.Length > 0); // Enforced by contract
     return path.ParentDirectoryPath.GetChildFileWithName(fileName);
 }

 private void ChangeUnitLocation(IPath pathToTheTargetPlanet, IUnit unitToTeleport, ILocation targetLocation)
 {
     pathToTheTargetPlanet.TargetLocation.Planet.Units.Add(unitToTeleport);
     unitToTeleport.CurrentLocation.Planet.Units.Remove(unitToTeleport);
     unitToTeleport.PreviousLocation = unitToTeleport.CurrentLocation;
     unitToTeleport.CurrentLocation = targetLocation;
 }

			internal static IFilePath GetSisterFilePath(IPath path, string fileName)
			{
				Argument.IsNotNull(nameof(path), path);
				Argument.IsNotNullOrEmpty(nameof(fileName), fileName);

				return path.ParentDirectoryPath.GetChildFilePath(fileName);
			}

        /// <summary>
        /// Creates a new instance of the axis class
        /// </summary>
        /// <param name="path">That path to use</param>
        public Axis(IPath path)
        {
            _valid = true;
            _path = path;

            SetPath(path);
        }

 public SelectableObject(Guid owner ,string name, IPath path)
 {
     m_Owner = owner;
     m_Bounds = new Box(20.0, 20.0);
     m_Name = name;
     m_Path = path;
 }

 internal SubOperation(MouseArea mc, IPath path)
 {
     this.currentGraph = null;
     this.mouseAreaControl = null;
     this.mouseAreaControl = mc;
     this.CurrentGraph = path;
 }

 internal static IDirectoryPath GetBrotherDirectoryWithName(IPath path, string directoryName)
 {
     Debug.Assert(path != null);
     Debug.Assert(directoryName != null); // Enforced by contract
     Debug.Assert(directoryName.Length > 0); // Enforced by contract
     return path.ParentDirectoryPath.GetChildDirectoryWithName(directoryName);
 }

			internal static IDirectoryPath GetSisterDirectoryPath(IPath path, string directoryName)
			{
				Argument.IsNotNull(nameof(path), path);
				Argument.IsNotNullOrEmpty(nameof(directoryName), directoryName);

				return path.ParentDirectoryPath.GetChildDirectoryPath(directoryName);
			}

        /// <summary>
        /// Initializes a new instance of the <see cref="SelfMediaDatabase.Core.Operations.Prune.PruneOperation"/> class.
        /// </summary>
        /// <param name="directory">Injection wrapper of <see cref="System.IO.Directory"/>.</param>
        /// <param name="file">Injection wrapper of <see cref="System.IO.File"/>.</param>
        /// <param name="path">Injection wrapper of <see cref="System.IO.Path"/>.</param>
        /// <param name="imageComparer">Image comparer.</param>
        /// <param name="fileSystemHelper">Helper to access to files.</param>
        public PruneOperation(
            IDirectory directory, 
            IFile file, 
            IPath path, 
            IImageComparer imageComparer, 
            IFileSystemHelper fileSystemHelper,
            IDialog dialog,
            IRenameOperation renameOperation)
        {
            if (directory == null)
                throw new ArgumentNullException("directory");
            if (file == null)
                throw new ArgumentNullException("file");
            if (imageComparer == null)
                throw new ArgumentNullException("imageComparer");
            if (fileSystemHelper == null)
                throw new ArgumentNullException("fileSystemHelper");
            if (path == null)
                throw new ArgumentNullException("path");
            if (dialog == null)
                throw new ArgumentNullException("dialog");
            if (renameOperation == null)
                throw new ArgumentNullException("renameOperation");

            _directory = directory;
            _file = file;
            _path = path;
            _imageComparer = imageComparer;
            _fileSystemHelper = fileSystemHelper;
            _dialog = dialog;
            _renameOperation = renameOperation;
        }

 public Record(IPath path)
 {
     _time = path.Time;
     _position = path.Position;
     _velocity = path.Velocity;
     _acceleration = path.Acceleration;
 }

        public LinearPath(IPath anotherPath, int sampleCount)
        {
            List<Vector3> pointList = new List<Vector3>(1000);

            PathPosition pathPosition = anotherPath.getStartPoint();

            float pathLength = 0f;
            float remaining = 0f;

            while (remaining == 0)
            {
                remaining = anotherPath.move(pathPosition, 0.01f, out pathPosition);
                pathLength += 0.01f;
            }
            pathLength -= remaining;

            distanceBetweenPoints = pathLength / sampleCount;
            pathPosition = anotherPath.getStartPoint();
            remaining = 0;

            while (remaining == 0f)
            {
                pointList.Add(anotherPath.getLocalPosition(pathPosition));
                remaining = anotherPath.move(pathPosition, distanceBetweenPoints, out pathPosition);
            }

            if (remaining < distanceBetweenPoints / 2f)
                pointList[pointList.Count - 1] = anotherPath.getLocalPosition(anotherPath.getEndPoint());
            else
                pointList.Add(anotherPath.getLocalPosition(anotherPath.getEndPoint()));

            points = pointList.ToArray();
        }

        /// <summary>
        /// Gets a default behavior for a path segment
        /// </summary>
        /// <param name="location"></param>
        /// <param name="vehicleState"></param>
        /// <param name="exit"></param>
        /// <param name="relative"></param>
        /// <param name="stopSpeed"></param>
        /// <param name="aMax"></param>
        /// <param name="dt">timestep in seconds</param>
        /// <returns></returns>
        public static PathFollowingBehavior DefaultStayInLaneBehavior(RndfLocation location, VehicleState vehicleState, 
            RndfWaypointID action, ActionType actionType, bool relative, double stopSpeed, double aMax, double dt,
            double maxSpeed, IPath path)
        {
            // get lane path
            //IPath path = RoadToolkit.LanePath(location.Partition.FinalWaypoint.Lane, vehicleState, relative);

            // check if the action is just a goal (note that exit and stop take precedence)
            if (actionType == ActionType.Goal)
            {
                // get maximum speed
                //double maxSpeed = location.Partition.FinalWaypoint.Lane.Way.Segment.SpeedInformation.MaxSpeed;
                //double maxSpeed = maxV;

                // generate path following behavior
                //return new PathFollowingBehavior(path, new ScalarSpeedCommand(maxSpeed));
                return null;
            }
            else
            {
                // get maximum speed
                //double maxSpeed = location.Partition.FinalWaypoint.Lane.Way.Segment.SpeedInformation.MaxSpeed;

                // get operational required distance to hand over to operational stop
                double distance = RoadToolkit.DistanceUntilOperationalStop(RoadToolkit.DistanceToWaypoint(location, action)-TahoeParams.FL);

                // get desired velocity
                double desiredSpeed = RoadToolkit.InferFinalSpeed(0, stopSpeed, distance, maxSpeed, aMax, dt);

                // generate path following behavior
                //return new PathFollowingBehavior(path, new ScalarSpeedCommand(desiredSpeed));
                return null;
            }
        }

 public GenerateInstallScriptRequestProcessor(
     IPath path,
     IHelpContentManager helpContentManager)
 {
     _path = path;
     _helpContentManager = helpContentManager;
 }

 public static List<Vector2> IPathToPoints(IPath p)
 {
     List<Vector2> pts = new List<Vector2>();
     foreach (IPathSegment lp in p)
         pts.Add(lp.Start);
     pts.Add(p.EndPoint.pt);
     return pts;
 }

        public bool Matches(IRoute route, IPath path)
        {
            var routePath = route.Path;
            if (!routePath.IsLiteral)
                return false;

            return routePath.LiteralPath.Equals(path.LiteralPath);
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="X509CertificateWrap"/> class.
        /// </summary>
        public X509CertificateWrap(IFile file,
                                   IPath path)
        {
            this.FileWrap = file;
            this.PathWrap = path;

            this.Initialize();
        }

        public void BecauseOf()
        {
            m_Path = Get<IPath>();
            m_Motion = Get<IMotion>();

            m_Path.GetCurrentMotion(Arg.Any<ulong>()).Returns(m_Motion);

            m_SelectableObject = new SelectableObject(m_TestObjectName, m_Path);
        }

      public void Test_ContainsPath() {
         var array = new IPath[] {
            @"C:\File.txt".ToAbsoluteFilePath(),
            @".\".ToRelativeDirectoryPath()
         };

         Assert.IsTrue(array.ContainsPath(@".\".ToRelativeDirectoryPath()));
         Assert.IsFalse(array.ContainsPath(@"..\".ToRelativeDirectoryPath()));
      }

 public void UpdatePath(IPath path)
 {
     if (path == null) return;
     if (PathUtils.CheckPathsEqual(this.path, path)) return;
     lock (pathLock)
     {
         this.path = path;
     }
 }

		/// <summary>
		///     Returns <i>true</i> if <paramref name="path" /> and <paramref name="otherPath" /> are both <i>null</i>, or if <paramref name="path" />.Equals(
		///     <paramref name="otherPath" />).
		/// </summary>
		/// <param name="path">The first path.</param>
		/// <param name="otherPath">The scond path.</param>
		public static bool EqualsNullSupported(this IPath path, IPath otherPath)
		{
			if (path == null)
			{
				return otherPath == null;
			}

			return otherPath != null && path.Equals(otherPath);
		}