How should I unit test a bitmap modifying method?

  > Is it appropriate to store these bitmaps as resources, 
  > and then check the results are equal?

In my opinion i would say yes, but instead of coding these comparisons yourself i would use approvaltests for dotnet or java for this.

So instead of hiding the bitmap-comparison behind a junit-testmethod the approval test shows every test-result where the bitmaps are not equal any more to the tester, who can decide this result is ok or is not ok. if it is ok the expected result is overwritten.

so on the next run the approvaltest will not complain any more.

Is it appropriate to store these bitmaps as resources

Well, whatever will work for you is appropriate, isn't it? Your unit tests should run quick, be functional, should be easy to maintain and to extend, and if they fail, they should make root cause analysis easier for you.

• "quick" can be fulfilled by using very small bitmaps

• "functional": to include significant cases, the bitmaps must be actually not too small. For your case, I guess bitmaps with a side length of minimum of 3 or 4 will probably make sense.

• easy to maintain and to extend: well, as long as your tool set allows easy bitmap manipulation, storing of bitmaps in a resource and retrieving it again, that should not be much of an issue

• "make root cause analysis easy": for this, you may have to make some provisions. If you just "check if the results of a bitmap comparison are equal", you might not easily see how your "testBitmap" looks like and why it does not match the expected results. But it should be pretty simple to add some code which in case the equality test fails, writes your test bitmap to disk so you can check it easily with an imager viewer (either just visually, or by creating something like a "difference image" between the expected bitmap and your test bitmap)

Of course, the alternative would be to create some per-pixel tests with hard-encoded colors and coordinates, but though that will surely work, IMHO that's not easier to maintain and can become very tedious.

Some related posts on other SE sites:

http://stackoverflow.com/questions/16217982/comparing-images-as-byte-arrays-for-unit-tests

http://sqa.stackexchange.com/questions/3136/how-to-test-the-graphical-contents-of-a-bitmap-or-a-pdf-file

As I understand you are using your own custom sprite and not some sprite from DirectX or from DirectXMobile.

What you could try:

1) If your class provides some per-pixel indexer like SomeColorInfo this[int x, int y] or the ToBitmap() method:

You could try to use small parent and child (like few pixels per few pixels) where you could manually calculate all desired pixels and compare resulting and desired images(sprites). For example, supposing for simplicity that you are using greyscale pictures:

[TestMethod]
void Test_Sprite_UpdateWithBitmap_GreyScaleSprite3x3_GreyScaleBitmap2x2()
{
    // Create 3 x 3 greyscale Sprite from 
    Sprite sprite = new Sprite(3, 
    3, 
    new Byte { 
    1, 2, 3,
    4, 5, 6,
    7, 8, 9});

    // Create 3 x 2 bitmap to update with
                Bitmap bitmap = new Bitmap(2, 
    2, 
    new Byte { 
    101, 102
    103, 104});

    // Coordinates of update point
    Int32 x = 1;
    Int32 y = 1;

    // Expected sprite
    Sprite expectedSprite =  new Sprite(3, 
    3, 
    new Byte { 
    1, 2, 3,
    4, 101, 102,
    7, 103, 104});

    // Update  sprite
    sprite.updateWithBitmap(child, 3,3);

    // Assert
    CollectionAssert.AreEqual(expectedSprite, sprite);
}

Well your sprite and bitmap should have constructors like Sprite(Int32,Int32, IEnumerable<Byte>); and your Sprite should be IEnumerable(you will just have to make sprite.ToList() in assert) or ICollection

2) If your sprite cannot be calculated(painted) other than in the actual user interface environment or you do not want to add some unneeded members, you should consider some way to get his pixels through other channels. I don't know what UI you use, but most of them provide some sort of a PaintingContext for your custom painting objects. Such an object can be an interface like:

public interface IPaintingContext : IDisposable
{
    void PutPixel(Int32 x, Int32 y);

    void PutImage(IImage image);

    //... And so on
}

that will allow you to mock it and use in your test method like:

...
IPaintingContext expectedPaintingContext = new MockPaintingContext(3, 3, new Byte[]{...});
...
IPaintingContext paintingContext = new MockPaintingContext();
...
sprite.PaintOn(paintingContext);
...
CollectionAssert.Assert(expectedPaintingContext, paintingContex);

If your environment provides such functionality in a not an interface way, then you could create your own custom infrastructure of a such kind: IPaintingContext context = new MyUiPaintingContextWrapper(UI.GetPaintingPlane())