public void Increment_WithException_AddReadingDataForTheSpecificException()
        {
            var sensor = new ExceptionSensor();

            ArgumentException exception = new ArgumentException();
            sensor.AddError(exception);

            Reading reading = null;
            ReadingPublisher.Readings.TryDequeue(out reading); // TotalExceptions
            ReadingPublisher.Readings.TryDequeue(out reading);

            Assert.That(reading.Data.Name, Is.EqualTo(exception.GetType().Name));
        }
        //-------------------------------------------------------------------------
        public virtual void failure()
        {
            System.ArgumentException ex   = new System.ArgumentException("failure");
            Result <string>          test = Result.failure(ex);

            assertEquals(test.Success, false);
            assertEquals(test.Failure, true);
            assertEquals(test.getValueOrElse("blue"), "blue");
            assertEquals(test.getValueOrElseApply(f => "blue"), "blue");
//JAVA TO C# CONVERTER TODO TASK: Method reference arbitrary object instance method syntax is not converted by Java to C# Converter:
            assertEquals(test.getValueOrElseApply(Failure::getMessage), "failure");
            assertThrowsIllegalArg(() => test.getValueOrElse(null));
            assertThrowsIllegalArg(() => test.getValueOrElseApply(null));
            assertEquals(test.Failure.Reason, ERROR);
            assertEquals(test.Failure.Message, "failure");
            assertEquals(test.Failure.Items.size(), 1);
            FailureItem item = test.Failure.Items.GetEnumerator().next();

            assertEquals(item.Reason, ERROR);
            assertEquals(item.Message, "failure");
            assertEquals(item.CauseType.get(), ex.GetType());
            assertEquals(item.StackTrace, Throwables.getStackTraceAsString(ex).replace(Environment.NewLine, "\n"));
        }
Example #3
0
        public void TestCompareEndpointsMethod50316(TestCaseAttribute testCase)
        {
            HeaderComment(testCase);

            ArgumentException ex = new ArgumentException("Unused, just need an instance for GetType() below");

            CompareEndpointsHelper(SampleText.Random256, TargetRangeType.DocumentRange, TargetRangeType.DifferentTextPattern,
                   ValueComparison.Equals, ValueComparison.Equals, ValueComparison.Equals, ValueComparison.Equals, ex.GetType());
        }
        public void PruebaConstructorConLímiteDeVelocidadClaseDeRutaBoolArray()
        {
            #region Caso 1: Caso normal.
              {
            // Preparación.
            LímiteDeVelocidad límiteDeVelocidad = new LímiteDeVelocidad(2);
            ClaseDeRuta claseDeRuta = new ClaseDeRuta(3);
            bool[] otrosParámetros = new bool[] { true, false, true, false, false, false, true, true, false, true };

            // Llama al constructor en prueba.
            CampoParámetrosDeRuta objectoEnPrueba = new CampoParámetrosDeRuta(límiteDeVelocidad, claseDeRuta, otrosParámetros);

            // Prueba Propiedades.
            Assert.That(objectoEnPrueba.Identificador, Is.EqualTo(CampoParámetrosDeRuta.IdentificadorDeParámetrosDeRuta), "Identificador");
            Assert.That(objectoEnPrueba.ClaseDeRuta, Is.EqualTo(claseDeRuta), "ClaseDeRuta");
            Assert.That(objectoEnPrueba.LímiteDeVelocidad, Is.EqualTo(límiteDeVelocidad), "LímiteDeVelocidad");
            Assert.That(objectoEnPrueba.OtrosParámetros, Is.EqualTo(otrosParámetros), "OtrosParámetros");
              }
              #endregion

              #region Caso 2: Muy pocos elementos en Otros Parámetros.
              {
            // Preparación.
            LímiteDeVelocidad límiteDeVelocidad = new LímiteDeVelocidad(2);
            ClaseDeRuta claseDeRuta = new ClaseDeRuta(3);
            bool[] otrosParámetros = new bool[] { true, true, false, false, false, true, true, false, true };
            bool lanzóExcepción = false;
            ArgumentException excepciónEsperada = new ArgumentException(
              "El números de Otrós Parámetros debe ser 10 pero es 9\r\nParameter name: losOtrosParámetros");

            // Llama al constructor en prueba.
            try
            {
              CampoParámetrosDeRuta objectoEnPrueba = new CampoParámetrosDeRuta(límiteDeVelocidad, claseDeRuta, otrosParámetros);
            }
            catch (Exception e)
            {
              // Prueba las propiedades de la excepción.
              Assert.That(e.GetType(), Is.EqualTo(excepciónEsperada.GetType()), "Tipo de Excepción");
              Assert.That(e.Message, Is.EqualTo(excepciónEsperada.Message), "Excepción.Message");

              lanzóExcepción = true;
            }

            Assert.That(lanzóExcepción, Is.True, "No se lanzó la excepción.");
              }
              #endregion

              #region Caso 3: Muchos elementos en Otros Parámetros.
              {
            // Preparación.
            LímiteDeVelocidad límiteDeVelocidad = new LímiteDeVelocidad(2);
            ClaseDeRuta claseDeRuta = new ClaseDeRuta(3);
            bool[] otrosParámetros = new bool[] { true, true, false, true, false, false, false, true, true, false, true };
            bool lanzóExcepción = false;
            ArgumentException excepciónEsperada = new ArgumentException(
              "El números de Otrós Parámetros debe ser 10 pero es 11\r\nParameter name: losOtrosParámetros");

            // Llama al constructor en prueba.
            try
            {
              CampoParámetrosDeRuta objectoEnPrueba = new CampoParámetrosDeRuta(límiteDeVelocidad, claseDeRuta, otrosParámetros);
            }
            catch (Exception e)
            {
              // Prueba las propiedades de la excepción.
              Assert.That(e.GetType(), Is.EqualTo(excepciónEsperada.GetType()), "Tipo de Excepción");
              Assert.That(e.Message, Is.EqualTo(excepciónEsperada.Message), "Excepción.Message");

              lanzóExcepción = true;
            }

            Assert.That(lanzóExcepción, Is.True, "No se lanzó la excepción.");
              }
              #endregion
        }
        public void PruebaConstructorConString()
        {
            #region Caso 1: Indice en rango válido.
              {
            // Preparación.
            LímiteDeVelocidad límiteDeVelocidad = new LímiteDeVelocidad (2);
            ClaseDeRuta claseDeRuta = new ClaseDeRuta (3);
            string parámetrosDeRuta = "2,3,0,1,0,0,0,0,0,0,0,1";
            bool[] otrosParámetrosEsperados = new bool[] { false, true, false, false, false, false, false, false, false, true };

            // Llama al constructor en prueba.
            CampoParámetrosDeRuta objectoEnPrueba = new CampoParámetrosDeRuta(parámetrosDeRuta);

            // Prueba Propiedades.
            Assert.That(objectoEnPrueba.Identificador, Is.EqualTo(CampoParámetrosDeRuta.IdentificadorDeParámetrosDeRuta), "Identificador");
            Assert.That(objectoEnPrueba.ClaseDeRuta, Is.EqualTo(claseDeRuta), "ClaseDeRuta");
            Assert.That(objectoEnPrueba.LímiteDeVelocidad, Is.EqualTo(límiteDeVelocidad), "LímiteDeVelocidad");
            Assert.That(objectoEnPrueba.OtrosParámetros, Is.EqualTo(otrosParámetrosEsperados), "OtrosParámetros");
              }
              #endregion

              #region Caso 2: Parametros de Tuta con muy pocos elementos.
              {
            // Preparación.
            string parametrosDeRutaInválidos = "2";
            bool lanzóExcepción = false;
            ArgumentException excepciónEsperada = new ArgumentException(
              "Los parámetros de rutas deben tener 12 elementos separados por coma, pero es: 2");

            // Llama al constructor en prueba.
            try
            {
              CampoParámetrosDeRuta objectoEnPrueba = new CampoParámetrosDeRuta(parametrosDeRutaInválidos);
            }
            catch (Exception e)
            {
              // Prueba las propiedades de la excepción.
              Assert.That(e.GetType(), Is.EqualTo(excepciónEsperada.GetType()), "Tipo de Excepción");
              Assert.That(e.Message, Is.EqualTo(excepciónEsperada.Message), "Excepción.Message");

              lanzóExcepción = true;
            }

            Assert.That(lanzóExcepción, Is.True, "No se lanzó la excepción.");
              }
              #endregion

              #region Caso 3: Otros Parámetros con valores diferente de 0 ó 1.
              {
            // Preparación.
            string parametrosDeRutaInválidos = "2,3,0,5,0,0,0,0,0,0,0,1";
            bool lanzóExcepción = false;
            ArgumentException excepciónEsperada = new ArgumentException(
              "El números de los parámetros de ruta para el tercer elemento en adelante tiene que ser 0 ó 1:" +
              " 2,3,0,5,0,0,0,0,0,0,0,1\r\nParameter name: elTextoDeParámetrosDeRuta");

            // Llama al constructor en prueba.
            try
            {
              CampoParámetrosDeRuta objectoEnPrueba = new CampoParámetrosDeRuta(parametrosDeRutaInválidos);
            }
            catch (Exception e)
            {
              // Prueba las propiedades de la excepción.
              Assert.That(e.GetType(), Is.EqualTo(excepciónEsperada.GetType()), "Tipo de Excepción");
              Assert.That(e.Message, Is.EqualTo(excepciónEsperada.Message), "Excepción.Message");

              lanzóExcepción = true;
            }

            Assert.That(lanzóExcepción, Is.True, "No se lanzó la excepción.");
              }
              #endregion
        }
