// Returns true if the expected result is right // Returns false if the expected result is wrong public bool PosTest1() { bool retVal = true; TestLibrary.TestFramework.BeginScenario("PosTest1: Create a new instance of MethodAccessException."); try { string expectValue = "HELLO"; ArgumentException notFoundException = new ArgumentException(); MethodAccessException myException = new MethodAccessException(expectValue, notFoundException); if (myException == null) { TestLibrary.TestFramework.LogError("001.1", "MethodAccessException instance can not create correctly."); retVal = false; } if (myException.Message != expectValue) { TestLibrary.TestFramework.LogError("001.2", "the Message should return " + expectValue); retVal = false; } if (!(myException.InnerException is ArgumentException)) { TestLibrary.TestFramework.LogError("001.3", "the InnerException should return ArgumentException."); retVal = false; } } catch (Exception e) { TestLibrary.TestFramework.LogError("001.0", "Unexpected exception: " + e); retVal = false; } return retVal; }
public void StreamIdCannotBeEmptyGuid() { var expectedEx = new ArgumentException(Exceptions.ArgumentEqualToValue.FormatWith(Guid.Empty), "streamId"); var actualEx = Assert.Throws<ArgumentException>(() => new Snapshot(Guid.Empty, 1, new Object())); Assert.Equal(expectedEx.Message, actualEx.Message); }
public bool PosTest1() { bool retVal = true; TestLibrary.TestFramework.BeginScenario("PosTest1: Using ctor1 to test the message property"); try { string randValue = TestLibrary.Generator.GetString(-55, false, c_MIN_STRING_LENGTH, c_MAX_STRING_LENGTH); ArgumentException argumentException = new ArgumentException(randValue); if (argumentException.Message != randValue) { TestLibrary.TestFramework.LogError("001", "The result is not the value as expected"); TestLibrary.TestFramework.LogInformation("Expected: " + randValue + "; Actual: " + argumentException.Message); retVal = false; } } catch (Exception e) { TestLibrary.TestFramework.LogError("002", "Unexpected exception: " + e); retVal = false; } return retVal; }
// Returns true if the expected result is right // Returns false if the expected result is wrong public bool PosTest2() { bool retVal = true; TestLibrary.TestFramework.BeginScenario("PosTest2: the parameter string is null."); try { string expectValue = null; ArgumentException dpoExpection = new ArgumentException(); MethodAccessException myException = new MethodAccessException(expectValue, dpoExpection); if (myException == null) { TestLibrary.TestFramework.LogError("002.1", "MethodAccessException instance can not create correctly."); retVal = false; } if (myException.Message == expectValue) { TestLibrary.TestFramework.LogError("002.2", "the Message should return the default value."); retVal = false; } if (!(myException.InnerException is ArgumentException)) { TestLibrary.TestFramework.LogError("002.3", "the InnerException should return MethodAccessException."); retVal = false; } } catch (Exception e) { TestLibrary.TestFramework.LogError("002.0", "Unexpected exception: " + e); retVal = false; } return retVal; }
public void HeaderNameCannotBeReservedName(String name) { var expectedEx = new ArgumentException(Exceptions.ReservedHeaderName.FormatWith(name), nameof(name)); var actualEx = Assert.Throws<ArgumentException>(() =>new Header(name, "value")); Assert.Equal(expectedEx.Message, actualEx.Message); }
public void TrueThrowsArgumentException() { var expectedEx = new ArgumentException("Custom Message", "paramName"); var actualEx = Assert.Throws<ArgumentException>(() => Verify.False(true, "paramName", "Custom Message")); Assert.Equal(expectedEx.Message, actualEx.Message); }
public void BaseTypeNotFoundThrowsArgumentException() { var expectedEx = new ArgumentException(Exceptions.TypeDoesNotDeriveFromBase.FormatWith(typeof(Exception), typeof(Object)), "paramName"); var actualEx = Assert.Throws<ArgumentException>(() => Verify.TypeDerivesFrom(typeof(Exception), typeof(Object), "paramName")); Assert.Equal(expectedEx.Message, actualEx.Message); }
public async Task SendAsync_SendCloseMessageType_ThrowsArgumentExceptionWithMessage(Uri server) { using (ClientWebSocket cws = await WebSocketHelper.GetConnectedWebSocket(server, TimeOutMilliseconds, _output)) { var cts = new CancellationTokenSource(TimeOutMilliseconds); string expectedInnerMessage = ResourceHelper.GetExceptionMessage( "net_WebSockets_Argument_InvalidMessageType", "Close", "SendAsync", "Binary", "Text", "CloseOutputAsync"); var expectedException = new ArgumentException(expectedInnerMessage, "messageType"); string expectedMessage = expectedException.Message; Assert.Throws<ArgumentException>(() => { Task t = cws.SendAsync(new ArraySegment<byte>(), WebSocketMessageType.Close, true, cts.Token); }); Assert.Equal(WebSocketState.Open, cws.State); } }
public void SetNext() { var r = new DiscardRedundantWorkThrottle(); var ax = new ArgumentException(); var cx = new OperationCanceledException(); // results are propagated var n = 0; r.SetNextToAction(() => n++).AssertRanToCompletion(); n.AssertEquals(1); r.SetNextToFunction(() => 2).AssertRanToCompletion().AssertEquals(2); r.SetNextToAsyncFunction(Tasks.RanToCompletion).AssertRanToCompletion(); r.SetNextToAsyncFunction(() => Task.FromResult(3)).AssertRanToCompletion().AssertEquals(3); // faulted tasks are propagated r.SetNextToAsyncFunction(() => Tasks.Faulted(ax)).AssertFailed<ArgumentException>(); r.SetNextToAsyncFunction(() => Tasks.Faulted<int>(ax)).AssertFailed<ArgumentException>(); // cancelled tasks are propagated r.SetNextToAsyncFunction(Tasks.Cancelled).AssertCancelled(); r.SetNextToAsyncFunction(Tasks.Cancelled<int>).AssertCancelled(); // thrown cancellation exceptions indicate cancellation r.SetNextToAsyncFunction(() => { throw cx; }).AssertCancelled(); r.SetNextToAsyncFunction<int>(() => { throw cx; }).AssertCancelled(); r.SetNextToAction(() => { throw cx; }).AssertCancelled(); r.SetNextToFunction<int>(() => { throw cx; }).AssertCancelled(); // thrown exceptions are propagated r.SetNextToAsyncFunction(() => { throw ax; }).AssertFailed<ArgumentException>(); r.SetNextToAsyncFunction<int>(() => { throw ax; }).AssertFailed<ArgumentException>(); r.SetNextToAction(() => { throw ax; }).AssertFailed<ArgumentException>(); r.SetNextToFunction<int>(() => { throw ax; }).AssertFailed<ArgumentException>(); }
public void Constructor_throws_if_invalid_cache_type() { var exception = new ArgumentException( Strings.Generated_View_Type_Super_Class(typeof(object)), "cacheType"); Assert.Equal(exception.Message, Assert.Throws<ArgumentException>(() => new DbMappingViewCacheTypeAttribute(typeof(SampleContext), typeof(object))).Message); }
public void EventTypeMustDeriveFromEvent() { // ReSharper disable NotResolvedInText var mapping = new ObjectEventTypeMapping(); var expectedEx = new ArgumentException(Exceptions.TypeDoesNotDeriveFromBase.FormatWith(typeof(Event), typeof(Object)), "eventType"); var ex = Assert.Throws<ArgumentException>(() => mapping.GetMappings(new Mock<IServiceProvider>().Object)); Assert.Equal(expectedEx.Message, ex.Message); // ReSharper restore NotResolvedInText }
public void Ctor() { DecoderFallbackException ex = new DecoderFallbackException(); Assert.Null(ex.BytesUnknown); Assert.Equal(default(int), ex.Index); Assert.Null(ex.StackTrace); Assert.Null(ex.InnerException); Assert.Equal(0, ex.Data.Count); ArgumentException arg = new ArgumentException(); Assert.Equal(ex.Message, arg.Message); }
public void Cannot_create_mapping_for_non_complex_property() { var property = EdmProperty.CreatePrimitive("P", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String)); var exception = new ArgumentException( Strings.StorageComplexPropertyMapping_OnlyComplexPropertyAllowed, "property"); Assert.Equal( exception.Message, Assert.Throws<ArgumentException>( () => new ComplexPropertyMapping(property)).Message); }
// Test the ArgumentException class. public void TestArgumentException() { ArgumentException e; ExceptionTester.CheckMain(typeof(ArgumentException), unchecked((int)0x80070057)); e = new ArgumentException(); AssertNull("ArgumentException (1)", e.ParamName); e = new ArgumentException("msg"); AssertNull("ArgumentException (2)", e.ParamName); e = new ArgumentException("msg", "p"); AssertEquals("ArgumentException (3)", "p", e.ParamName); e = new ArgumentException("msg", "p", e); AssertEquals("ArgumentException (4)", "p", e.ParamName); }
public void CreateODataError_CopiesInnerExceptionInformation() { Exception innerException = new ArgumentException("innerException"); Exception exception = new InvalidOperationException("exception", innerException); var error = new HttpError(exception, true); ODataError oDataError = error.CreateODataError(); Assert.Equal("An error has occurred.", oDataError.Message); Assert.Equal("exception", oDataError.InnerError.Message); Assert.Equal("System.InvalidOperationException", oDataError.InnerError.TypeName); Assert.Equal("innerException", oDataError.InnerError.InnerError.Message); Assert.Equal("System.ArgumentException", oDataError.InnerError.InnerError.TypeName); }
public void CompletedCancelledFaultedTask() { Tasks.RanToCompletion().AssertRanToCompletion(); Tasks.RanToCompletion(1).AssertRanToCompletion().AssertEquals(1); Tasks.Cancelled().AssertCancelled(); Tasks.Cancelled<int>().AssertCancelled(); var ex = new ArgumentException(); Tasks.Faulted(ex).AssertFailed<ArgumentException>().AssertEquals(ex); Tasks.Faulted<int>(ex).AssertFailed<ArgumentException>().AssertEquals(ex); Tasks.Faulted(new[] { ex, ex }).AssertFailed<AggregateException>().InnerExceptions.AssertSequenceEquals(new[] { ex, ex }); Tasks.Faulted<int>(new[] { ex, ex }).AssertFailed<AggregateException>().InnerExceptions.AssertSequenceEquals(new[] { ex, ex }); }
public static void Ctor() { EncoderFallbackException ex = new EncoderFallbackException(); Assert.Equal(default(char), ex.CharUnknown); Assert.Equal(default(char), ex.CharUnknownHigh); Assert.Equal(default(char), ex.CharUnknownLow); Assert.Equal(default(int), ex.Index); Assert.Null(ex.StackTrace); Assert.Null(ex.InnerException); Assert.Equal(0, ex.Data.Count); ArgumentException arg = new ArgumentException(); Assert.Equal(arg.Message, ex.Message); }
public void Constructors_throw_if_invalid_context_type() { var cacheTypeName = typeof(SampleMappingViewCache).AssemblyQualifiedName; var exception = new ArgumentException( Strings.DbMappingViewCacheTypeAttribute_InvalidContextType(typeof(object)), "contextType"); Assert.Equal(exception.Message, Assert.Throws<ArgumentException>(() => new DbMappingViewCacheTypeAttribute(typeof(object), typeof(SampleMappingViewCache))).Message); Assert.Equal(exception.Message, Assert.Throws<ArgumentException>(() => new DbMappingViewCacheTypeAttribute(typeof(object), cacheTypeName)).Message); }
public bool PosTest2() { bool retVal = true; TestLibrary.TestFramework.BeginScenario("PosTest2: Using ctor2 to test the message property"); try { string randValue = TestLibrary.Generator.GetString(-55, false, c_MIN_STRING_LENGTH, c_MAX_STRING_LENGTH); string paramName = TestLibrary.Generator.GetString(-55, false, c_MIN_STRING_LENGTH, c_MAX_STRING_LENGTH); ArgumentException argumentException = new ArgumentException(randValue, paramName); string expectedWindows = randValue + "\r\nParameter name: " + paramName; string expectedMac = randValue + "\nParameter name: " + paramName; if ((argumentException.Message != randValue)) { if (!Utilities.IsWindows) { if (argumentException.Message != expectedMac) { TestLibrary.TestFramework.LogError("003", "The result is not the value as expected"); TestLibrary.TestFramework.LogInformation("Expected: " + expectedMac + "; Actual: " + argumentException.Message); retVal = false; } } else if (argumentException.Message != expectedWindows) { TestLibrary.TestFramework.LogError("004", "The result is not the value as expected"); TestLibrary.TestFramework.LogInformation("Expected: " + expectedWindows + "; Actual: " + argumentException.Message); retVal = false; } } } catch (Exception e) { TestLibrary.TestFramework.LogError("005", "Unexpected exception: " + e); retVal = false; } return retVal; }
public bool PosTest1() { bool retVal = true; TestLibrary.TestFramework.BeginScenario("PosTest1:Initialize the InvalidCastException instance with message and InnerException 1"); try { string message = "HelloWorld"; ArgumentException innerException = new ArgumentException(); InvalidCastException myException = new InvalidCastException(message, innerException); if (myException == null || myException.Message != message || !myException.InnerException.Equals(innerException)) { TestLibrary.TestFramework.LogError("001", "the InvalidCastException with message and innerException instance creating failed"); retVal = false; } } catch (Exception e) { TestLibrary.TestFramework.LogError("002", "Unexpect exception:" + e); retVal = false; } return retVal; }
public bool PosTest2() { bool retVal = true; TestLibrary.TestFramework.BeginScenario("PosTest2:Initialize the InvalidCastException instance with message and InnerException 2"); try { string message = null; ArgumentException innerException = new ArgumentException(); InvalidCastException myException = new InvalidCastException(message, innerException); if (myException == null || myException.Message == null || !myException.InnerException.Equals(innerException)) { TestLibrary.TestFramework.LogError("003", "Initialize the InvalidCastException instance with null message not succeed"); retVal = false; } } catch (Exception e) { TestLibrary.TestFramework.LogError("004", "Unexpect exception:" + e); retVal = false; } return retVal; }
public bool PosTest1() { bool retVal = true; TestLibrary.TestFramework.BeginScenario("PosTest1: Call ctor to construct a new instance"); try { ArgumentException argumentException = new ArgumentException(); if (argumentException == null) { TestLibrary.TestFramework.LogError("001", "The result is not the value as expected"); retVal = false; } } catch (Exception e) { TestLibrary.TestFramework.LogError("002", "Unexpected exception: " + e); retVal = false; } return retVal; }
// Returns true if the expected result is right // Returns false if the expected result is wrong public bool PosTest1() { bool retVal = true; TestLibrary.TestFramework.BeginScenario("PosTest1: Create a new ArrayTypeMismatchException instance. "); try { string expectValue = "Hello"; ArgumentException myAieldExcption = new ArgumentException(); ArrayTypeMismatchException myException = new ArrayTypeMismatchException(expectValue, myAieldExcption); if (myException == null) { TestLibrary.TestFramework.LogError("001.1", " the constructor should not return null. "); retVal = false; } else { if (myException.Message!=expectValue) { TestLibrary.TestFramework.LogError("001.2", " the expection message should return " + expectValue); retVal = false; } if (!(myException.InnerException is ArgumentException)) { TestLibrary.TestFramework.LogError("001.3", " the inner expection should return the specified exception."); retVal = false; } } } catch (Exception e) { TestLibrary.TestFramework.LogError("001.0", "Unexpected exception: " + e); retVal = false; } return retVal; }
/// <summary> /// </summary> protected override void BeginProcessing() { // Validate that WinRM is OK and that the user can query system state RemotingCommandUtil.CheckRemotingCmdletPrerequisites(); PSSessionConfigurationCommandUtilities.ThrowIfNotAdministrator(); // Get the configuration for the given endpoint Collection<PSObject> configurations = null; using (PowerShellApi invoker = PowerShellApi.Create(RunspaceMode.CurrentRunspace)) { invoker.AddCommand("Get-PSSessionConfiguration").AddParameter("Name", this.ConfigurationName).AddParameter("ErrorAction", "Stop"); try { // If the session name doesn't exist, this Invoke() throws configurations = invoker.Invoke(); } catch (ActionPreferenceStopException e) { ThrowTerminatingError(new ErrorRecord(e.ErrorRecord.Exception, "CouldNotFindSessionConfiguration", ErrorCategory.ObjectNotFound, this.ConfigurationName)); } } // The validator that will be applied to the role lookup Func<string, bool> validator = (role) => true; if (!String.IsNullOrEmpty(this.Username)) { if (this.Username.IndexOf("\\", StringComparison.OrdinalIgnoreCase) >= 0) { validator = null; // Convert DOMAIN\user to the upn (user@DOMAIN) string[] upnComponents = this.Username.Split(Utils.Separators.Backslash); if (upnComponents.Length == 2) { this.Username = upnComponents[1] + "@" + upnComponents[0]; } } try { System.Security.Principal.WindowsPrincipal windowsPrincipal = new System.Security.Principal.WindowsPrincipal( new System.Security.Principal.WindowsIdentity(this.Username)); validator = (role) => windowsPrincipal.IsInRole(role); } catch (SecurityException e) { // Identity could not be mapped string message = StringUtil.Format(RemotingErrorIdStrings.CouldNotResolveUsername, this.Username); ArgumentException ioe = new ArgumentException(message, e); ErrorRecord er = new ErrorRecord(ioe, "CouldNotResolveUsername", ErrorCategory.InvalidArgument, this.Username); ThrowTerminatingError(er); return; } } foreach (PSObject foundConfiguration in configurations) { string configFilePath = null; PSPropertyInfo configFilePathProperty = foundConfiguration.Properties["ConfigFilePath"]; if (configFilePathProperty != null) { configFilePath = configFilePathProperty.Value as string; } // If we could not get the config file, throw an error that it's not a configuration created with // config file-based session configurations. if (configFilePath == null) { string configurationName = (string)foundConfiguration.Properties["Name"].Value; string message = StringUtil.Format(RemotingErrorIdStrings.SessionConfigurationMustBeFileBased, configurationName); ArgumentException ioe = new ArgumentException(message); ErrorRecord er = new ErrorRecord(ioe, "SessionConfigurationMustBeFileBased", ErrorCategory.InvalidArgument, foundConfiguration); WriteError(er); continue; } InitialSessionState iss = InitialSessionState.CreateFromSessionConfigurationFile(configFilePath, validator); if (this.Full) { WriteObject(iss); } else { using (PowerShellApi analyzer = PowerShellApi.Create(iss)) { analyzer.AddCommand("Get-Command").AddParameter("CommandType", "All"); foreach (PSObject output in analyzer.Invoke()) { WriteObject(output); } } } } }
public void EmptyValueThrowsArgumentException() { var expectedEx = new ArgumentException(Exceptions.MustContainOneNonWhitespaceCharacter, "paramName"); var actualEx = Assert.Throws<ArgumentException>(() => Verify.NotNullOrWhiteSpace(String.Empty, "paramName")); Assert.Equal(expectedEx.Message, actualEx.Message); }
public void LocalCryptographyClientRequiresJsonWebKey() { ArgumentException ex = Assert.Throws <ArgumentNullException>(() => new LocalCryptographyClient(null)); Assert.AreEqual("jsonWebKey", ex.ParamName); }
[Test] // .ctor (SerializationInfo, StreamingContext) public void Constructor3() { SerializationInfo si; MyException ex; Exception inner; inner = new ArgumentException(); si = new SerializationInfo(typeof(Exception), new FormatterConverter()); si.AddValue("ClassName", "CLASS"); si.AddValue("Message", "MSG"); si.AddValue("InnerException", inner, typeof(Exception)); si.AddValue("HelpURL", "URL"); si.AddValue("StackTraceString", null); si.AddValue("RemoteStackTraceString", null); si.AddValue("RemoteStackIndex", 0); si.AddValue("HResult", 10); si.AddValue("Source", "SRC"); si.AddValue("ExceptionMethod", null); Hashtable data = new Hashtable(); data.Add("XX", "ZZ"); si.AddValue("Data", data, typeof(IDictionary)); ex = new MyException(si, new StreamingContext()); Assert.AreEqual("MSG", ex.Message, "#A1"); Assert.AreSame(inner, ex.InnerException, "#A2"); Assert.AreEqual("URL", ex.HelpLink, "#A3"); Assert.AreEqual(10, ex.HResult, "#A4"); Assert.AreEqual("SRC", ex.Source, "#A5"); #if NET_2_0 Assert.IsNotNull(ex.Data, "#A6"); Assert.AreEqual(1, ex.Data.Keys.Count, "#A7"); Assert.AreEqual("ZZ", ex.Data ["XX"], "#A8"); #endif inner = null; si = new SerializationInfo(typeof(Exception), new FormatterConverter()); si.AddValue("ClassName", "CLASS"); si.AddValue("Message", null); si.AddValue("InnerException", inner, typeof(Exception)); si.AddValue("HelpURL", "URL"); si.AddValue("StackTraceString", null); si.AddValue("RemoteStackTraceString", null); si.AddValue("RemoteStackIndex", 0); si.AddValue("HResult", 10); si.AddValue("Source", "SRC"); si.AddValue("ExceptionMethod", null); ex = new MyException(si, new StreamingContext()); Assert.IsNotNull(ex.Message, "#B1"); Assert.IsTrue(ex.Message.IndexOf("CLASS") != -1, "#B2"); Assert.IsNull(ex.InnerException, "#B3"); Assert.AreEqual("URL", ex.HelpLink, "#B4"); Assert.AreEqual(10, ex.HResult, "#B5"); Assert.AreEqual("SRC", ex.Source, "#B6"); #if NET_2_0 Assert.IsNotNull(ex.Data, "#B7"); Assert.AreEqual(0, ex.Data.Keys.Count, "#B8"); #endif }
public ParseCommandUndo(string parameters, ParseCommandStacks stacks) { var badCommandException = new ArgumentException("command is invalid for Undo: " + parameters); string[] parts = parameters.Split(new char[] { ':' }, 3); int times = 1; bool isSpecificStack = false; CommandTypes stackType = CommandTypes.Invalid; if (parts.Length > 1) { isSpecificStack = true; switch (parts[1]) { case "f": stackType = CommandTypes.Foreground; break; case "b": stackType = CommandTypes.Background; break; case "g": stackType = CommandTypes.Glyph; break; case "e": stackType = CommandTypes.Effect; break; case "m": stackType = CommandTypes.Mirror; break; case "a": isSpecificStack = false; break; default: throw badCommandException; } } if (parts.Length >= 1 && parts[0] != "") { times = int.Parse(parts[0]); } for (int i = 0; i < times; i++) { ParseCommandBase behavior = null; if (!isSpecificStack) { if (stacks.All.Count != 0) { behavior = stacks.All.Pop(); switch (behavior.CommandType) { case CommandTypes.Foreground: stacks.Foreground.Pop(); break; case CommandTypes.Background: stacks.Background.Pop(); break; case CommandTypes.Glyph: stacks.Glyph.Pop(); break; case CommandTypes.Mirror: stacks.Mirror.Pop(); break; case CommandTypes.Effect: stacks.Effect.Pop(); break; default: break; } } else { break; } } else { switch (stackType) { case CommandTypes.Foreground: if (stacks.Foreground.Count != 0) { behavior = stacks.Foreground.Pop(); } break; case CommandTypes.Background: if (stacks.Background.Count != 0) { behavior = stacks.Background.Pop(); } break; case CommandTypes.Glyph: if (stacks.Glyph.Count != 0) { behavior = stacks.Glyph.Pop(); } break; case CommandTypes.Mirror: if (stacks.Mirror.Count != 0) { behavior = stacks.Mirror.Pop(); } break; case CommandTypes.Effect: if (stacks.Effect.Count != 0) { behavior = stacks.Effect.Pop(); } break; default: break; } if (behavior != null) { List <ParseCommandBase> all = new List <ParseCommandBase>(stacks.All); all.Remove(behavior); stacks.All = new Stack <ParseCommandBase>(all); } } } CommandType = CommandTypes.PureCommand; }
public void FromString(string str) { Dictionary <string, string> settings = new Dictionary <string, string>(); string[] components = str.Split(','); foreach (string component in components) { string[] pair = component.Trim().Split('='); if (pair == null || pair.Length != 2) { var e = new ArgumentException("invalid component to be used as key-value pair:", component); Exceptions.Throw(e, LOGGER); } settings.Add(pair[0], pair[1]); } string ipAddress; if (!settings.TryGetValue("IP", out ipAddress)) { Exceptions.Throw(new ArgumentException("cannot find IP entry"), LOGGER); } ipAddress = ipAddress.Split('/').Last(); string port; if (!settings.TryGetValue("Port", out port)) { Exceptions.Throw(new ArgumentException("cannot find Port entry"), LOGGER); } int portNumber = 0; int.TryParse(port, out portNumber); string hostName; if (!settings.TryGetValue("HostName", out hostName)) { Exceptions.Throw(new ArgumentException("cannot find HostName entry"), LOGGER); } string memory; if (!settings.TryGetValue("Memory", out memory)) { Exceptions.Throw(new ArgumentException("cannot find Memory entry"), LOGGER); } int memoryInMegaBytes = 0; int.TryParse(memory, out memoryInMegaBytes); string core; if (!settings.TryGetValue("Core", out core)) { Exceptions.Throw(new ArgumentException("cannot find Core entry"), LOGGER); } int vCore = 0; int.TryParse(core, out vCore); IPEndPoint ipEndPoint = new IPEndPoint(IPAddress.Parse(ipAddress), portNumber); _nodeDescriptor = new NodeDescriptorImpl(); _nodeDescriptor.InetSocketAddress = ipEndPoint; _nodeDescriptor.HostName = hostName; _type = EvaluatorType.CLR; _megaBytes = memoryInMegaBytes; _virtualCore = vCore; }
public static void ValidateArgumentException(string parameterName, string expectedMessage, ArgumentException exception) { Assert.Equal(string.Format("{0}{1}Parameter name: {2}", expectedMessage, Environment.NewLine, parameterName), exception.Message); }
private static CommonSecurityDescriptor CreateInternalPatched(ResourceType resourceType, bool isContainer, string name, SafeHandle handle, AccessControlSections includeSections, bool createByName, ExceptionFromErrorCode exceptionFromErrorCode, object exceptionContext) { if (createByName && name is null) { throw new ArgumentNullException(nameof(name)); } else if (!createByName && handle is null) { throw new ArgumentNullException(nameof(handle)); } Contract.EndContractBlock(); try { object[] parameters = { resourceType, AddLongPathPrefixAndFixSeparators(name), handle, includeSections, null }; var error = (int)win32GetSecurityInfo.Value.Invoke(null, parameters); if (error != ERROR_SUCCESS) { Exception exception = null; if (exceptionFromErrorCode != null) { exception = exceptionFromErrorCode(error, name, handle, exceptionContext); } if (exception is null) { if (error == ERROR_ACCESS_DENIED) { exception = new UnauthorizedAccessException(); } else if (error == ERROR_INVALID_OWNER) { exception = new InvalidOperationException(EnvGetResString1("AccessControl_InvalidOwner")); } else if (error == ERROR_INVALID_PRIMARY_GROUP) { exception = new InvalidOperationException(EnvGetResString1("AccessControl_InvalidGroup")); } else if (error == ERROR_INVALID_PARAMETER) { exception = new InvalidOperationException(EnvGetResString2("AccessControl_UnexpectedError", error)); } else if (error == ERROR_INVALID_NAME) { exception = new ArgumentException(EnvGetResString2("Argument_InvalidName"), nameof(name)); } else if (error == ERROR_FILE_NOT_FOUND) { exception = (name is null ? new FileNotFoundException() : new FileNotFoundException(name)); } else if (error == ERROR_NO_SECURITY_ON_OBJECT) { exception = new NotSupportedException(EnvGetResString1("AccessControl_NoAssociatedSecurity")); } else { Contract.Assert(false, string.Format(CultureInfo.InvariantCulture, "Win32GetSecurityInfo() failed with unexpected error code {0}", error)); exception = new InvalidOperationException(EnvGetResString2("AccessControl_UnexpectedError", error)); } } throw exception; } var rawSD = (RawSecurityDescriptor)parameters[parameters.Length - 1]; return((CommonSecurityDescriptor)csdCtor.Value .Invoke(new object[] { isContainer, false, rawSD, true })); } catch (TargetInvocationException ex) { if (ex.InnerException != null) { ExceptionDispatchInfo.Capture(ex.InnerException).Throw(); } throw; } catch (NullReferenceException nre) { if (win32GetSecurityInfo.Value is null) { throw new MissingMethodException("Method 'System.Security.AccessControl.Win32.GetSecurityInfo' not found.", nre.InnerException ?? nre); } else if (csdCtor.Value is null) { throw new MissingMethodException("Constructor 'CommonSecurityDescriptor' with 4 args not found.", nre.InnerException ?? nre); } throw; } }
public async Task CloseAsync_CloseDescriptionIsMaxLengthPlusOne_ThrowsArgumentException(Uri server) { string closeDescription = new string('C', CloseDescriptionMaxLength + 1); using (ClientWebSocket cws = await WebSocketHelper.GetConnectedWebSocket(server, TimeOutMilliseconds, _output)) { var cts = new CancellationTokenSource(TimeOutMilliseconds); string expectedInnerMessage = ResourceHelper.GetExceptionMessage( "net_WebSockets_InvalidCloseStatusDescription", closeDescription, CloseDescriptionMaxLength); var expectedException = new ArgumentException(expectedInnerMessage, "statusDescription"); string expectedMessage = expectedException.Message; Assert.Throws<ArgumentException>(() => { Task t = cws.CloseAsync(WebSocketCloseStatus.NormalClosure, closeDescription, cts.Token); }); Assert.Equal(WebSocketState.Open, cws.State); } }
public static void GetResult_FaultedTask_MultipleExceptions_ThrowsFirstException() { var exception = new ArgumentException("uh oh"); var tcs = new TaskCompletionSource<string>(); tcs.SetException(new Exception[] { exception, new InvalidOperationException("uh oh") }); Task<string> task = tcs.Task; // Task.GetAwaiter and Task<T>.GetAwaiter Assert.Same(exception, Assert.Throws<ArgumentException>(() => ((Task)task).GetAwaiter().GetResult())); Assert.Same(exception, Assert.Throws<ArgumentException>(() => task.GetAwaiter().GetResult())); // w/ ConfigureAwait false and true Assert.Same(exception, Assert.Throws<ArgumentException>(() => ((Task)task).ConfigureAwait(false).GetAwaiter().GetResult())); Assert.Same(exception, Assert.Throws<ArgumentException>(() => ((Task)task).ConfigureAwait(true).GetAwaiter().GetResult())); Assert.Same(exception, Assert.Throws<ArgumentException>(() => task.ConfigureAwait(false).GetAwaiter().GetResult())); Assert.Same(exception, Assert.Throws<ArgumentException>(() => task.ConfigureAwait(true).GetAwaiter().GetResult())); }
public static Exception ToIotHubClientContract(Error error) { Exception retException; if (error == null) { retException = new IotHubException("Unknown error."); return(retException); } string message = error.Description; string trackingId = null; if (error.Info != null && error.Info.TryGetValue(AmqpIoTConstants.TrackingId, out trackingId)) { message = "{0}{1}{2}".FormatInvariant(message, Environment.NewLine, "Tracking Id:" + trackingId); } if (error.Condition.Equals(TimeoutError)) { retException = new TimeoutException(message); } else if (error.Condition.Equals(AmqpErrorCode.NotFound)) { retException = new DeviceNotFoundException(message, (Exception)null); } else if (error.Condition.Equals(AmqpErrorCode.NotImplemented)) { retException = new NotSupportedException(message); } else if (error.Condition.Equals(MessageLockLostError)) { retException = new DeviceMessageLockLostException(message); } else if (error.Condition.Equals(AmqpErrorCode.NotAllowed)) { retException = new InvalidOperationException(message); } else if (error.Condition.Equals(AmqpErrorCode.UnauthorizedAccess)) { retException = new UnauthorizedException(message); } else if (error.Condition.Equals(ArgumentError)) { retException = new ArgumentException(message); } else if (error.Condition.Equals(ArgumentOutOfRangeError)) { retException = new ArgumentOutOfRangeException(message); } else if (error.Condition.Equals(AmqpErrorCode.MessageSizeExceeded)) { retException = new MessageTooLargeException(message); } else if (error.Condition.Equals(AmqpErrorCode.ResourceLimitExceeded)) { retException = new DeviceMaximumQueueDepthExceededException(message); } else if (error.Condition.Equals(DeviceContainerThrottled)) { retException = new IotHubThrottledException(message, null); } else if (error.Condition.Equals(IotHubSuspended)) { retException = new IotHubSuspendedException(message); } else { retException = new IotHubException(message); } if (trackingId != null && retException is IotHubException) { IotHubException iotHubException = (IotHubException)retException; iotHubException.TrackingId = trackingId; } return(retException); }
/// <summary> /// Remove a job from the store /// </summary> /// <param name="job">job object to remove</param> public override void RemoveJob(Job2 job) { if (job == null) { throw new ArgumentNullException("job"); } _structuredTracer.RemoveJobStarted(job.InstanceId); var jobInMemory = _jobRepository.GetItem(job.InstanceId); if (jobInMemory == null) { // the specified job is not available in memory // load the job repository PopulateJobRepositoryIfRequired(); } if (!(job is ContainerParentJob)) { throw new InvalidOperationException(Resources.CannotRemoveWorkflowJobDirectly); } _tracer.WriteMessage(String.Format(CultureInfo.InvariantCulture, "WorkflowJobSourceAdapter: Removing Workflow job with instance id: {0}", job.InstanceId)); Exception innerException = null; foreach (Job childJob in job.ChildJobs) { PSWorkflowJob workflowChildJob = childJob as PSWorkflowJob; if (workflowChildJob == null) { continue; } try { GetJobManager().RemoveJob(workflowChildJob.InstanceId); _structuredTracer.JobRemoved(job.InstanceId, childJob.InstanceId, workflowChildJob.WorkflowGuid); } catch (ArgumentException exception) { //ignoring the error message and just logging them into ETW _tracer.WriteMessage(String.Format(CultureInfo.InvariantCulture, "WorkflowJobSourceAdapter: Ignoring the exception. Exception details: {0}", exception)); innerException = exception; _structuredTracer.JobRemoveError(job.InstanceId, childJob.InstanceId, workflowChildJob.WorkflowGuid, exception.Message); } } // remove the container parent job from repository try { _jobRepository.Remove((ContainerParentJob)job); } catch (ArgumentException exception) { //ignoring the error message and just logging them into ETW _tracer.WriteMessage(String.Format(CultureInfo.InvariantCulture, "WorkflowJobSourceAdapter: Ignoring the exception. Exception details: {0}", exception)); innerException = exception; } job.Dispose(); // Failed to remove the job? if (innerException != null) { ArgumentException exc = new ArgumentException(Resources.WorkflowChildCouldNotBeRemoved, "job", innerException); throw exc; } }
/// <summary> /// Performs an asynchronous fetch from the cache index. /// </summary> /// <param name="parameters">The parameters.</param> /// <param name="timeoutMilliseconds">The timeout milliseconds.</param> public void FetchAsynch(Object parameters, int timeoutMilliseconds) { var fetchParameters = (FetchParameters)parameters; var request = (HttpWebRequest)WebRequest.Create(fetchParameters.CacheIndex.GetAbsouteUri(fetchParameters.CacheIndexItem)); request.Method = "GET"; //request.Proxy = null; request.AutomaticDecompression = DecompressionMethods.GZip; if (fetchParameters.Headers != null && fetchParameters.Headers.Any()) { foreach (string key in fetchParameters.Headers.Keys) { if (key.ToLower() == "accept") { request.Accept = fetchParameters.Headers[key]; } else if (key.ToLower() == "content-type") { request.ContentType = fetchParameters.Headers[key]; } else if (key.ToLower() == "host") { //TODO: add the URL explaining PCL incompatibility Exception ex = new ArgumentException("Host header value cannot be set in PCL libraries."); Device.Log.Error(ex); throw ex; } else { request.Headers[key] = fetchParameters.Headers[key]; } } } RequestState state = new RequestState() { Request = request, CacheFileName = fetchParameters.CacheIndex.GetCachePath(fetchParameters.CacheIndexItem), CacheIndex = fetchParameters.CacheIndex, CacheIndexItem = fetchParameters.CacheIndexItem, RelativeUri = fetchParameters.CacheIndexItem.RelativeUri, BaseUri = fetchParameters.CacheIndex.BaseUri, Expiration = DateTime.UtcNow.Add(fetchParameters.DefaultExpiration), }; try { // Start the asynchronous request. IAsyncResult result = request.BeginGetResponse(ResponseCallback, state); if (!_allDone.WaitOne(timeoutMilliseconds)) { try { request.Abort(); } catch (Exception) { } // .Abort() always throws exception return; } } catch (Exception exc) { Device.Log.Error("CacheFetcher.FetchAsynch encountered exception", exc); _autoEvent.Set(); } }
/// <summary> /// This is task which validates data /// Documentation: https://github.com/CommunityHiQ/Frends.Community.SecurityThreatDiagnostics /// Throws application exception if diagnostics find vulnerability from the payload challenge. /// </summary> /// <param name="validation">Runtime element to be diagnosted.</param> /// <param name="options">Options for the runtime validation.</param> /// <param name="cancellationToken"></param> /// <returns>{bool challenges for validation} </returns> public static SecurityThreatDiagnosticsResult ChallengeAgainstSecurityThreats( [PropertyTab] Validation validation, [PropertyTab] Options options, CancellationToken cancellationToken) { cancellationToken.ThrowIfCancellationRequested(); Dictionary <string, string> dictionary = new Dictionary <string, string>(); StringBuilder validationChallengeMessage = new StringBuilder(); validationChallengeMessage .Append("Payload challenged for input validation [") .Append(validation.Payload) .Append("] \n\n"); StringBuilder innerExceptionMessage = new StringBuilder(); innerExceptionMessage .Append("Payload challenged for input validation [") .Append(validation.Payload) .Append("] \n\n"); ConcurrentDictionary <string, SecurityRuleFilter> ruleDictionary = SecurityFilterReader.Instance; foreach (var entry in ruleDictionary) { ChallengeCharacterSetEncoding(validation.Payload, options); string base64DecodedPayload = DecodeBase64Encoding(validation.Payload); if (entry.Value.Rule.IsMatch(validation.Payload) || entry.Value.Rule.IsMatch(base64DecodedPayload) && options.Base64Decode) { validationChallengeMessage .Append("id [") .Append(entry.Key) .Append("]") .Append(" contains vulnerability [") .Append(entry.Value.Description) .Append("], ") .Append("encoded value [") .Append(base64DecodedPayload) .Append("]"); dictionary.Add(entry.Key, validationChallengeMessage.ToString()); innerExceptionMessage .Append("id [") .Append(entry.Key) .Append("] ") .Append("Validation pattern [") .Append(entry.Value.Rule.ToString()) .Append("], ") .Append("encoded value [") .Append(base64DecodedPayload) .Append("]"); } } if (dictionary.Count > 0) { ArgumentException argumentException = new ArgumentException("Invalid argument information " + innerExceptionMessage.ToString()); ApplicationException applicationException = new ApplicationException(validationChallengeMessage.ToString(), argumentException); throw applicationException; } SecurityThreatDiagnosticsResult securityThreatDiagnosticsResult = new SecurityThreatDiagnosticsResult(); securityThreatDiagnosticsResult.IsValid = true; return(securityThreatDiagnosticsResult); }
public CngProvider(string provider) { ArgumentException.ThrowIfNullOrEmpty(provider); _provider = provider; }
}//End BeginProcessing() #region private private void QuickConfigRemoting(bool serviceonly) { IWSManSession m_SessionObj = null; try { string transport; IWSManEx wsmanObject = (IWSManEx) new WSManClass(); m_SessionObj = (IWSManSession)wsmanObject.CreateSession(null, 0, null); string xpathEnabled = string.Empty; string xpathText = string.Empty; string xpathUpdate = string.Empty; string analysisInputXml = string.Empty; string action = string.Empty; string xpathStatus = string.Empty; string xpathResult = string.Empty; if (!usessl) { transport = "http"; } else { transport = "https"; } if (serviceonly) { analysisInputXml = @"<AnalyzeService_INPUT xmlns=""http://schemas.microsoft.com/wbem/wsman/1/config/service""></AnalyzeService_INPUT>"; action = "AnalyzeService"; } else { string openAllProfiles = skipNetworkProfileCheck ? "<Force/>" : String.Empty; analysisInputXml = @"<Analyze_INPUT xmlns=""http://schemas.microsoft.com/wbem/wsman/1/config/service""><Transport>" + transport + "</Transport>" + openAllProfiles + "</Analyze_INPUT>"; action = "Analyze"; } string analysisOutputXml = m_SessionObj.Invoke(action, "winrm/config/service", analysisInputXml, 0); XmlDocument resultopxml = new XmlDocument(); resultopxml.LoadXml(analysisOutputXml); if (serviceonly) { xpathEnabled = "/cfg:AnalyzeService_OUTPUT/cfg:RemotingEnabled"; xpathText = "/cfg:AnalyzeService_OUTPUT/cfg:Results"; xpathUpdate = "/cfg:AnalyzeService_OUTPUT/cfg:EnableService_INPUT"; } else { xpathEnabled = "/cfg:Analyze_OUTPUT/cfg:RemotingEnabled"; xpathText = "/cfg:Analyze_OUTPUT/cfg:Results"; xpathUpdate = "/cfg:Analyze_OUTPUT/cfg:EnableRemoting_INPUT"; } XmlNamespaceManager nsmgr = new XmlNamespaceManager(resultopxml.NameTable); nsmgr.AddNamespace("cfg", "http://schemas.microsoft.com/wbem/wsman/1/config/service"); string enabled = resultopxml.SelectSingleNode(xpathEnabled, nsmgr).InnerText; XmlNode sourceAttribute = resultopxml.SelectSingleNode(xpathEnabled, nsmgr).Attributes.GetNamedItem("Source"); string source = null; if (sourceAttribute != null) { source = sourceAttribute.Value; } string rxml = ""; if (enabled.Equals("true")) { string Err_Msg = ""; if (serviceonly) { Err_Msg = WSManResourceLoader.GetResourceString("L_QuickConfigNoServiceChangesNeeded_Message"); } else { Err_Msg = WSManResourceLoader.GetResourceString("L_QuickConfigNoChangesNeeded_Message"); } // ArgumentException e = new ArgumentException(Err_Msg); // ErrorRecord er = new ErrorRecord(e, "InvalidOperation", ErrorCategory.InvalidOperation, null); // WriteError(er); WriteObject(Err_Msg); return; } if (!enabled.Equals("false")) { ArgumentException e = new ArgumentException(WSManResourceLoader.GetResourceString("L_QuickConfig_InvalidBool_0_ErrorMessage")); ErrorRecord er = new ErrorRecord(e, "InvalidOperation", ErrorCategory.InvalidOperation, null); WriteError(er); return; } string resultAction = resultopxml.SelectSingleNode(xpathText, nsmgr).InnerText; if (source != null && source.Equals("GPO")) { String Info_Msg = WSManResourceLoader.GetResourceString("L_QuickConfig_RemotingDisabledbyGP_00_ErrorMessage"); Info_Msg += " " + resultAction; ArgumentException e = new ArgumentException(Info_Msg); WriteError(new ErrorRecord(e, "NotSpecified", ErrorCategory.NotSpecified, null)); return; } string inputXml = resultopxml.SelectSingleNode(xpathUpdate, nsmgr).OuterXml; if (resultAction.Equals("") || inputXml.Equals("")) { ArgumentException e = new ArgumentException(WSManResourceLoader.GetResourceString("L_ERR_Message") + WSManResourceLoader.GetResourceString("L_QuickConfig_MissingUpdateXml_0_ErrorMessage")); ErrorRecord er = new ErrorRecord(e, "InvalidOperation", ErrorCategory.InvalidOperation, null); WriteError(er); return; } if (serviceonly) { action = "EnableService"; } else { action = "EnableRemoting"; } rxml = m_SessionObj.Invoke(action, "winrm/config/service", inputXml, 0); XmlDocument finalxml = new XmlDocument(); finalxml.LoadXml(rxml); if (serviceonly) { xpathStatus = "/cfg:EnableService_OUTPUT/cfg:Status"; xpathResult = "/cfg:EnableService_OUTPUT/cfg:Results"; } else { xpathStatus = "/cfg:EnableRemoting_OUTPUT/cfg:Status"; xpathResult = "/cfg:EnableRemoting_OUTPUT/cfg:Results"; } if (finalxml.SelectSingleNode(xpathStatus, nsmgr).InnerText.ToString().Equals("succeeded")) { if (serviceonly) { WriteObject(WSManResourceLoader.GetResourceString("L_QuickConfigUpdatedService_Message")); } else { WriteObject(WSManResourceLoader.GetResourceString("L_QuickConfigUpdated_Message")); } WriteObject(finalxml.SelectSingleNode(xpathResult, nsmgr).InnerText); } else { helper.AssertError(WSManResourceLoader.GetResourceString("L_ERR_Message") + WSManResourceLoader.GetResourceString("L_QuickConfigUpdateFailed_ErrorMessage"), false, null); } } finally { if (!String.IsNullOrEmpty(m_SessionObj.Error)) { helper.AssertError(m_SessionObj.Error, true, null); } if (m_SessionObj != null) { Dispose(m_SessionObj); } } }
private static Expression InvalidType(Type type, string message) { var ex = new ArgumentException(message, "type"); return(Block(Throw(Constant(ex)), Constant(null, type))); }
public async override Tasks.Task RunCommand(object sender) { var engine = (IAutomationEngineInstance)sender; var exceptionMessage = (string)await v_ExceptionMessage.EvaluateCode(engine); Exception ex; switch (v_ExceptionType) { case "AccessViolationException": ex = new AccessViolationException(exceptionMessage); break; case "ArgumentException": ex = new ArgumentException(exceptionMessage); break; case "ArgumentNullException": ex = new ArgumentNullException(exceptionMessage); break; case "ArgumentOutOfRangeException": ex = new ArgumentOutOfRangeException(exceptionMessage); break; case "DivideByZeroException": ex = new DivideByZeroException(exceptionMessage); break; case "Exception": ex = new Exception(exceptionMessage); break; case "FileNotFoundException": ex = new FileNotFoundException(exceptionMessage); break; case "FormatException": ex = new FormatException(exceptionMessage); break; case "IndexOutOfRangeException": ex = new IndexOutOfRangeException(exceptionMessage); break; case "InvalidDataException": ex = new InvalidDataException(exceptionMessage); break; case "InvalidOperationException": ex = new InvalidOperationException(exceptionMessage); break; case "KeyNotFoundException": ex = new KeyNotFoundException(exceptionMessage); break; case "NotSupportedException": ex = new NotSupportedException(exceptionMessage); break; case "NullReferenceException": ex = new NullReferenceException(exceptionMessage); break; case "OverflowException": ex = new OverflowException(exceptionMessage); break; case "TimeoutException": ex = new TimeoutException(exceptionMessage); break; default: throw new NotImplementedException("Selected exception type " + v_ExceptionType + " is not implemented."); } throw ex; }
public static void ThrowsArgumentOutOfRangeException(string paramName, Action action) { ArgumentException exception = Throws <ArgumentOutOfRangeException>(action); Assert.AreEqual(paramName, exception.ParamName); }
/// ------------------------------------------------------------------------------------ /// <summary> /// Reports a load exception in the scrDataSource. /// </summary> /// <param name="e">The exception.</param> /// ------------------------------------------------------------------------------------ void scrDataSource_LoadException(ArgumentException e) { ErrorReporter.ReportException(e, m_app.SettingsKey, m_app.SupportEmailAddress, ParentForm, false); }
public void Throw_GiveArgumentException_ThrowsArgumentException() { var argumentException = new ArgumentException(); ExceptionManager.Throw(argumentException); }
public ValidationError(ArgumentException e) : base(e.Message) { }
/// <summary> /// Starts the transcription. /// </summary> protected override void BeginProcessing() { // If they haven't specified a path, figure out the correct output path. if (!_isFilenameSet) { // read the filename from $TRANSCRIPT object value = this.GetVariableValue("global:TRANSCRIPT", null); // $TRANSCRIPT is not set, so create a file name (the default: $HOME/My Documents/PowerShell_transcript.YYYYMMDDmmss.txt) if (value == null) { // If they've specified an output directory, use it. Otherwise, use "My Documents" if (OutputDirectory != null) { _outFilename = System.Management.Automation.Host.PSHostUserInterface.GetTranscriptPath(OutputDirectory, false); _isLiteralPath = true; } else { _outFilename = System.Management.Automation.Host.PSHostUserInterface.GetTranscriptPath(); } } else { _outFilename = (string)value; } } // Normalize outFilename here in case it is a relative path try { string effectiveFilePath = ResolveFilePath(Path, _isLiteralPath); if (!ShouldProcess(effectiveFilePath)) { return; } if (System.IO.File.Exists(effectiveFilePath)) { if (NoClobber && !Append) { string message = StringUtil.Format(TranscriptStrings.TranscriptFileExistsNoClobber, effectiveFilePath, "NoClobber"); // prevents localization Exception uae = new UnauthorizedAccessException(message); ErrorRecord errorRecord = new ErrorRecord( uae, "NoClobber", ErrorCategory.ResourceExists, effectiveFilePath); // NOTE: this call will throw ThrowTerminatingError(errorRecord); } System.IO.FileInfo fInfo = new System.IO.FileInfo(effectiveFilePath); if ((fInfo.Attributes & FileAttributes.ReadOnly) == FileAttributes.ReadOnly) { // Save some disk write time by checking whether file is readonly.. if (Force) { // Make sure the file is not read only // Note that we will not clear the ReadOnly flag later fInfo.Attributes &= ~(FileAttributes.ReadOnly); } else { string errorMessage = string.Format( System.Globalization.CultureInfo.CurrentCulture, TranscriptStrings.TranscriptFileReadOnly, effectiveFilePath); Exception innerException = new ArgumentException(errorMessage); ThrowTerminatingError(new ErrorRecord(innerException, "FileReadOnly", ErrorCategory.InvalidArgument, effectiveFilePath)); } } // If they didn't specify -Append, empty the file if (!_shouldAppend) { System.IO.File.WriteAllText(effectiveFilePath, string.Empty); } } System.Management.Automation.Remoting.PSSenderInfo psSenderInfo = this.SessionState.PSVariable.GetValue("PSSenderInfo") as System.Management.Automation.Remoting.PSSenderInfo; Host.UI.StartTranscribing(effectiveFilePath, psSenderInfo, IncludeInvocationHeader.ToBool(), UseMinimalHeader.IsPresent); // ch.StartTranscribing(effectiveFilePath, Append); // NTRAID#Windows Out Of Band Releases-931008-2006/03/21 // Previous behavior was to write this even if ShouldProcess // returned false. Why would we want that? PSObject outputObject = new PSObject( StringUtil.Format(TranscriptStrings.TranscriptionStarted, Path)); outputObject.Properties.Add(new PSNoteProperty("Path", Path)); WriteObject(outputObject); } catch (Exception e) { try { Host.UI.StopTranscribing(); } catch { } string errorMessage = string.Format( System.Globalization.CultureInfo.CurrentCulture, TranscriptStrings.CannotStartTranscription, e.Message); ErrorRecord er = new ErrorRecord( PSTraceSource.NewInvalidOperationException(e, errorMessage), "CannotStartTranscription", ErrorCategory.InvalidOperation, null); ThrowTerminatingError(er); } }
public void GetObjectData() { string msg = "MESSAGE"; Exception inner = new ArgumentException("whatever"); SerializationInfo si; Exception se; se = new Exception(msg, inner); si = new SerializationInfo(typeof(Exception), new FormatterConverter()); se.GetObjectData(si, new StreamingContext()); #if NET_2_0 Assert.AreEqual(11, si.MemberCount, "#A1"); #else Assert.AreEqual(10, si.MemberCount, "#A1"); #endif Assert.AreEqual(typeof(Exception).FullName, si.GetString("ClassName"), "#A2"); #if NET_2_0 Assert.IsNull(si.GetValue("Data", typeof(IDictionary)), "#A3"); #endif Assert.AreSame(msg, si.GetString("Message"), "#A4"); Assert.AreSame(inner, si.GetValue("InnerException", typeof(Exception)), "#A5"); Assert.AreSame(se.HelpLink, si.GetString("HelpURL"), "#A6"); Assert.IsNull(si.GetString("StackTraceString"), "#A7"); Assert.IsNull(si.GetString("RemoteStackTraceString"), "#A8"); Assert.AreEqual(0, si.GetInt32("RemoteStackIndex"), "#A9"); Assert.AreEqual(-2146233088, si.GetInt32("HResult"), "#A10"); Assert.IsNull(si.GetString("Source"), "#A11"); Assert.IsNull(si.GetString("ExceptionMethod"), "#A12"); // attempt initialization of lazy init members #if NET_2_0 Assert.IsNotNull(se.Data); #endif Assert.IsNull(se.Source); Assert.IsNull(se.StackTrace); si = new SerializationInfo(typeof(Exception), new FormatterConverter()); se.GetObjectData(si, new StreamingContext()); #if NET_2_0 Assert.AreEqual(11, si.MemberCount, "#B1"); #else Assert.AreEqual(10, si.MemberCount, "#B1"); #endif Assert.AreEqual(typeof(Exception).FullName, si.GetString("ClassName"), "#B2"); #if NET_2_0 Assert.AreSame(se.Data, si.GetValue("Data", typeof(IDictionary)), "#B3"); #endif Assert.AreSame(msg, si.GetString("Message"), "#B4"); Assert.AreSame(inner, si.GetValue("InnerException", typeof(Exception)), "#B5"); Assert.AreSame(se.HelpLink, si.GetString("HelpURL"), "#B6"); Assert.IsNull(si.GetString("StackTraceString"), "#B7"); Assert.IsNull(si.GetString("RemoteStackTraceString"), "#B8"); Assert.AreEqual(0, si.GetInt32("RemoteStackIndex"), "#B9"); Assert.AreEqual(-2146233088, si.GetInt32("HResult"), "#B10"); Assert.IsNull(si.GetString("Source"), "#B11"); Assert.IsNull(si.GetString("ExceptionMethod"), "#B12"); try { throw new Exception(msg, inner); } catch (Exception ex) { si = new SerializationInfo(typeof(Exception), new FormatterConverter()); ex.GetObjectData(si, new StreamingContext()); #if NET_2_0 Assert.AreEqual(11, si.MemberCount, "#C1"); #else Assert.AreEqual(10, si.MemberCount, "#C1"); #endif Assert.AreEqual(typeof(Exception).FullName, si.GetString("ClassName"), "#C2"); #if NET_2_0 Assert.IsNull(si.GetValue("Data", typeof(IDictionary)), "#C3"); #endif Assert.AreSame(msg, si.GetString("Message"), "#C4"); Assert.AreSame(inner, si.GetValue("InnerException", typeof(Exception)), "#C5"); Assert.AreSame(se.HelpLink, si.GetString("HelpURL"), "#C6"); Assert.IsNotNull(si.GetString("StackTraceString"), "#C7"); Assert.IsNull(si.GetString("RemoteStackTraceString"), "#C8"); Assert.AreEqual(0, si.GetInt32("RemoteStackIndex"), "#C9"); Assert.AreEqual(-2146233088, si.GetInt32("HResult"), "#C10"); Assert.IsNotNull(si.GetString("Source"), "#C11"); //Assert.IsNotNull (si.GetString ("ExceptionMethod"), "#C12"); } try { throw new Exception(msg, inner); } catch (Exception ex) { // force initialization of lazy init members #if NET_2_0 Assert.IsNotNull(ex.Data); #endif Assert.IsNotNull(ex.StackTrace); si = new SerializationInfo(typeof(Exception), new FormatterConverter()); ex.GetObjectData(si, new StreamingContext()); #if NET_2_0 Assert.AreEqual(11, si.MemberCount, "#D1"); #else Assert.AreEqual(10, si.MemberCount, "#D1"); #endif Assert.AreEqual(typeof(Exception).FullName, si.GetString("ClassName"), "#D2"); #if NET_2_0 Assert.AreSame(ex.Data, si.GetValue("Data", typeof(IDictionary)), "#D3"); #endif Assert.AreSame(msg, si.GetString("Message"), "#D4"); Assert.AreSame(inner, si.GetValue("InnerException", typeof(Exception)), "#D5"); Assert.AreSame(ex.HelpLink, si.GetString("HelpURL"), "#D6"); Assert.IsNotNull(si.GetString("StackTraceString"), "#D7"); Assert.IsNull(si.GetString("RemoteStackTraceString"), "#D8"); Assert.AreEqual(0, si.GetInt32("RemoteStackIndex"), "#D9"); Assert.AreEqual(-2146233088, si.GetInt32("HResult"), "#D10"); Assert.AreEqual(typeof(ExceptionTest).Assembly.GetName().Name, si.GetString("Source"), "#D11"); //Assert.IsNotNull (si.GetString ("ExceptionMethod"), "#D12"); } }
protected static bool IsIllegalCharactersInPathError(ArgumentException e) { return(e.Message.Contains(IllegalCharactersInPathErrorMessage)); }
/// <summary> /// Errors the message argument exception /// </summary> /// <param name="functionName">Name of the function.</param> /// <param name="e">The e.</param> /// <returns>System.String.</returns> private static string ErrorMessage(string functionName, ArgumentException e) => $"{ClassLocation}.{functionName} - {e.Message}";
Prompt(string caption, string message, Collection <FieldDescription> descriptions) { // Need to implement EchoOnPrompt HandleThrowOnReadAndPrompt(); if (descriptions == null) { throw PSTraceSource.NewArgumentNullException("descriptions"); } if (descriptions.Count < 1) { throw PSTraceSource.NewArgumentException("descriptions", ConsoleHostUserInterfaceStrings.PromptEmptyDescriptionsErrorTemplate, "descriptions"); } // we lock here so that multiple threads won't interleave the various reads and writes here. lock (_instanceLock) { Dictionary <string, PSObject> results = new Dictionary <string, PSObject>(); bool cancelInput = false; if (!string.IsNullOrEmpty(caption)) { // Should be a skin lookup WriteLineToConsole(); WriteLineToConsole(PromptColor, RawUI.BackgroundColor, WrapToCurrentWindowWidth(caption)); } if (!string.IsNullOrEmpty(message)) { WriteLineToConsole(WrapToCurrentWindowWidth(message)); } if (AtLeastOneHelpMessageIsPresent(descriptions)) { WriteLineToConsole(WrapToCurrentWindowWidth(ConsoleHostUserInterfaceStrings.PromptHelp)); } int descIndex = -1; foreach (FieldDescription desc in descriptions) { descIndex++; if (desc == null) { throw PSTraceSource.NewArgumentException("descriptions", ConsoleHostUserInterfaceStrings.NullErrorTemplate, string.Format(CultureInfo.InvariantCulture, "descriptions[{0}]", descIndex)); } PSObject inputPSObject = null; string fieldPrompt = null; fieldPrompt = desc.Name; bool fieldEchoOnPrompt = true; // FieldDescription.ParameterAssemblyFullName never returns null. But this is // defense in depth. if (string.IsNullOrEmpty(desc.ParameterAssemblyFullName)) { string paramName = string.Format(CultureInfo.InvariantCulture, "descriptions[{0}].AssemblyFullName", descIndex); throw PSTraceSource.NewArgumentException(paramName, ConsoleHostUserInterfaceStrings.NullOrEmptyErrorTemplate, paramName); } Type fieldType = InternalHostUserInterface.GetFieldType(desc); if (fieldType == null) { if (InternalHostUserInterface.IsSecuritySensitiveType(desc.ParameterTypeName)) { string errMsg = StringUtil.Format(ConsoleHostUserInterfaceStrings.PromptTypeLoadErrorTemplate, desc.Name, desc.ParameterTypeFullName); PromptingException e = new PromptingException(errMsg, null, "BadTypeName", ErrorCategory.InvalidType); throw e; } fieldType = typeof(string); } if (fieldType.GetInterface(typeof(IList).FullName) != null) { // field is a type implementing IList ArrayList inputList = new ArrayList(); // stores all converted user input before // assigned to an array // if the field is an array, the element type can be found; else, use Object Type elementType = typeof(Object); if (fieldType.IsArray) { elementType = fieldType.GetElementType(); int rank = fieldType.GetArrayRank(); // This check may be redundant because it doesn't seem possible to create // an array of zero dimension. if (rank <= 0) { string msg = StringUtil.Format(ConsoleHostUserInterfaceStrings.RankZeroArrayErrorTemplate, desc.Name); ArgumentException innerException = PSTraceSource.NewArgumentException( string.Format(CultureInfo.InvariantCulture, "descriptions[{0}].AssemblyFullName", descIndex)); PromptingException e = new PromptingException(msg, innerException, "ZeroRankArray", ErrorCategory.InvalidOperation); throw e; } } StringBuilder fieldPromptList = new StringBuilder(fieldPrompt); // fieldPromptList = fieldPrompt + "[i] :" fieldPromptList.Append("["); while (true) { fieldPromptList.Append( string.Format(CultureInfo.InvariantCulture, "{0}]: ", inputList.Count)); bool inputListEnd = false; object convertedObj = null; string inputString = PromptForSingleItem(elementType, fieldPromptList.ToString(), fieldPrompt, caption, message, desc, fieldEchoOnPrompt, true, out inputListEnd, out cancelInput, out convertedObj); if (cancelInput || inputListEnd) { break; } else if (!cancelInput) { inputList.Add(convertedObj); // Remove the indices from the prompt fieldPromptList.Length = fieldPrompt.Length + 1; } } // if cancelInput, should throw OperationCancelException? if (!cancelInput) { object tryConvertResult = null; if (LanguagePrimitives.TryConvertTo(inputList, fieldType, out tryConvertResult)) { inputPSObject = PSObject.AsPSObject(tryConvertResult); } else { inputPSObject = PSObject.AsPSObject(inputList); } } } else { string printFieldPrompt = StringUtil.Format(ConsoleHostUserInterfaceStrings.PromptFieldPromptInputSeparatorTemplate, fieldPrompt); // field is not a list object convertedObj = null; bool dummy = false; PromptForSingleItem(fieldType, printFieldPrompt, fieldPrompt, caption, message, desc, fieldEchoOnPrompt, false, out dummy, out cancelInput, out convertedObj); if (!cancelInput) { inputPSObject = PSObject.AsPSObject(convertedObj); } } if (cancelInput) { s_tracer.WriteLine("Prompt canceled"); WriteLineToConsole(); results.Clear(); break; } results.Add(desc.Name, PSObject.AsPSObject(inputPSObject)); } return(results); } }
public void EqualThrowsArgumentException() { var expectedEx = new ArgumentException(Exceptions.ArgumentEqualToValue.FormatWith(Guid.Empty), "paramName"); var actualEx = Assert.Throws<ArgumentException>(() => Verify.NotEqual(Guid.Empty, Guid.Empty, "paramName")); Assert.Equal(expectedEx.Message, actualEx.Message); }
public void DuplicateEntriesThrowArgumentException() { var context = Create( "Target", "Target/runtime", true, null, runtimeLibraries: new[] { new RuntimeLibrary( "package", "DuplicatePackageName", "1.2.3", "HASH", new [] { new RuntimeAssetGroup(string.Empty, "Banana.dll"), new RuntimeAssetGroup("win7-x64", "Banana.Win7-x64.dll") }, new [] { new RuntimeAssetGroup(string.Empty, "runtimes\\linux\\native\\native.so"), new RuntimeAssetGroup("win7-x64", "native\\Banana.Win7-x64.so") }, new [] { new ResourceAssembly("en-US\\Banana.Resource.dll", "en-US") }, new [] { new Dependency("Fruits.Abstract.dll", "2.0.0") }, true, "PackagePath", "PackageHashPath", "placeHolderManifest.xml" ), new RuntimeLibrary( "package", "DuplicatePackageName", "1.2.3", "HASH", new [] { new RuntimeAssetGroup(string.Empty, "Banana.dll"), new RuntimeAssetGroup("win7-x64", "Banana.Win7-x64.dll") }, new [] { new RuntimeAssetGroup(string.Empty, "runtimes\\linux\\native\\native.so"), new RuntimeAssetGroup("win7-x64", "native\\Banana.Win7-x64.so") }, new [] { new ResourceAssembly("en-US\\Banana.Resource.dll", "en-US") }, new [] { new Dependency("Fruits.Abstract.dll", "2.0.0") }, true, "PackagePath", "PackageHashPath", "placeHolderManifest.xml" ), }, runtimeGraph: new[] { new RuntimeFallbacks("win7-x64", new [] { "win6", "win5" }), new RuntimeFallbacks("win8-x64", new [] { "win7-x64" }), }); ArgumentException ex = Assert.Throws <ArgumentException>(() => Save(context)); Assert.Contains("DuplicatePackageName", ex.Message); }
/// <summary> /// Stop copy operation by CloudBlob object /// </summary> /// <param name="blob">CloudBlob object</param> /// <param name="copyId">Copy id</param> private async Task StopCopyBlob(long taskId, IStorageBlobManagement localChannel, CloudBlob blob, string copyId, bool fetchCopyIdFromBlob = false) { ValidateBlobType(blob); AccessCondition accessCondition = null; BlobRequestOptions abortRequestOption = RequestOptions ?? new BlobRequestOptions(); //Set no retry to resolve the 409 conflict exception abortRequestOption.RetryPolicy = new NoRetry(); if (null == blob) { throw new ArgumentException(String.Format(Resources.ObjectCannotBeNull, typeof(CloudBlob).Name)); } string specifiedCopyId = copyId; if (string.IsNullOrEmpty(specifiedCopyId) && fetchCopyIdFromBlob) { if (blob.CopyState != null) { specifiedCopyId = blob.CopyState.CopyId; } } string abortCopyId = string.Empty; if (string.IsNullOrEmpty(specifiedCopyId) || Force) { //Make sure we use the correct copy id to abort //Use default retry policy for FetchBlobAttributes BlobRequestOptions options = RequestOptions; await localChannel.FetchBlobAttributesAsync(blob, accessCondition, options, OperationContext, CmdletCancellationToken); if (blob.CopyState == null || String.IsNullOrEmpty(blob.CopyState.CopyId)) { ArgumentException e = new ArgumentException(String.Format(Resources.CopyTaskNotFound, blob.Name, blob.Container.Name)); OutputStream.WriteError(taskId, e); } else { abortCopyId = blob.CopyState.CopyId; } if (!Force) { string confirmation = String.Format(Resources.ConfirmAbortCopyOperation, blob.Name, blob.Container.Name, abortCopyId); if (!await OutputStream.ConfirmAsync(confirmation)) { string cancelMessage = String.Format(Resources.StopCopyOperationCancelled, blob.Name, blob.Container.Name); OutputStream.WriteVerbose(taskId, cancelMessage); } } } else { abortCopyId = specifiedCopyId; } await localChannel.AbortCopyAsync(blob, abortCopyId, accessCondition, abortRequestOption, OperationContext, CmdletCancellationToken); string message = String.Format(Resources.StopCopyBlobSuccessfully, blob.Name, blob.Container.Name); OutputStream.WriteObject(taskId, message); }
public void KeyVaultKeyIdentifierNullThrows() { ArgumentException ex = Assert.Throws <ArgumentNullException>(() => new KeyVaultKeyIdentifier(null)); Assert.AreEqual("id", ex.ParamName); }
/// <summary> /// /// </summary> protected override void BeginProcessing() { //ValidateNotNullOrEmpty attribute is not working for System.Uri datatype, so handling it here if ((_cssuriSpecified) && (string.IsNullOrEmpty(_cssuri.OriginalString.Trim()))) { ArgumentException ex = new ArgumentException(StringUtil.Format(UtilityCommonStrings.EmptyCSSUri, "CSSUri")); ErrorRecord er = new ErrorRecord(ex, "ArgumentException", ErrorCategory.InvalidArgument, "CSSUri"); ThrowTerminatingError(er); } _propertyMshParameterList = ProcessParameter(_property); if (!String.IsNullOrEmpty(_title)) { WebUtility.HtmlEncode(_title); } // This first line ensures w3c validation will succeed. However we are not specifying // an encoding in the HTML because we don't know where the text will be written and // if a particular encoding will be used. if (!_fragment) { if (!_transitional) { WriteObject("<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Strict//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd\">"); } else { WriteObject("<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\">"); } WriteObject("<html xmlns=\"http://www.w3.org/1999/xhtml\">"); WriteObject("<head>"); if (_charsetSpecified) { WriteObject("<meta charset=\"" + _charset + "\">"); } if (_metaSpecified) { List <string> useditems = new List <string>(); foreach (string s in _meta.Keys) { if (!useditems.Contains(s)) { switch (s.ToLower()) { case "content-type": case "default-style": case "x-ua-compatible": WriteObject("<meta http-equiv=\"" + s + "\" content=\"" + _meta[s] + "\">"); break; case "application-name": case "author": case "description": case "generator": case "keywords": case "viewport": WriteObject("<meta name=\"" + s + "\" content=\"" + _meta[s] + "\">"); break; default: MshCommandRuntime mshCommandRuntime = this.CommandRuntime as MshCommandRuntime; string Message = StringUtil.Format(ConvertHTMLStrings.MetaPropertyNotFound, s, _meta[s]); WarningRecord record = new WarningRecord(Message); InvocationInfo invocationInfo = GetVariableValue(SpecialVariables.MyInvocation) as InvocationInfo; if (invocationInfo != null) { record.SetInvocationInfo(invocationInfo); } mshCommandRuntime.WriteWarning(record); WriteObject("<meta name=\"" + s + "\" content=\"" + _meta[s] + "\">"); break; } useditems.Add(s); } } } WriteObject(_head ?? new string[] { "<title>" + _title + "</title>" }, true); if (_cssuriSpecified) { WriteObject("<link rel=\"stylesheet\" type=\"text/css\" href=\"" + _cssuri + "\" />"); } WriteObject("</head><body>"); if (_body != null) { WriteObject(_body, true); } } if (_preContent != null) { WriteObject(_preContent, true); } WriteObject("<table>"); _isTHWritten = false; _propertyCollector = new StringCollection(); }
public void CreateFileAndForgetEventName_WhenMemberNameIsNullOrEmpty_Throws(string memberName) { ArgumentException exception = Assert.Throws <ArgumentException>(() => TelemetryUtility.CreateFileAndForgetEventName("typeName", memberName)); Assert.Equal("memberName", exception.ParamName); }
public static void GetResult_FaultedTask_OneException_ThrowsOriginalException() { var exception = new ArgumentException("uh oh"); Task<string> task = Task.FromException<string>(exception); // Task.GetAwaiter and Task<T>.GetAwaiter Assert.Same(exception, Assert.Throws<ArgumentException>(() => ((Task)task).GetAwaiter().GetResult())); Assert.Same(exception, Assert.Throws<ArgumentException>(() => task.GetAwaiter().GetResult())); // w/ ConfigureAwait false and true Assert.Same(exception, Assert.Throws<ArgumentException>(() => ((Task)task).ConfigureAwait(false).GetAwaiter().GetResult())); Assert.Same(exception, Assert.Throws<ArgumentException>(() => ((Task)task).ConfigureAwait(true).GetAwaiter().GetResult())); Assert.Same(exception, Assert.Throws<ArgumentException>(() => task.ConfigureAwait(false).GetAwaiter().GetResult())); Assert.Same(exception, Assert.Throws<ArgumentException>(() => task.ConfigureAwait(true).GetAwaiter().GetResult())); }
private void ProcessExpandParameter(PSObject inputObject, List <PSNoteProperty> matchedProperties) { // expand parameter is used // expand the property value from the inputobject object propValue = null; try { propValue = GetPropValue(inputObject, expand); } catch (Exception e) { WriteNonTerminatingError(expand, "PropertyAccessException", e, ErrorCategory.InvalidData); return; } if (null == propValue) { string message = string.Format(CultureInfo.CurrentCulture, GetErrorMessage(PROPERTYNOTFOUND), expand); Exception e = new ArgumentException(message); WriteNonTerminatingError(expand, "PropertyNotFound", e, ErrorCategory.InvalidData); return; } // Expand prop value using a Enumerator System.Collections.IEnumerable results = LanguagePrimitives.GetEnumerable(propValue); if (results == null) { string message = string.Format(CultureInfo.CurrentCulture, GetErrorMessage(NOTHINGTOEXPAND), expand); Exception e = new ArgumentException(message); WriteNonTerminatingError(expand, "NothingToExpand", e, ErrorCategory.InvalidArgument); return; } foreach (object expandedValue in results) { if (expandedValue == null) { WriteVerbose("One of the expanded values is null"); continue; } PSObject expandedObject = PSObject.AsPSObject(expandedValue); foreach (PSNoteProperty noteProperty in matchedProperties) { try { if (expandedObject.Properties[noteProperty.Name] != null) { WriteAlreadyExistingPropertyError(noteProperty.Name, inputObject); } else { expandedObject.Properties.Add(noteProperty); } } catch (ExtendedTypeSystemException) { WriteAlreadyExistingPropertyError(noteProperty.Name, inputObject); } } SendToOutputPipe(expandedObject, matchedProperties); } }
/// <summary> /// Computes and returns the supported command type given a stipulated command type and command object. /// </summary> /// <remarks> /// If the returned type does not match the stipulated type, /// a warning event is raised on the given command object. /// </remarks> /// <param name="commandType">Type of the command.</param> /// <param name="command">The command.</param> /// <returns>the supported command type</returns> private static CommandType ToSupportedCommandType(CommandType commandType, HsqlCommand command) { switch (commandType) { case CommandType.StoredProcedure: case CommandType.TableDirect: case CommandType.Text: { return commandType; } default: { ArgumentException ex = new ArgumentException( "commandType", string.Format( "[{0}] is not a valid command type", commandType)); HsqlDataSourceException hex = new HsqlDataSourceException("Warning.", ex); command.OnWarning(new HsqlWarningEventArgs(hex)); return CommandType.Text; } } }
internal static Exception MakeException(SpotCamReturnCode returnCode, bool treatWarningAsError = false) { if (SpotCamReturnCode.Success == returnCode || (!treatWarningAsError && returnCode < 0)) { return(null); } Exception exception = null; switch (returnCode) { case SpotCamReturnCode.WarnServiceConfigurationUnknown: break; case SpotCamReturnCode.WarnColorLibNotLoaded: break; case SpotCamReturnCode.WarnInvalidOutputIcc: break; case SpotCamReturnCode.WarnInvalidInputIcc: break; case SpotCamReturnCode.WarnUnsupportedCameraFeatures: break; case SpotCamReturnCode.Abort: exception = new OperationCanceledException(); break; case SpotCamReturnCode.ErrorOutOfMemory: exception = new OutOfMemoryException(); break; case SpotCamReturnCode.ErrorExposureTooShort: break; case SpotCamReturnCode.ErrorExposureTooLong: break; case SpotCamReturnCode.ErrorNoCameraResponse: break; case SpotCamReturnCode.ErrorValueOutOfRange: break; case SpotCamReturnCode.ErrorInvalidParam: exception = new ArgumentException("The SpotCam parameter is not valid"); break; case SpotCamReturnCode.ErrorDriverNotInitialized: break; case SpotCamReturnCode.ErrorRegistryQuery: break; case SpotCamReturnCode.ErrorRegistrySet: break; case SpotCamReturnCode.ErrorDeviveDriverLoad: break; case SpotCamReturnCode.ErrorCameraError: break; case SpotCamReturnCode.ErrorDriverAlreadyInit: break; case SpotCamReturnCode.ErrorDmaSetup: break; case SpotCamReturnCode.ErrorReadingCameraInfo: break; case SpotCamReturnCode.ErrorNotCapable: break; case SpotCamReturnCode.ErrorColorFilterNotIn: break; case SpotCamReturnCode.ErrorColorFilterNotOut: break; case SpotCamReturnCode.ErrorCameraBusy: break; case SpotCamReturnCode.ErrorCameraNotSupported: break; case SpotCamReturnCode.ErrorNoImageAvailable: break; case SpotCamReturnCode.ErrorFileOpen: break; case SpotCamReturnCode.ErrorFlatfieldIncompatible: break; case SpotCamReturnCode.ErrorNoDevicesFound: break; case SpotCamReturnCode.ErrorBrightnessChanged: break; case SpotCamReturnCode.ErrorCameraAndCardIncompatible: break; case SpotCamReturnCode.ErrorBiasFrameIncompatible: break; case SpotCamReturnCode.ErrorBackgroundImageIncompatible: break; case SpotCamReturnCode.ErrorBackgroundTooBright: break; case SpotCamReturnCode.ErrorInvalidFile: break; case SpotCamReturnCode.ErrorMisc: break; case SpotCamReturnCode.ErrorImageTooBright: break; case SpotCamReturnCode.ErrorNothingToDo: break; case SpotCamReturnCode.ErrorNoCameraPower: break; case SpotCamReturnCode.ErrorInsuf1394IsocBandwidth: break; case SpotCamReturnCode.ErrorInsuf1394IsocResources: break; case SpotCamReturnCode.ErrorNo1394IsocChannel: break; case SpotCamReturnCode.ErrorUsbVersionLowerThan2: break; case SpotCamReturnCode.ErrorStartupAlreadyDone: break; case SpotCamReturnCode.ErrorStartupNotDone: break; case SpotCamReturnCode.ErrorSpotcamServiceNotFound: break; case SpotCamReturnCode.ErrorWrongSpotcamServiceVersion: break; case SpotCamReturnCode.ErrorOperationNotSupported: break; case SpotCamReturnCode.ErrorServiceConfigurationFileError: break; case SpotCamReturnCode.ErrorServiceConfigurationSyntaxError: break; case SpotCamReturnCode.ErrorServiceConfigurationInvalid: break; default: break; } if (null == exception) { exception = new Exception(String.Format("SpotCam error {0}", returnCode)); } return(exception); }