raise

Is it OK to raise a built-in exception with a custom text? or to raise a built-in warning also with custom text? The documentation reads: exception ValueError: Raised when a built-in operation or function receives an argument (…) Is it implied that only built-in operations should raise a ValueError exception? In practice, I understand that it is safe to create an exception class that inherits from ValueError or Exception. But is it OK not to do that, and directly raise a ValueError("custom text")? Since ValueError is built-in, raising a ValueError (with a custom text) allows users to quickly

This question already has an answer here: Checking for null before event dispatching… thread safe? 6 answers I came across this question in a Microsoft Practice Test and I got confused. Here is the question: Which of the following C# code samples is the proper way to raise an event, assuming that the Alarm event, the AlarmEventArgs class, and the AlarmEventHandler delegate have been declared? Here is the "correct" answer they provided: AlarmEventArgs e = new AlarmEventArgs(1, 2); AlarmEventHandler handler = Alarm; if (handler != null) { handler(this, e); } However, there is also another answer

I like method parameters enclosed in parenthesis, this is some Pascal nostalgia. When cleaning up code, if I find a method parameters without it I enclose them immediately. Today it caused my working code throwing errors although my syntax looks okay according to the documentation. Kernel.raise's documentation has this format: (Object) raise(exception[, string [, array]]) These are all working: > raise TypeError TypeError: TypeError > raise (TypeError) TypeError: TypeError > raise "Error message" RuntimeError: Error message > raise ("Error message") RuntimeError: Error message But the enclosed

I'm using custom exceptions to differ my exceptions from Python's default exceptions. Is there a way to define a custom exit code when I raise the exception? class MyException(Exception): pass def do_something_bad(): raise MyException('This is a custom exception') if __name__ == '__main__': try: do_something_bad() except: print('Oops') # Do some exception handling raise In this code, the main function runs a few functions in a try code. After I catch an exception I want to re-raise it to preserve the traceback stack. The problem is that 'raise' always exits 1. I want to exit the script with a

Let's assume we have smth like that : import py, pytest ERROR1 = ' --- Error : value < 5! ---' ERROR2 = ' --- Error : value > 10! ---' class MyError(Exception): def __init__(self, m): self.m = m def __str__(self): return self.m def foo(i): if i < 5: raise MyError(ERROR1) elif i > 10: raise MyError(ERROR2) return i # ---------------------- TESTS ------------------------- def test_foo1(): with pytest.raises(MyError) as e: foo(3) assert ERROR1 in str(e) def test_foo2(): with pytest.raises(MyError) as e: foo(11) assert ERROR2 in str(e) def test_foo3(): .... foo(7) .... Q: How can I make test_foo3(

I was wondering what's the proper way of raising events from C++/CLI. In C# one s hould first make a copy of the handler, check if it's not null, and then call it . Is there a similar practice for C++/CLI? C++/CLI allows you to override raise in custom event handlers so you don't have to test for null or copy when raising the event. Of course, inside your custom raise you still have to do this. Example, adapted from the MSDN for correctness: public delegate void f(int); public ref struct E { f ^ _E; public: void handler(int i) { System::Console::WriteLine(i); } E() { _E = nullptr; } event f^

I have been learning Python for a while and the raise function and assert are (what I realised is that both of them crash the app, unlike try - except) really similar and I can't see a situation where you would use raise or assert over try . So, what is the difference between Raise, Try and Assert? Assert: Used when you want to "stop" the script based on a certain condition and return something to help debug faster: list_ = ["a","b","x"] assert "x" in list_, "x is not in the list" print("passed") #>> prints passed list_ = ["a","b","c"] assert "x" in list_, "x is not in the list" print("passed"