Example #6
0
        } // CopyRegistryKey

        private bool ErrorIfDestinationIsSourceOrChildOfSource(
            string sourcePath,
            string destinationPath)
        {
            s_tracer.WriteLine("destinationPath = {0}", destinationPath);

            // Note the paths have already been normalized so case-insensitive
            // comparisons should be sufficient

            bool result = false;

            do
            {
                // See if the paths are equal

                if (String.Compare(
                        sourcePath,
                        destinationPath,
                        StringComparison.OrdinalIgnoreCase) == 0)
                {
                    result = true;
                    break;
                }

                string newDestinationPath = GetParentPath(destinationPath, null);

                if (String.IsNullOrEmpty(newDestinationPath))
                {
                    // We reached the root so the destination must not be a child
                    // of the source
                    break;
                }

                if (String.Compare(
                        newDestinationPath,
                        destinationPath,
                        StringComparison.OrdinalIgnoreCase) == 0)
                {
                    // We reached the root so the destination must not be a child
                    // of the source
                    break;
                }

                destinationPath = newDestinationPath;
            } while (true);

            if (result)
            {
                Exception e =
                    new ArgumentException(
                        RegistryProviderStrings.DestinationChildOfSource);
                WriteError(new ErrorRecord(
                    e,
                    e.GetType().FullName,
                    ErrorCategory.InvalidArgument,
                    destinationPath));
            }
            return result;
        } // ErrorIfDestinationIsSourceOrChildOfSource
Example #7
0
        private void TS_ThrowTextPatternExceptions()
        {
            TextPatternRange returnedRange = null;
            Point screenLocation = new Point();
            ArgumentException aeEx = new ArgumentException("<<Fake argument>>");
            ArgumentNullException anEx = new ArgumentNullException("<<Fake null argument>>");

            //----------------
            // RangeFromPoint
            //----------------

            screenLocation.X = Int32.MaxValue;
            screenLocation.Y = Int32.MinValue;

            // ArgumentException – if given point is outside of AutomationElement of the control
            _tth.Pattern_RangeFromPoint(_pattern, ref returnedRange, screenLocation, aeEx.GetType(), CheckType.Verification);

            //----------------
            // RangeFromChild
            //----------------

            // ArgumentNullException – if returnedRange is null 
            _tth.Pattern_RangeFromChild(_pattern, ref returnedRange, null, anEx.GetType(), CheckType.Verification);

            //// InvalidOperationException – if the child could not have come from this container.
            // Bug 1199703: Spec bug: RangeFromChild returns incorrect exception when passed an automation element from another container
            //_tth.Pattern_RangeFromChild(_pattern, ref returnedRange, differentautoElement, ioeEx.GetType(), CheckType.Verification);

            m_TestStep++;
        }
