<< A 30-Second Introduction to IPv6 | Home | October Is Scary Schema Month >>

What's Wrong With This Code (#18)

Here is another golden oldie:

Numeric overflows are a type of software bug that occur when a calculation produces a result that doesn't fit in the intended storage location. One of the most famous cases of an overflow bug is the overflow bug that destroyed an Ariane 5 rocket in 1996*.

Fortunately, .NET has a dedicated exception to highlight overflow problems. Just run the following VB code and watch the OverflowException appear.

Dim i As Integer
i += Integer.MaxValue
i += Integer.MaxValue

So, given this class:

public class LineItem
{
    private int _quantity;
    public int Quantity
    {
        get { return _quantity; }
    }

    public int AddQuantity(int additionalQuantity)
    {
        // some logic ...
        return _quantity += additionalQuantity;
    }

    // other stuff...
}

Why does the following unit test fail?

[TestFixture]
public class LineItemTest
{
    [Test]
    [ExpectedException(typeof(OverflowException))]
    public void TestForOverflow()
    {
        LineItem lineItem = new LineItem();
        lineItem.AddQuantity(Int32.MaxValue);
        lineItem.AddQuantity(Int32.MaxValue);
    }
}

What options are available to fix the problem?

* The article Design By Contract: The Lessons Of Ariane says the real error was a "reuse specification error". Quote: "To attempt to reuse software without Eiffel-like assertions is to invite failures of potentially disastrous consequences".

Print | posted @ Tuesday, October 09, 2007 3:01 AM

Comments on this entry:

Gravatar # re: What's Wrong With This Code (#18)
by Jonas at 10/9/2007 4:43 AM
The unit test fails because when Int32.MaxValue is passed to AddQuantity for the second time, _quantity overflows, as it's already at Int32.MaxValue.
  
Gravatar # re: What's Wrong With This Code (#18)
by Jonathan Malek at 10/9/2007 5:37 AM
I think it should be:

return checked(_quantity += additionalQuantity);

So that runtime overflow checking is applied. You can also use /checked+ as a compiler switch instead of the statement or block.
  
Gravatar # re: What's Wrong With This Code (#18)
by Kalpesh at 10/9/2007 5:49 AM
The unit test would fail because the value is returned before += could execute? To make it throw the exception, it should read

_quantity += additionalQuantity;
return _quantity;

Just a wild guess. I didn't try running it.
  
Gravatar # re: What's Wrong With This Code (#18)
by Jason Stangroome at 10/9/2007 6:57 AM
VB projects have an advanced compile optimization to remove integer overflow checks. This is off by default so VB checks for and throws OverflowExceptions.

C# projects have advanced build settings to check for arithmetic overflow/underflow. This is off by default so C# does not check for overflow and does not throw exceptions.

To pass the unit test without enabling overflow checks for the whole project and assuming only non-negative numbers are valid for the additionalQuantity field (yet another unit test) I would add the following guard clause:

if (_quantity > Int32.MaxValue - additionalQuantity) throw new OverflowException();
  
Gravatar # re: What's Wrong With This Code (#18)
by Ronin at 10/9/2007 7:05 AM
Well i suppose you should you checked construct in AddQuantity, else compiler won't throw an exception, will just round up.
  
Gravatar # re: What's Wrong With This Code (#18)
by Ronin at 10/9/2007 7:08 AM
You need to use checked construct in AddQuantity method in order to ensure that the compiler will throw an exception.
The default behavior is to round-up.
  
Gravatar # re: What's Wrong With This Code (#18)
by Dave at 10/9/2007 10:49 AM
I believe this is down to the fact that by default VB checks for overflows at runtime which C# by default does not. Thus, the test will fail .

The simple of way of getting the exception to throw (and the test to pass) is to use the checked keyword so that the addition of the two integers is checked at runtime or you also set the /checked switch on the compiler to make sure that all integer arithmetic is overflow checked.
  
Gravatar # re: What's Wrong With This Code (#18)
by Eric D. Burdo at 10/9/2007 10:35 PM
Another potential problem. You have an Int32, and an Int. This doesn't guarantee that the Int will be 32 bits (depends on the platform and such).
  
Gravatar # re: What's Wrong With This Code (#18)
by scott at 10/10/2007 12:48 AM
Good catch!
  
Gravatar # re: What's Wrong With This Code (#18)
by Scott McMaster at 10/12/2007 2:55 AM
Re: int versus Int32 a couple of comments above, "int" in C# IS guaranteed to be 32 bits == "Int32" per spec. The "platform" in this case IS .NET. The designers didn't want to propagate the old C/C++ data type sizing mess.
  

Your comment:

Title:
Name:
Email:
Website:
 
Italic Underline Blockquote Hyperlink
 
 
Please add 5 and 7 and type the answer here: