Exemple #1
0
        public void CheckFunctionality_Of_IsWithin_When_InsertValue_InRange_result_False(int value)
        {
            //Act
            var result = GeneralValidationHelper.IsWithin(value, 10, 20);

            //Assert
            Assert.False(result);
        }
Exemple #2
0
        public void CheckFunctionality_Of_IsIntegerValueNegative_When_InsertValue_Positive_result_False(int value)
        {
            //Act
            var result = GeneralValidationHelper.IsIntegerValueNegative(value);

            //Assert
            Assert.False(result);
        }
Exemple #3
0
 private void ValidateSetupValue(int value)
 {
     if (GeneralValidationHelper.IsIntegerValueNegative(value))
     {
         _log.Message(LogLevel.Warn, RobotConstantsValues.MatrixSetupFailureBackToDefault);
         // no need to throw exception. Mission will fail
         PreDefaultMatrix();
     }
 }
        public bool SetPosition(int x, int y, Direction direction)
        {
            _log.Starting();

            if (!Enum.IsDefined(typeof(Direction), direction))
            {
                throw new InvalidEnumArgumentException();
            }

            if (GeneralValidationHelper.IsIntegerValueNegative(x) || GeneralValidationHelper.IsIntegerValueNegative(y))
            {
                return(false);
            }

            if (!GeneralValidationHelper.IsWithin(x, _workingMatrixSize.Min_Y_Value, _workingMatrixSize.Max_Y_Value))
            {
                return(false);
            }

            if (!GeneralValidationHelper.IsWithin(y, _workingMatrixSize.Min_X_Value, _workingMatrixSize.Max_X_Value))
            {
                return(false);
            }

            switch (direction)
            {
            case Direction.N:     // y++
                return(ProcessNorthDirection(x, y, direction));

            case Direction.S:     // y--
                return(ProcessSouthDirection(x, y, direction));

            case Direction.E:     //x++
                return(ProcessEastDirection(x, y, direction));

            case Direction.W:     //x--
                return(ProcessWestDirection(x, y, direction));

            default:
                throw new NotImplementedException();
            }
        }
        public bool ProcessSouthDirection(int x, int y, Direction direction)// y--
        {
            // int temp = _currentPosition.Y - y;
            int temp = y;

            if (!GeneralValidationHelper.IsWithin(temp, _workingMatrixSize.Min_Y_Value, _workingMatrixSize.Max_Y_Value))
            {
                return(false);
            }

            if (!GeneralValidationHelper.IsWithin(x, _workingMatrixSize.Min_X_Value, _workingMatrixSize.Max_X_Value))
            {
                return(false);
            }

            _currentPosition.X         = x;
            _currentPosition.Y         = temp;
            _currentPosition.Direction = direction;
            return(true);
        }
        public bool ProcessWestDirection(int x, int y, Direction direction) //x--
        {
            //int temp = _currentPosition.X -  x;
            int temp = x;

            if (_setupPostionFirstTime)
            {
                if (!GeneralValidationHelper.IsWithin(temp, _workingMatrixSize.Min_X_Value, _workingMatrixSize.Max_X_Value))
                {
                    return(false);
                }
            }

            if (!GeneralValidationHelper.IsWithin(y, _workingMatrixSize.Min_Y_Value, _workingMatrixSize.Max_Y_Value))
            {
                return(false);
            }

            _currentPosition.Y         = y;
            _currentPosition.X         = temp;
            _currentPosition.Direction = direction;
            return(true);
        }