Example #8
0
        private void TS_Coverage_FindText()
        {
            Type type = null;
            ArgumentException aeEx = new ArgumentException("FAKE Argument");
            TextPatternRange callingRange = _pattern.DocumentRange;
            TextPatternRange returnedRange = null;
            string text = callingRange.GetText(-1);

            TextTestsHelper.TrimTrailingCRLF(m_le, ref text);

            if (string.IsNullOrEmpty(text) == true)
            {
                type = aeEx.GetType();
            }

            // Empty text
            _tth.Range_FindText(callingRange, ref returnedRange, "", true, true, aeEx.GetType(), CheckType.Verification);
            _tth.Range_FindText(callingRange, ref returnedRange, "", true, false, aeEx.GetType(), CheckType.Verification);
            _tth.Range_FindText(callingRange, ref returnedRange, "", false, true, aeEx.GetType(), CheckType.Verification);
            _tth.Range_FindText(callingRange, ref returnedRange, "", false, true, aeEx.GetType(), CheckType.Verification);

            // Non-matching text
            _tth.Range_FindText(callingRange, ref returnedRange, "ATG", true, true, null, CheckType.Verification);
            _tth.Range_FindText(callingRange, ref returnedRange, "ATG", true, false, null, CheckType.Verification);
            _tth.Range_FindText(callingRange, ref returnedRange, "ATG", false, true, null, CheckType.Verification);
            _tth.Range_FindText(callingRange, ref returnedRange, "ATG", false, true, null, CheckType.Verification);

            // Matching Text with matching case
            text = text.Substring(0, ((text.Length / 2)));
            _tth.Range_FindText(callingRange, ref returnedRange, text, true, true, type, CheckType.Verification);
            _tth.Range_FindText(callingRange, ref returnedRange, text, true, false, type, CheckType.Verification);
            _tth.Range_FindText(callingRange, ref returnedRange, text, false, true, type, CheckType.Verification);
            _tth.Range_FindText(callingRange, ref returnedRange, text, false, true, type, CheckType.Verification);

            // Matching Text with mis-matched case
            text = text.ToUpperInvariant();
            _tth.Range_FindText(callingRange, ref returnedRange, text, true, true, type, CheckType.Verification);
            _tth.Range_FindText(callingRange, ref returnedRange, text, true, false, type, CheckType.Verification);
            _tth.Range_FindText(callingRange, ref returnedRange, text, false, true, type, CheckType.Verification);
            _tth.Range_FindText(callingRange, ref returnedRange, text, false, true, type, CheckType.Verification);

            Comment("Called FindText kitchen sink");
            m_TestStep++;
        }
        //-------------------------------------------------------------------
        // Regress Bug
        //-------------------------------------------------------------------
        internal void Bug1106920( string bugID, string controls, string bugTitle )
        {
            TextPatternRange range  = null;

            TS_RegressionTest(bugID, controls, bugTitle);

            try
            {
                string actualText = "";
                SetText(SampleText.String1, out actualText, CheckType.IncorrectElementConfiguration);
                range = Pattern_DocumentRange(CheckType.Verification);

                ArgumentException     aeEx  = new ArgumentException();
                ArgumentNullException aneEx = new ArgumentNullException();
                TextPatternRange targetRange = null;

                Range_FindText( range, ref targetRange, null, false, false, aneEx.GetType(), CheckType.IncorrectElementConfiguration );
                
                Range_FindText( range, ref targetRange, "",   false, false, aeEx.GetType(), CheckType.IncorrectElementConfiguration );

                Comment("FindText raised correct exceptions");
            }
            catch (Exception ex)
            {
                if (IsUIVerifyException(ex))  // Don't interfere with legitimate ThrowMe(...)
                    throw;

                ThrowMe(CheckType.Verification, "Unexpected exception encountered:\n" + ex.ToString());
            }
        }
Example #10
0
 protected override PSDriveInfo NewDrive(PSDriveInfo drive)
 {
     if (drive == null)
     {
         throw PSTraceSource.NewArgumentNullException("drive");
     }
     if (!this.ItemExists(drive.Root))
     {
         Exception exception = new ArgumentException(RegistryProviderStrings.NewDriveRootDoesNotExist);
         base.WriteError(new ErrorRecord(exception, exception.GetType().FullName, ErrorCategory.InvalidArgument, drive.Root));
     }
     return drive;
 }
Example #11
0
        } // EscapeChildName

        /// <summary>
        /// Renames the key at the specified <paramref name="path"/> to <paramref name="newName"/>.
        /// </summary>
        ///
        /// <param name="path">
        /// The path to the key to rename.
        /// </param>
        ///
        /// <param name="newName">
        /// The new name of the key.
        /// </param>
        protected override void RenameItem(
            string path,
            string newName)
        {
            if (String.IsNullOrEmpty(path))
            {
                throw PSTraceSource.NewArgumentException("path");
            }

            if (String.IsNullOrEmpty(newName))
            {
                throw PSTraceSource.NewArgumentException("newName");
            }

            s_tracer.WriteLine("newName = {0}", newName);

            string parentPath = GetParentPath(path, null);
            string newPath = MakePath(parentPath, newName);

            // Make sure we aren't going to overwrite an existing item

            bool exists = ItemExists(newPath);

            if (exists)
            {
                Exception e = new ArgumentException(RegistryProviderStrings.RenameItemAlreadyExists);
                WriteError(new ErrorRecord(
                    e,
                    e.GetType().FullName,
                    ErrorCategory.InvalidArgument,
                    newPath));

                return;
            }
            // Confirm the rename item with the user

            string action = RegistryProviderStrings.RenameItemAction;

            string resourceTemplate = RegistryProviderStrings.RenameItemResourceTemplate;

            string resource =
                String.Format(
                    Host.CurrentCulture,
                    resourceTemplate,
                    path,
                    newPath);

            if (ShouldProcess(resource, action))
            {
                // Implement rename as a move operation

                MoveRegistryItem(path, newPath);
            } // ShouldProcess
        } // RenameItem
