Test with NO expected exception

I want to create NUnit test to ensure that my function does not throw an exception. Is there some specific way to do it, or I should just write

[Test]
public void noExceptionTest() {
  testedFunction();
}

and it will succeed if no exception is thrown?

Assert.DoesNotThrow(() => { /* custom code block here*/});

OR just method

Assert.DoesNotThrow(() => CallMymethod());

For more details see NUnit Exception Asserts

Using NUnit 3.0 Constraint Model type assertions the code would look as follows:

Assert.That(() => SomeMethod(actual), Throws.Nothing);

This example is taken from NUnit wiki.

Not throwing an exception is the normal course of action. Your test will successfully verify that an exception is not thrown.

You are correct. If there's an exception then the test will fail.

Unless you specify

[ExpectedException( typeof(YourException) ) ]
public void TestMethod()
{ 
   ...
}

Or as @sll says, you use the more specific

Assert.DoesNotThrow

assertion.

Yes, no thrown exceptions -> test pass. If there was try-catch block without re-throw, it'll pass too.

I think there is a problem related to unit test logic. If you are expecting a specific exception under certain inputs, you declare it as an expected exception. If you are just checking whether your function behaves properly and no exceptions are expected during this proper behavior, you just write it and if it throws any exception, your test fails.

Your code seems to be working properly, on the other hand, only checking no exceptions may not be the proper way for unit testing. In unit tests, generally you expect some outputs (expected values), you have some actual outputs (actual values) and you assert that expected and actual values are the same.

If you want to stick to the Arrange-Act-Assert pattern, you can define the TestDelegate beforehand and assert it later on. The function is still executed in the Assert part, but the structure is clearer.

// Arrange
var dataHandler = this.GetTestDataHandler();

// Act
TestDelegate transformAction = () => dataHandler.TransformData();

// Assert
Assert.DoesNotThrow(transformAction);