More image tests

Author: kunitoki

tests/yup_graphics.cpp

@@ -25,6 +25,7 @@
 #include "yup_graphics/yup_Drawable.cpp"
 #include "yup_graphics/yup_Font.cpp"
 #include "yup_graphics/yup_Graphics.cpp"
+#include "yup_graphics/yup_Image.cpp"
 #include "yup_graphics/yup_Line.cpp"
 #include "yup_graphics/yup_Path.cpp"
 #include "yup_graphics/yup_Point.cpp"

tests/yup_graphics/yup_Image.cpp

@@ -23,6 +23,10 @@
 
 #include <yup_graphics/yup_graphics.h>
 
+#include <memory>
+#include <stdexcept>
+#include <utility>
+
 using namespace yup;
 
 TEST (ImageTests, RgbaBitmapStoresRGBABytesAndReturnsARGBColor)
@@ -98,6 +102,34 @@ TEST (BitmapDataTests, RgbaSetPixelWritesAtCorrectRowOffset)
     EXPECT_EQ (bitmap.getPixel (1, 1), 0x80123456u);
 }
 
+TEST (BitmapDataTests, DefaultConstructorCreatesEmptyBitmap)
+{
+    BitmapData bitmap;
+
+    EXPECT_EQ (bitmap.getWidth(), 0);
+    EXPECT_EQ (bitmap.getHeight(), 0);
+    EXPECT_EQ (bitmap.getPixelFormat(), PixelFormat::RGBA);
+    EXPECT_EQ (bitmap.getPixelStride(), 4);
+    EXPECT_TRUE (bitmap.getRawData().empty());
+
+    EXPECT_NO_THROW (bitmap.clear());
+    EXPECT_NO_THROW (bitmap.fill (0xffffffff));
+    EXPECT_THROW (bitmap.getPixel (0, 0), std::out_of_range);
+}
+
+TEST (BitmapDataTests, ConstructorAdoptsProvidedPixelData)
+{
+    auto pixels = std::unique_ptr<uint8[]> (new uint8[4] { 0x12, 0x34, 0x56, 0x80 });
+
+    BitmapData bitmap (1, 1, PixelFormat::RGBA, std::unique_ptr<const uint8[]> (pixels.release()));
+
+    EXPECT_EQ (bitmap.getRawData().size(), 4u);
+    EXPECT_EQ (bitmap.getPixel (0, 0), 0x80123456u);
+
+    bitmap.setPixel (0, 0, 0xffabcdef);
+    EXPECT_EQ (bitmap.getPixel (0, 0), 0xffabcdefu);
+}
+
 TEST (BitmapDataTests, FillWritesExpectedBytesForRGBA)
 {
     BitmapData bitmap (2, 2, PixelFormat::RGBA);
@@ -133,6 +165,44 @@ TEST (BitmapDataTests, FillWritesExpectedBytesForRGB)
     EXPECT_EQ (raw[5], 0x56);
 }
 
+TEST (BitmapDataTests, FillWritesExpectedBytesForGrayscale)
+{
+    BitmapData bitmap (3, 1, PixelFormat::Grayscale);
+
+    bitmap.fillColor (Color (0xff00ff00));
+
+    const auto raw = bitmap.getRawData();
+
+    ASSERT_EQ (raw.size(), 3u);
+    EXPECT_EQ (raw[0], 182);
+    EXPECT_EQ (raw[1], 182);
+    EXPECT_EQ (raw[2], 182);
+    EXPECT_EQ (bitmap.getPixel (2, 0), 0xffb6b6b6u);
+}
+
+TEST (BitmapDataTests, SetPixelColorAndGetPixelColorRoundTrip)
+{
+    BitmapData bitmap (1, 1, PixelFormat::RGBA);
+
+    bitmap.setPixelColor (0, 0, Color (0x80123456));
+
+    EXPECT_EQ (bitmap.getPixelColor (0, 0), Color (0x80123456));
+}
+
+TEST (BitmapDataTests, MutableRawDataUpdatesPixelValues)
+{
+    BitmapData bitmap (1, 1, PixelFormat::RGB);
+
+    auto raw = bitmap.getRawData();
+    ASSERT_EQ (raw.size(), 3u);
+
+    raw[0] = 0x12;
+    raw[1] = 0x34;
+    raw[2] = 0x56;
+
+    EXPECT_EQ (bitmap.getPixel (0, 0), 0xff123456u);
+}
+
 TEST (BitmapDataTests, ClearZerosRawData)
 {
     BitmapData bitmap (2, 2, PixelFormat::RGBA);
@@ -187,6 +257,7 @@ TEST (BitmapDataTests, ConstructorRejectsInvalidDimensions)
     EXPECT_THROW (BitmapData (1, 0, PixelFormat::RGBA), std::invalid_argument);
     EXPECT_THROW (BitmapData (-1, 1, PixelFormat::RGBA), std::invalid_argument);
     EXPECT_THROW (BitmapData (1, -1, PixelFormat::RGBA), std::invalid_argument);
+    EXPECT_THROW (BitmapData (1, 1, static_cast<PixelFormat> (255)), std::runtime_error);
 }
 
 TEST (BitmapDataTests, PixelAccessRejectsOutOfRangeCoordinates)
@@ -198,6 +269,30 @@ TEST (BitmapDataTests, PixelAccessRejectsOutOfRangeCoordinates)
     EXPECT_THROW (bitmap.setPixel (2, 0, 0xffffffff), std::out_of_range);
     EXPECT_THROW (bitmap.setPixel (0, 2, 0xffffffff), std::out_of_range);
     EXPECT_THROW (bitmap.getPixel (2, 0), std::out_of_range);
+    EXPECT_THROW (bitmap.getPixelColor (0, 2), std::out_of_range);
+}
+
+TEST (ImageTests, DefaultConstructorCreatesInvalidImage)
+{
+    const Image image;
+
+    EXPECT_FALSE (image.isValid());
+}
+
+TEST (ImageTests, ConstructorExposesBitmapMetadata)
+{
+    Image image (3, 2, PixelFormat::RGB);
+
+    EXPECT_TRUE (image.isValid());
+    EXPECT_EQ (image.getWidth(), 3);
+    EXPECT_EQ (image.getHeight(), 2);
+    EXPECT_EQ (image.getPixelFormat(), PixelFormat::RGB);
+    EXPECT_EQ (image.getPixelStride(), 3);
+    EXPECT_EQ (image.getRawData().size(), 18u);
+
+    const auto& constImage = image;
+    EXPECT_EQ (constImage.getBitmapData().getWidth(), 3);
+    EXPECT_EQ (image.getBitmapData().getHeight(), 2);
 }
 
 TEST (ImageTests, FillColorAndClearRoundTrip)
@@ -213,6 +308,49 @@ TEST (ImageTests, FillColorAndClearRoundTrip)
     EXPECT_EQ (image.getPixel (1, 1), 0u);
 }
 
+TEST (ImageTests, MutableRawDataUpdatesPixelValues)
+{
+    Image image (1, 1, PixelFormat::RGBA);
+
+    auto raw = image.getRawData();
+    ASSERT_EQ (raw.size(), 4u);
+
+    raw[0] = 0x12;
+    raw[1] = 0x34;
+    raw[2] = 0x56;
+    raw[3] = 0x80;
+
+    EXPECT_EQ (image.getPixelColor (0, 0), Color (0x80123456));
+}
+
+TEST (ImageTests, CopyConstructorPreservesBitmapData)
+{
+    Image original (1, 1, PixelFormat::RGBA);
+    original.setPixel (0, 0, 0x80123456);
+
+    Image copy (original);
+
+    EXPECT_TRUE (copy.isValid());
+    EXPECT_EQ (copy.getWidth(), 1);
+    EXPECT_EQ (copy.getHeight(), 1);
+    EXPECT_EQ (copy.getPixelFormat(), PixelFormat::RGBA);
+    EXPECT_EQ (copy.getPixel (0, 0), 0x80123456u);
+}
+
+TEST (ImageTests, CopyAssignmentPreservesBitmapData)
+{
+    Image original (1, 1, PixelFormat::RGB);
+    original.setPixel (0, 0, 0x80123456);
+
+    Image copy (2, 2, PixelFormat::RGBA);
+    copy = original;
+
+    EXPECT_EQ (copy.getWidth(), 1);
+    EXPECT_EQ (copy.getHeight(), 1);
+    EXPECT_EQ (copy.getPixelFormat(), PixelFormat::RGB);
+    EXPECT_EQ (copy.getPixel (0, 0), 0xff123456u);
+}
+
 TEST (ImageTests, MoveConstructorTransfersBitmapData)
 {
     Image source (1, 1, PixelFormat::RGBA);
@@ -226,3 +364,34 @@ TEST (ImageTests, MoveConstructorTransfersBitmapData)
     EXPECT_EQ (moved.getHeight(), 1);
     EXPECT_EQ (moved.getPixel (0, 0), 0x80123456u);
 }
+
+TEST (ImageTests, MoveAssignmentTransfersBitmapData)
+{
+    Image source (1, 1, PixelFormat::RGBA);
+    source.setPixel (0, 0, 0x80123456);
+
+    Image moved (2, 2, PixelFormat::RGB);
+    moved = std::move (source);
+
+    EXPECT_FALSE (source.isValid());
+    EXPECT_TRUE (moved.isValid());
+    EXPECT_EQ (moved.getWidth(), 1);
+    EXPECT_EQ (moved.getHeight(), 1);
+    EXPECT_EQ (moved.getPixel (0, 0), 0x80123456u);
+}
+
+TEST (ImageTests, ConstructorRejectsInvalidDimensions)
+{
+    EXPECT_THROW (Image (0, 1, PixelFormat::RGBA), std::invalid_argument);
+    EXPECT_THROW (Image (1, 0, PixelFormat::RGBA), std::invalid_argument);
+}
+
+TEST (ImageTests, PixelAccessRejectsOutOfRangeCoordinates)
+{
+    Image image (2, 2, PixelFormat::RGBA);
+
+    EXPECT_THROW (image.setPixel (-1, 0, 0xffffffff), std::out_of_range);
+    EXPECT_THROW (image.setPixelColor (0, -1, Color (0xffffffff)), std::out_of_range);
+    EXPECT_THROW (image.getPixel (2, 0), std::out_of_range);
+    EXPECT_THROW (image.getPixelColor (0, 2), std::out_of_range);
+}