Example #12
0
        } // WriteRegistryItemObject

        /// <summary>
        /// Takes a string and tries to parse it into a RegistryValueKind enum
        /// type.
        /// If the conversion fails, WriteError() is called
        /// </summary>
        /// 
        /// <param name="type">
        /// The type as specified by the user that should be parsed into a RegistryValueKind enum.
        /// </param>
        /// 
        /// <param name="kind"> output for the RegistryValueKind for the string</param>
        /// <returns>
        /// true if the conversion succeeded
        /// </returns>
        private bool ParseKind(string type, out RegistryValueKind kind)
        {
            kind = RegistryValueKind.Unknown;

            if (String.IsNullOrEmpty(type))
            {
                return true;
            }

            bool success = true;
            Exception innerException = null;
            try
            {
                // Convert the parameter to a RegistryValueKind
                kind = (RegistryValueKind)Enum.Parse(typeof(RegistryValueKind), type, true);
            }
            catch (InvalidCastException invalidCast)
            {
                innerException = invalidCast;
            }
            catch (ArgumentException argException)
            {
                innerException = argException;
            }

            if (innerException != null)
            {
                success = false;

                string formatString =
                    RegistryProviderStrings.TypeParameterBindingFailure;
                Exception e =
                    new ArgumentException(
                        string.Format(
                            CultureInfo.CurrentCulture,
                            formatString,
                            type,
                            typeof(RegistryValueKind).FullName),
                        innerException);
                WriteError(new ErrorRecord(
                    e,
                    e.GetType().FullName,
                    ErrorCategory.InvalidArgument,
                    type));
            }

            return success;
        } // ParseKind
Example #13
0
        /// <summary>
        /// A private helper method that retrieves a RegistryKey for the specified
        /// path and if an exception is thrown retrieving the key, an error is written
        /// and null is returned.
        /// </summary>
        ///
        /// <param name="path">
        /// The path to the registry key to retrieve.
        /// </param>
        ///
        /// <param name="writeAccess">
        /// If write access is required the key then this should be true. If false,
        /// the key will be opened with read access only.
        /// </param>
        ///
        /// <returns>
        /// The RegistryKey associated with the specified path.
        /// </returns>
        ///
        private IRegistryWrapper GetRegkeyForPathWriteIfError(string path, bool writeAccess)
        {
            IRegistryWrapper result = null;
            try
            {
                result = GetRegkeyForPath(path, writeAccess);

                if (result == null)
                {
                    // The key was not found, write out an error.

                    ArgumentException exception =
                        new ArgumentException(
                        RegistryProviderStrings.KeyDoesNotExist);
                    WriteError(new ErrorRecord(exception, exception.GetType().FullName, ErrorCategory.InvalidArgument, path));

                    return null;
                }
            }
            catch (ArgumentException argumentException)
            {
                WriteError(new ErrorRecord(argumentException, argumentException.GetType().FullName, ErrorCategory.OpenError, path));
                return result;
            }
            catch (System.IO.IOException ioException)
            {
                // An exception occurred while trying to get the key. Write
                // out the error.

                WriteError(new ErrorRecord(ioException, ioException.GetType().FullName, ErrorCategory.OpenError, path));
                return result;
            }
            catch (System.Security.SecurityException securityException)
            {
                // An exception occurred while trying to get the key. Write
                // out the error.

                WriteError(new ErrorRecord(securityException, securityException.GetType().FullName, ErrorCategory.PermissionDenied, path));
                return result;
            }
            catch (System.UnauthorizedAccessException unauthorizedAccessException)
            {
                // An exception occurred while trying to get the key. Write
                // out the error.

                WriteError(new ErrorRecord(unauthorizedAccessException, unauthorizedAccessException.GetType().FullName, ErrorCategory.PermissionDenied, path));
                return result;
            }
            return result;
        }
