Best practice for incorrect parameters on a remove method

Question

So I have an abstract data type called RegionModel with a series of values (Region), each mapped to an index. It's possible to remove a number of regions by calling:

regionModel.removeRegions(index, numberOfRegionsToRemove);

My question is what's the best way to handle a call when the index is valid :

(between 0 (inclusive) and the number of Regions in the model (exclusive))

but the numberOfRegionsToRemove is invalid:

(index + regionsToRemove > the number of regions in the model)

Is it best to throw an exception like IllegalArgumentException or just to remove as many Regions as I can (all the regions from index to the end of the model)?

Sub-question: if I throw an exception what's the recommended way to unit test that the call threw the exception and left the model untouched (I'm using Java and JUnit here but I guess this isn't a Java specific question).

Answer 1

I would say that an argument such as illegalArgumentException would be the best way to go here. If the calling code was not passing a workable value, you wouldn't necessarily want to trust that they really wanted to remove what it had them do.

Answer 2

Typically, for structures like this, you have a remove method which takes an index and if that index is outside the bounds of the items in the structure, an exception is thrown.

That being said, you should be consistent with whatever that remove method that takes a single index does. If it simply ignores incorrect indexes, then ignore it if your range exceeds (or even starts before) the indexes of the items in your structure.

Answer 3

I agree with Mitchel and casperOne -- an Exception makes the most sense.

As far as unit testing is concerned, JUnit4 allows you to exceptions directly: http://www.ibm.com/developerworks/java/library/j-junit4.html

You would need only to pass parameters which are guaranteed to cause the exception, and add the correct annotation (@Test(expected=IllegalArgumentException.class)) to the JUnit test method.

Edit: As Tom Martin mentioned, JUnit 4 is a decent-sized step away from JUnit 3. It is, however, possible to also test exceptions using JUnit 3. It's just not as easy.

One of the ways I've tested exceptions is by using a try/catch block within the class itself, and embedding Assert statements within it.

Here's a simple example -- it's not complete (e.g. regionModel is assumed to be instantiated), but it should get the idea across:

public void testRemoveRegionsInvalidInputs() {
  int originalSize = regionModel.length();
  int index = 0;
  int numberOfRegionsToRemove = 1,000; // > than regionModel's current size
  try {
    regionModel.removeRegions(index, numberOfRegionsToRemove);

    // Since the exception will immediately go into the 'catch' block this code will only run if the IllegalArgumentException wasn't thrown
    Assert.assertTrue("Exception not Thrown!", false);
  }
  catch (IllegalArgumentException e) {
     Assert.assertTrue("Exception thrown, but regionModel was modified", regionModel.length() == originalSize);
  }
  catch (Exception e) {
      Assert.assertTrue("Incorrect exception thrown", false);
  }
}