Example #14
0
        } // RemovePropertyValueAt        

        /// <summary>
        /// Adds a property value on the item specified by the path.
        /// </summary>
        /// 
        /// <param name="path">
        /// The path to the item on which the property should be added.
        /// </param>
        /// 
        /// <param name="at">
        /// The position of the property to add.
        /// </param>
        ///
        /// <param name="propertyValue">
        /// The property to add the value on.
        /// </param>
        /// 
        /// <returns>
        /// Nothing. A PSObject representing the property and value that was 
        /// added should be passed to the WriteObject() method.
        /// </returns>
        /// 
        /// <remarks>
        /// Implement this method when you are providing access to a data store
        /// that allows multivalued properties.
        /// </remarks>
        /// 
        public void AddPropertyValueAt(
            string path,
            object at,
            PSObject propertyValue)
        {
            if (path == null)
            {
                throw tracer.NewArgumentNullException("path");
            }

            if (!CheckOperationNotAllowedOnHiveContainer(path))
            {
                return;
            }

            if (propertyValue == null)
            {
                throw tracer.NewArgumentNullException("propertyValue");
            }

            // Convert the at parameter to an int
            int index = GetIndexFromAt(at);

            IRegistryWrapper key = GetRegkeyForPathWriteIfError(path, true);

            if (key == null)
            {
                return;
            }

            string action = RegistryProviderStrings.AddPropertyValueAtAction;
            
            string resourceTemplate = RegistryProviderStrings.AddPropertyValueAtResourceTemplate;

            PSMemberInfoCollection properties = null;

            try
            {
                properties = propertyValue.Properties;
            }
            catch (System.IO.IOException ioException)
            {
                // An exception occurred while trying to get the key. Write
                // out the error.

                WriteError (new ErrorRecord (ioException, ioException.GetType().FullName, ErrorCategory.ReadError, path));
                return;
            }
            catch (System.Security.SecurityException securityException)
            {
                // An exception occurred while trying to get the key. Write
                // out the error.

                WriteError (new ErrorRecord (securityException, securityException.GetType().FullName, ErrorCategory.PermissionDenied, path));
                return;
            }
            catch (System.UnauthorizedAccessException unauthorizedAccessException)
            {
                // An exception occurred while trying to get the key. Write
                // out the error.

                WriteError (new ErrorRecord (unauthorizedAccessException, unauthorizedAccessException.GetType().FullName, ErrorCategory.PermissionDenied, path));
                return;
            }


            foreach (PSMemberInfo property in properties)
            {
                object newPropertyValue = property.Value;

                string resource = 
                    String.Format(
                        Host.CurrentCulture, 
                        resourceTemplate,
                        path,
                        property.Name,
                        at);

                if (ShouldProcess(resource, action))
                {
                    string propertyNameToSet = GetPropertyName(property.Name);

                    // First get the current value

                    object currentValue = null;
                    
                    try
                    { 
                        currentValue = key.GetValue(propertyNameToSet);
                    }
                    catch (System.IO.IOException ioException)
                    {
                        // An exception occurred while trying to set the value. Write
                        // out the error.

                        WriteError (new ErrorRecord (ioException, ioException.GetType().FullName, ErrorCategory.ReadError, property.Name));
                        continue;
                    }
                    catch (System.Security.SecurityException securityException)
                    {
                        // An exception occurred while trying to set the value. Write
                        // out the error.

                        WriteError (new ErrorRecord (securityException, securityException.GetType().FullName, ErrorCategory.PermissionDenied, property.Name));
                        continue;
                    }
                    catch (System.UnauthorizedAccessException unauthorizedAccessException)
                    {
                        // An exception occurred while trying to get the key. Write
                        // out the error.

                        WriteError (new ErrorRecord (unauthorizedAccessException, unauthorizedAccessException.GetType().FullName, ErrorCategory.PermissionDenied, property.Name));
                        continue;
                    }

                    if (currentValue != null &&
                        currentValue is string[])
                    {
                        ArrayList newValueArrayList = new ArrayList((string[])currentValue);

                        if (index == -1 || index >= newValueArrayList.Count)
                        {
                            newValueArrayList.Add(newPropertyValue.ToString());
                        }
                        else
                        {
                            newValueArrayList.Insert(index, newPropertyValue.ToString());
                        }
                        currentValue = newValueArrayList.ToArray(typeof(string));
                    }
                    else if (currentValue != null && currentValue is byte[])
                    {
                        ArrayList newValueArrayList = new ArrayList((byte[])currentValue);

                        if (index == -1 || index >= newValueArrayList.Count)
                        {
                            newValueArrayList.Add((byte)newPropertyValue);
                        }
                        else
                        {
                            newValueArrayList.Insert(index, (byte)newPropertyValue);
                        }
                        currentValue = newValueArrayList.ToArray(typeof(byte));
                    }
                    else
                    {
                        Exception e =
                            new ArgumentException (
                                RegistryProviderStrings.PropertyNotMultivaluedChange);
                        WriteError (new ErrorRecord (
                            e,
                            e.GetType().FullName,
                            ErrorCategory.InvalidOperation,
                            propertyNameToSet));
                        continue;
                    }

                    try
                    {
                        key.SetValue(propertyNameToSet, currentValue);

                        // Now write out the value by getting the value from the store

                        object value = key.GetValue(propertyNameToSet);

                        PSObject result = new PSObject();
                        result.Properties.Add(new PSNoteProperty(property.Name, value));

                        WritePropertyObject(result, path);
                    }
                    catch (System.IO.IOException ioException)
                    {
                        // An exception occurred while trying to set the value. Write
                        // out the error.

                        WriteError (new ErrorRecord (ioException, ioException.GetType().FullName, ErrorCategory.WriteError, property.Name));
                    }
                    catch (System.Security.SecurityException securityException)
                    {
                        // An exception occurred while trying to set the value. Write
                        // out the error.

                        WriteError (new ErrorRecord (securityException, securityException.GetType().FullName, ErrorCategory.PermissionDenied, property.Name));
                    }
                    catch (System.UnauthorizedAccessException unauthorizedAccessException)
                    {
                        // An exception occurred while trying to get the key. Write
                        // out the error.

                        WriteError (new ErrorRecord (unauthorizedAccessException, unauthorizedAccessException.GetType().FullName, ErrorCategory.PermissionDenied, property.Name));
                    }
                } // if ShouldProcess
            }
        } // RemovePropertyValueAt  
Example #15
0
        /// <summary>
        /// Removes the specified value of a property on the item specified by the path.
        /// </summary>
        /// 
        /// <param name="path">
        /// The path to the item from which the property value should be removed.
        /// </param>
        /// 
        /// <param name="propertyName">
        /// The property to remove the value from.
        /// </param>
        /// 
        /// <param name="at">
        /// The position of the property value to remove.
        /// </param>
        ///
        /// <returns>
        /// Nothing. A PSObject representing the property and value that was 
        /// removed should be passed to the WriteObject() method.
        /// </returns>
        /// 
        /// <remarks>
        /// Implement this method when you are providing access to a data store
        /// that allows multivalued properties.
        /// </remarks>
        /// 
        public void RemovePropertyValueAt(
            string path,
            string propertyName,
            object at)
        {
            if (path == null)
            {
                throw tracer.NewArgumentNullException("path");
            }

            if (!CheckOperationNotAllowedOnHiveContainer(path))
            {
                return;
            }

            // Convert the at parameter to an int
            int index = GetIndexFromAt(at);

            if (index == -1)
            {
                // The key was not found, write out an error.

                ArgumentException exception = 
                    new ArgumentException(
                    RegistryProviderStrings.BadAtParam);
                WriteError (new ErrorRecord (exception, exception.GetType().FullName, ErrorCategory.InvalidArgument, path));

                return;
            }

            IRegistryWrapper key = GetRegkeyForPathWriteIfError(path, true);

            if (key == null)
            {
                return;
            }

            string action = RegistryProviderStrings.RemovePropertyValueAtAction;
            
            string resourceTemplate = RegistryProviderStrings.RemovePropertyValueAtResourceTemplate;

            string resource = 
                String.Format(
                    Host.CurrentCulture, 
                    resourceTemplate,
                    path,
                    propertyName,
                    at);

            if (ShouldProcess(resource, action))
            {
                try
                {
                    string propertyNameToRemove = GetPropertyName(propertyName);

                    // First get the current value

                    object currentValue = key.GetValue(propertyNameToRemove);

                    if (currentValue != null &&
                        currentValue is string[])
                    {
                        ArrayList newValueArrayList = new ArrayList((string[])currentValue);
                        newValueArrayList.RemoveAt(index);
                        currentValue = newValueArrayList.ToArray(typeof(string));
                    }
                    else if (currentValue != null &&
                        currentValue is byte[])
                    {
                        ArrayList newValueArrayList = new ArrayList((byte[])currentValue);
                        newValueArrayList.RemoveAt(index);
                        currentValue = newValueArrayList.ToArray(typeof(byte));
                    }
                    else
                    {
                        Exception e =
                            new ArgumentException (
                                RegistryProviderStrings.PropertyNotMultivalued);
                        WriteError (new ErrorRecord (
                            e,
                            e.GetType().FullName,
                            ErrorCategory.InvalidOperation,
                            propertyNameToRemove));
                        return;
                    }

                    key.SetValue(propertyNameToRemove, currentValue);
                }
                catch (System.IO.IOException ioException)
                {
                    // An exception occurred while trying to set the value. Write
                    // out the error.

                    WriteError (new ErrorRecord (ioException, ioException.GetType().FullName, ErrorCategory.WriteError, propertyName));
                }
                catch (System.Security.SecurityException securityException)
                {
                    // An exception occurred while trying to set the value. Write
                    // out the error.

                    WriteError (new ErrorRecord (securityException, securityException.GetType().FullName, ErrorCategory.PermissionDenied, propertyName));
                }
                catch (System.UnauthorizedAccessException unauthorizedAccessException)
                {
                    // An exception occurred while trying to get the key. Write
                    // out the error.

                    WriteError (new ErrorRecord (unauthorizedAccessException, unauthorizedAccessException.GetType().FullName, ErrorCategory.PermissionDenied, propertyName));
                }

            }
        } // RemovePropertyValueAt        
Example #16
0
        public void TestFindAttributeMethod50513(TestCaseAttribute testCase)
        {
            HeaderComment(testCase);

            ArgumentException ex = new ArgumentException("Unused, just need an instance for GetType() below");

            FindAttributeHelper(SampleText.Empty, TypeValue.WrongTypeAndValue, AttributeType.SupportedAttributes, false, FindResults.Exception, ex.GetType());
        }
Example #17
0
        public void TestFindTextMethod50615(TestCaseAttribute testCase)
        {
            HeaderComment(testCase);

            ArgumentException ex = new ArgumentException("Unused, just need an instance for GetType() below");

            FindTextHelper(SampleText.Random256, SearchText.Empty,
                   FindResults.Exception, FindResults.Exception, FindResults.Exception, FindResults.Exception, ex.GetType());
        }
Example #18
0
 private bool ParseKind(string type, out RegistryValueKind kind)
 {
     kind = RegistryValueKind.Unknown;
     if (string.IsNullOrEmpty(type))
     {
         return true;
     }
     bool flag = true;
     Exception innerException = null;
     try
     {
         kind = (RegistryValueKind) Enum.Parse(typeof(RegistryValueKind), type, true);
     }
     catch (InvalidCastException exception2)
     {
         innerException = exception2;
     }
     catch (ArgumentException exception3)
     {
         innerException = exception3;
     }
     if (innerException != null)
     {
         flag = false;
         string typeParameterBindingFailure = RegistryProviderStrings.TypeParameterBindingFailure;
         Exception exception = new ArgumentException(string.Format(Thread.CurrentThread.CurrentCulture, typeParameterBindingFailure, new object[] { type, typeof(RegistryValueKind).FullName }), innerException);
         base.WriteError(new ErrorRecord(exception, exception.GetType().FullName, ErrorCategory.InvalidArgument, type));
     }
     tracer.WriteLine("result = {0}", new object[] { (RegistryValueKind) kind });
     return flag;
 }
Example #19
0
 protected override void RenameItem(string path, string newName)
 {
     if (string.IsNullOrEmpty(path))
     {
         throw PSTraceSource.NewArgumentException("path");
     }
     if (string.IsNullOrEmpty(newName))
     {
         throw PSTraceSource.NewArgumentException("newName");
     }
     tracer.WriteLine("newName = {0}", new object[] { newName });
     string parentPath = this.GetParentPath(path, null);
     string str2 = this.MakePath(parentPath, newName);
     if (this.ItemExists(str2))
     {
         Exception exception = new ArgumentException(RegistryProviderStrings.RenameItemAlreadyExists);
         base.WriteError(new ErrorRecord(exception, exception.GetType().FullName, ErrorCategory.InvalidArgument, str2));
     }
     else
     {
         string renameItemAction = RegistryProviderStrings.RenameItemAction;
         string renameItemResourceTemplate = RegistryProviderStrings.RenameItemResourceTemplate;
         string target = string.Format(base.Host.CurrentCulture, renameItemResourceTemplate, new object[] { path, str2 });
         if (base.ShouldProcess(target, renameItemAction))
         {
             this.MoveRegistryItem(path, str2);
         }
     }
 }
Example #20
0
 private bool ErrorIfDestinationIsSourceOrChildOfSource(string sourcePath, string destinationPath)
 {
     tracer.WriteLine("destinationPath = {0}", new object[] { destinationPath });
     bool flag = false;
 Label_001D:
     if (string.Compare(sourcePath, destinationPath, StringComparison.OrdinalIgnoreCase) == 0)
     {
         flag = true;
     }
     else
     {
         string parentPath = this.GetParentPath(destinationPath, null);
         if (!string.IsNullOrEmpty(parentPath) && (string.Compare(parentPath, destinationPath, StringComparison.OrdinalIgnoreCase) != 0))
         {
             destinationPath = parentPath;
             goto Label_001D;
         }
     }
     if (flag)
     {
         Exception exception = new ArgumentException(RegistryProviderStrings.DestinationChildOfSource);
         base.WriteError(new ErrorRecord(exception, exception.GetType().FullName, ErrorCategory.InvalidArgument, destinationPath));
     }
     tracer.WriteLine("result = {0}", new object[] { flag });
     return flag;
 }
Example #21
0
        private void TS_Coverage_RangeFromPoint()
        {
            object temp = m_le.GetCurrentPropertyValue(
                                                    AutomationElement.BoundingRectangleProperty);
            Rect autoElementRect = (Rect)temp; ;
            Rect[] boundRects = new Rect[0];
            Point screenLocation = new Point();
            ArgumentException aeEx = new ArgumentException("bogus argument exception");
            TextPatternRange callingRange = _pattern.DocumentRange;
            TextPatternRange returnedRange = null;

            _tth.Range_GetBoundingRectangles(callingRange, ref boundRects, null, CheckType.Verification);

            // Point is center of topLeft corner
            screenLocation.X = autoElementRect.Left + 1;
            screenLocation.Y = autoElementRect.Top + 1;
            _tth.Pattern_RangeFromPoint(_pattern, ref returnedRange, screenLocation, null, CheckType.Verification);

            // Point is middle
            screenLocation.X = (autoElementRect.Left + autoElementRect.Right) / 2;
            screenLocation.Y = (autoElementRect.Top + autoElementRect.Bottom) / 2;
            _tth.Pattern_RangeFromPoint(_pattern, ref returnedRange, screenLocation, null, CheckType.Verification);

            // Point is inside bottom right
            screenLocation.X = autoElementRect.Right - 1;
            screenLocation.Y = autoElementRect.Bottom - 1;
            _tth.Pattern_RangeFromPoint(_pattern, ref returnedRange, screenLocation, null, CheckType.Verification);

            // Point is outside bottom right
            screenLocation.X = autoElementRect.Right + 1;
            screenLocation.Y = autoElementRect.Bottom + 1;
            _tth.Pattern_RangeFromPoint(_pattern, ref returnedRange, screenLocation, aeEx.GetType(), CheckType.Verification);

            // Point is outside top left
            screenLocation.X = autoElementRect.Left - 1;
            screenLocation.Y = autoElementRect.Top - 1;
            _tth.Pattern_RangeFromPoint(_pattern, ref returnedRange, screenLocation, aeEx.GetType(), CheckType.Verification);

            // Point is outsdie autoElement
            screenLocation.X = autoElementRect.Left - 1;
            screenLocation.Y = autoElementRect.Top - 1;
            _tth.Pattern_RangeFromPoint(_pattern, ref returnedRange, screenLocation, aeEx.GetType(), CheckType.Verification);

            // Point is outsdie autoElement
            screenLocation.X = Int32.MaxValue;
            screenLocation.Y = Int32.MaxValue;
            _tth.Pattern_RangeFromPoint(_pattern, ref returnedRange, screenLocation, aeEx.GetType(), CheckType.Verification);


            m_TestStep++;
        }
Example #22
0
 private IRegistryWrapper GetRegkeyForPathWriteIfError(string path, bool writeAccess)
 {
     IRegistryWrapper regkeyForPath = null;
     try
     {
         regkeyForPath = this.GetRegkeyForPath(path, writeAccess);
         if (regkeyForPath == null)
         {
             ArgumentException exception = new ArgumentException(RegistryProviderStrings.KeyDoesNotExist);
             base.WriteError(new ErrorRecord(exception, exception.GetType().FullName, ErrorCategory.InvalidArgument, path));
             return regkeyForPath;
         }
     }
     catch (ArgumentException exception2)
     {
         base.WriteError(new ErrorRecord(exception2, exception2.GetType().FullName, ErrorCategory.OpenError, path));
         return regkeyForPath;
     }
     catch (IOException exception3)
     {
         base.WriteError(new ErrorRecord(exception3, exception3.GetType().FullName, ErrorCategory.OpenError, path));
         return regkeyForPath;
     }
     catch (SecurityException exception4)
     {
         base.WriteError(new ErrorRecord(exception4, exception4.GetType().FullName, ErrorCategory.PermissionDenied, path));
         return regkeyForPath;
     }
     catch (UnauthorizedAccessException exception5)
     {
         base.WriteError(new ErrorRecord(exception5, exception5.GetType().FullName, ErrorCategory.PermissionDenied, path));
         return regkeyForPath;
     }
     return regkeyForPath;
 }
Example #23
0
        private void TS_ThrowTextPatternRangeExceptions()
        {
            int results = 0;
            bool isEqual = false;
            string text = "";
            object nullObject = null;
            TextPattern differentTextPattern = TextTestsHelper.GetDifferentTextPattern(m_le, CheckType.IncorrectElementConfiguration);
            TextPatternRange targetRange = null;

            ArgumentException aeEx = new ArgumentException("<<Fake argument>>");
            ArgumentNullException anEx = new ArgumentNullException("<<Fake null argument>>");
            TextPatternRange callingRange = null;
            ArgumentOutOfRangeException aoreEx = new ArgumentOutOfRangeException();

            //---------
            // Compare
            //---------

            // ArgumentNullException – if the range is null.
            callingRange = _pattern.DocumentRange.Clone();
            _tth.Range_Compare(callingRange, null, ref isEqual, anEx.GetType(), CheckType.Verification);

            // ArgumentException – if range is from another container.
            callingRange = _pattern.DocumentRange.Clone();
            _tth.Range_Compare(callingRange, differentTextPattern.DocumentRange, ref isEqual, aeEx.GetType(), CheckType.Verification);

            //------------------
            // CompareEndPoints
            //------------------

            // ArgumentNullException – if the range is null.
            callingRange = _pattern.DocumentRange.Clone();
            _tth.Range_CompareEndpoints(callingRange, TextPatternRangeEndpoint.Start, null,
                    TextPatternRangeEndpoint.Start, ref results, anEx.GetType(), CheckType.Verification);

            // ArgumentException – if range is from another container.
            callingRange = _pattern.DocumentRange.Clone();
            _tth.Range_CompareEndpoints(callingRange, TextPatternRangeEndpoint.Start, differentTextPattern.DocumentRange,
                    TextPatternRangeEndpoint.Start, ref results, aeEx.GetType(), CheckType.Verification);

            //---------------
            // FindAttribute
            //---------------

            // ArgumentException – if wrong type is specified.
            callingRange = _pattern.DocumentRange.Clone();
            _tth.Range_FindAttribute(callingRange, ref targetRange, TextPattern.AnimationStyleAttribute,
                    results, true, aeEx.GetType(), CheckType.Verification);

            // ArgumentNullException – if attribute value is null.
            callingRange = _pattern.DocumentRange.Clone();
            _tth.Range_FindAttribute(callingRange, ref targetRange, TextPattern.AnimationStyleAttribute,
                    null, true, anEx.GetType(), CheckType.Verification);

            // ArgumentNullException – if attribute is null.
            callingRange = _pattern.DocumentRange.Clone();
            _tth.Range_FindAttribute(callingRange, ref targetRange, null,
                    (object)text, true, anEx.GetType(), CheckType.Verification);

            //----------
            // FindText
            //----------

            // ArgumentNullException – if null is applied for search text argument.
            _tth.Range_FindText( callingRange, ref targetRange, null, true, true, anEx.GetType() , CheckType.Verification );

            // ArgumentException –if empty string is applied for search text argument.
            callingRange = _pattern.DocumentRange.Clone();
            _tth.Range_FindText(callingRange, ref targetRange, "", true, true, aeEx.GetType(), CheckType.Verification);

            //-------------------
            // GetAttributeValue
            //-------------------            

            // ArgumentNullException – if attribute is null.
            callingRange = _pattern.DocumentRange.Clone();
            _tth.Range_GetAttributeValue(callingRange, null, ref nullObject, anEx.GetType(), CheckType.Verification);

            //---------
            // GetText
            //---------

            // Shoduld return ArgumentOutOfRangeException per the spec.
            callingRange = _pattern.DocumentRange.Clone();
            _tth.Range_GetText(callingRange, ref text, Int32.MinValue, aoreEx.GetType(), CheckType.Verification);
            
            //---------------------
            // MoveEndpointByRange
            //---------------------

            // ArgumentNullException – if targetRange is null.
            callingRange = _pattern.DocumentRange.Clone();
            _tth.Range_MoveEndpointByRange(callingRange, TextPatternRangeEndpoint.Start, null,
                    TextPatternRangeEndpoint.Start, anEx.GetType(), CheckType.Verification);

            // ArgumentException – if range is from a different container.
            callingRange = _pattern.DocumentRange.Clone();
            _tth.Range_MoveEndpointByRange(callingRange, TextPatternRangeEndpoint.Start, differentTextPattern.DocumentRange,
                    TextPatternRangeEndpoint.Start, aeEx.GetType(), CheckType.Verification);
            m_TestStep++;
        }
        public void PruebaConstructor()
        {
            #region Caso 1: Operación Normal
              {
            #region Preparación.
            // Lee un mapa de prueba.
            const string archivoDeEntrada = @"..\..\Data\PruebaEscritorFormatoPolish.mp";
            IEscuchadorDeEstatus escuchadorDeEstatus = new EscuchadorDeEstatusPorOmisión();
            ManejadorDeMapa manejadorDeMapa = new ManejadorDeMapa(escuchadorDeEstatus);
            LectorDeFormatoPolish lector = new LectorDeFormatoPolish(manejadorDeMapa, archivoDeEntrada);
            IList<ElementoDelMapa> elementos = lector.ElementosDelMapa;

            const string archivoDeSalida = @"PruebaEscritorFormatoPolish.Caso1.mp";
            #endregion

            // Llama al constructor.
            new EscritorDeFormatoPolish(archivoDeSalida, elementos, escuchadorDeEstatus);

            #region Prueba Archivo de Salida.
            string[] líneasDeEntrada = LéeArchivo(archivoDeEntrada);
            string[] líneasDeSalida = LéeArchivo(archivoDeSalida);
            Assert.That(líneasDeSalida, Is.EqualTo(líneasDeEntrada), "Líneas");
            #endregion
              }
              #endregion

              #region Caso 2: Archivo de Salida inválido.
              {
            #region Preparación.
            // Crea elementos.
            IEscuchadorDeEstatus escuchadorDeEstatus = new EscuchadorDeEstatusPorOmisión();
            IList<ElementoDelMapa> elementos = new List<ElementoDelMapa>();

            // Archivo inválido.
            const string archivoDeSalidaInválido = @"ABC::\\&AAAA";

            // Excepción esperada.
            bool lanzóExcepción = false;
            ArgumentException excepciónEsperada = new ArgumentException(
              "The path is not of a legal form.");
            #endregion

            // Llama al constructor en prueba.
            try
            {
              new EscritorDeFormatoPolish(archivoDeSalidaInválido, elementos, escuchadorDeEstatus);
            }
            catch (Exception e)
            {
              // Prueba las propiedades de la excepción.
              Assert.That(e.GetType(), Is.EqualTo(excepciónEsperada.GetType()), "Tipo de Excepción");
              Assert.That(e.Message, Is.EqualTo(excepciónEsperada.Message), "Excepción.Message");

              lanzóExcepción = true;
            }

            Assert.That(lanzóExcepción, Is.True, "No se lanzó la excepción.");
              }
              #endregion

              #region Caso 3: Elemento con Campo Desconocido.
              {
            #region Preparación.
            // Crea elementos.
            IEscuchadorDeEstatus escuchadorDeEstatus = new EscuchadorDeEstatusPorOmisión();
            IList<ElementoDelMapa> elementos = new List<ElementoDelMapa> {
              new ElementoDesconocido(null, 0, "Clase", new List<Campo> {
            new CampoDesconocido() })};

            const string archivoDeSalida = @"PruebaEscritorFormatoPolish.Caso3.mp";

            // Excepción esperada.
            bool lanzóExcepción = false;
            ArgumentException excepciónEsperada = new ArgumentException(
              "Campo desconocido: GpsYv.ManejadorDeMapa.Pruebas.PruebaEscritorFormatoPolish+CampoDesconocido");
            #endregion

            // Llama al constructor en prueba.
            try
            {
              new EscritorDeFormatoPolish(archivoDeSalida, elementos, escuchadorDeEstatus);
            }
            catch (Exception e)
            {
              // Prueba las propiedades de la excepción.
              Assert.That(e.GetType(), Is.EqualTo(excepciónEsperada.GetType()), "Tipo de Excepción");
              Assert.That(e.Message, Is.EqualTo(excepciónEsperada.Message), "Excepción.Message");

              lanzóExcepción = true;
            }

            Assert.That(lanzóExcepción, Is.True, "No se lanzó la excepción.");
              }
              #endregion
        }