Update tests.

Author: cfis

test/bitmap_test.rb

@@ -6,26 +6,26 @@
 class BitmapTest < Minitest::Test
   def test_default_constructor
     image = Bmp::Bitmap.new
-    assert_equal 0, image.width
-    assert_equal 0, image.height
-    assert image.empty?
+    assert_equal(0, image.width)
+    assert_equal(0, image.height)
+    assert(image.empty?)
   end
 
   def test_dimensions_constructor
     image = Bmp::Bitmap.new(640, 480)
     assert_equal(640, image.width)
     assert_equal(480, image.height)
-    refute image.empty?
+    refute(image.empty?)
   end
 
   def test_clone
     original = Bmp::Bitmap.new(100, 100)
     original.set(50, 50, Bmp::Red)
 
     copy = original.clone
-    assert_equal 100, copy.width
-    assert_equal 100, copy.height
-    assert_equal Bmp::Red.r, copy.get(50, 50).r
+    assert_equal(100, copy.width)
+    assert_equal(100, copy.height)
+    assert_equal(Bmp::Red.r, copy.get(50, 50).r)
   end
 
   def test_clear_default
@@ -34,29 +34,29 @@ def test_clear_default
 
     # Should be black by default
     pixel = image.get(5, 5)
-    assert_equal 0, pixel.r
-    assert_equal 0, pixel.g
-    assert_equal 0, pixel.b
+    assert_equal(0, pixel.r)
+    assert_equal(0, pixel.g)
+    assert_equal(0, pixel.b)
   end
 
   def test_clear_with_color
     image = Bmp::Bitmap.new(10, 10)
     image.clear(Bmp::Red)
 
     pixel = image.get(5, 5)
-    assert_equal 255, pixel.r
-    assert_equal 0, pixel.g
-    assert_equal 0, pixel.b
+    assert_equal(255, pixel.r)
+    assert_equal(0, pixel.g)
+    assert_equal(0, pixel.b)
   end
 
   def test_get_and_set
     image = Bmp::Bitmap.new(10, 10)
     image.set(5, 5, Bmp::Blue)
 
     pixel = image.get(5, 5)
-    assert_equal Bmp::Blue.r, pixel.r
-    assert_equal Bmp::Blue.g, pixel.g
-    assert_equal Bmp::Blue.b, pixel.b
+    assert_equal(Bmp::Blue.r, pixel.r)
+    assert_equal(Bmp::Blue.g, pixel.g)
+    assert_equal(Bmp::Blue.b, pixel.b)
   end
 
   def test_array_access
@@ -65,19 +65,19 @@ def test_array_access
 
     # Linear index = x + width * y = 5 + 10 * 5 = 55
     pixel = image[55]
-    assert_equal Bmp::Green.r, pixel.r
-    assert_equal Bmp::Green.g, pixel.g
-    assert_equal Bmp::Green.b, pixel.b
+    assert_equal(Bmp::Green.r, pixel.r)
+    assert_equal(Bmp::Green.g, pixel.g)
+    assert_equal(Bmp::Green.b, pixel.b)
   end
 
   def test_array_assignment
     image = Bmp::Bitmap.new(10, 10)
     image[55] = Bmp::Yellow
 
     pixel = image.get(5, 5)
-    assert_equal Bmp::Yellow.r, pixel.r
-    assert_equal Bmp::Yellow.g, pixel.g
-    assert_equal Bmp::Yellow.b, pixel.b
+    assert_equal(Bmp::Yellow.r, pixel.r)
+    assert_equal(Bmp::Yellow.g, pixel.g)
+    assert_equal(Bmp::Yellow.b, pixel.b)
   end
 
   def test_equality
@@ -90,32 +90,48 @@ def test_equality
     image3 = Bmp::Bitmap.new(10, 10)
     image3.clear(Bmp::Blue)
 
-    assert image1 == image2
-    assert image1 != image3
+    assert(image1 == image2)
+    assert(image1 != image3)
   end
 
   def test_each_iterator
-    image = Bmp::Bitmap.new(10, 10)
+    image = Bmp::Bitmap.new(2, 2)
     count = 0
 
-    image.each do |pixel|
-      count += 1
-      pixel.r = 128
+    image.each.with_index do |pixel, i|
+			count +=1
+			pixel.r = i
+			pixel.g = i + 1
+			pixel.b = i + 2
     end
 
-    assert_equal 100, count
-    assert_equal 128, image.get(0, 0).r
+    assert_equal(4, count)
+		expected = [Bmp::Pixel.new(red: 0, green: 1, blue: 2),
+								Bmp::Pixel.new(red: 1, green: 2, blue: 3),
+								Bmp::Pixel.new(red: 2, green: 3, blue: 4),
+								Bmp::Pixel.new(red: 3, green: 4, blue: 5)]
+
+		assert_equal(expected, image.each.to_a)
   end
 
   def test_each_reverse_iterator
-    image = Bmp::Bitmap.new(10, 10)
-    count = 0
-
-    image.each_reverse do |_pixel|
-      count += 1
-    end
-
-    assert_equal 100, count
+		image = Bmp::Bitmap.new(2, 2)
+		count = 0
+
+		image.each_reverse.with_index do |pixel, i|
+			count +=1
+			pixel.r = i
+			pixel.g = i + 1
+			pixel.b = i + 2
+		end
+
+		assert_equal(4, count)
+		expected = [Bmp::Pixel.new(red: 3, green: 4, blue: 5),
+								Bmp::Pixel.new(red: 2, green: 3, blue: 4),
+								Bmp::Pixel.new(red: 1, green: 2, blue: 3),
+								Bmp::Pixel.new(red: 0, green: 1, blue: 2)]
+
+		assert_equal(expected, image.each.to_a)
   end
 
   def test_inspect

test/draw_primitives_test.rb

@@ -12,67 +12,67 @@ def test_draw_line
     @image.draw_line(0, 0, 99, 99, Bmp::Red)
 
     # Check that line pixels are set
-    assert_equal Bmp::Red.r, @image.get(0, 0).r
-    assert_equal Bmp::Red.r, @image.get(50, 50).r
-    assert_equal Bmp::Red.r, @image.get(99, 99).r
+    assert_equal(Bmp::Red.r, @image.get(0, 0).r)
+    assert_equal(Bmp::Red.r, @image.get(50, 50).r)
+    assert_equal(Bmp::Red.r, @image.get(99, 99).r)
   end
 
   def test_draw_rect
     @image.draw_rect(10, 10, 20, 20, Bmp::Blue)
 
     # Check corners
-    assert_equal Bmp::Blue.b, @image.get(10, 10).b
-    assert_equal Bmp::Blue.b, @image.get(29, 10).b
-    assert_equal Bmp::Blue.b, @image.get(10, 29).b
-    assert_equal Bmp::Blue.b, @image.get(29, 29).b
+    assert_equal(Bmp::Blue.b, @image.get(10, 10).b)
+    assert_equal(Bmp::Blue.b, @image.get(29, 10).b)
+    assert_equal(Bmp::Blue.b, @image.get(10, 29).b)
+    assert_equal(Bmp::Blue.b, @image.get(29, 29).b)
 
     # Check that interior is not filled
-    assert_equal Bmp::White.r, @image.get(15, 15).r
+    assert_equal(Bmp::White.r, @image.get(15, 15).r)
   end
 
   def test_fill_rect
     @image.fill_rect(10, 10, 20, 20, Bmp::Green)
 
     # Check interior is filled
-    assert_equal Bmp::Green.g, @image.get(15, 15).g
-    assert_equal Bmp::Green.g, @image.get(20, 20).g
+    assert_equal(Bmp::Green.g, @image.get(15, 15).g)
+    assert_equal(Bmp::Green.g, @image.get(20, 20).g)
   end
 
   def test_draw_triangle
     @image.draw_triangle(50, 10, 10, 90, 90, 90, Bmp::Cyan)
 
     # Check vertices
-    assert_equal Bmp::Cyan.r, @image.get(50, 10).r
-    assert_equal Bmp::Cyan.r, @image.get(10, 90).r
-    assert_equal Bmp::Cyan.r, @image.get(90, 90).r
+    assert_equal(Bmp::Cyan.r, @image.get(50, 10).r)
+    assert_equal(Bmp::Cyan.r, @image.get(10, 90).r)
+    assert_equal(Bmp::Cyan.r, @image.get(90, 90).r)
   end
 
   def test_fill_triangle
     @image.fill_triangle(50, 10, 10, 90, 90, 90, Bmp::Magenta)
 
     # Check interior is filled (center of triangle)
-    assert_equal Bmp::Magenta.r, @image.get(50, 60).r
+    assert_equal(Bmp::Magenta.r, @image.get(50, 60).r)
   end
 
   def test_draw_circle
     @image.draw_circle(50, 50, 20, Bmp::Yellow)
 
     # Check points on circle edge
-    assert_equal Bmp::Yellow.r, @image.get(50, 30).r  # Top
-    assert_equal Bmp::Yellow.r, @image.get(50, 70).r  # Bottom
-    assert_equal Bmp::Yellow.r, @image.get(30, 50).r  # Left
-    assert_equal Bmp::Yellow.r, @image.get(70, 50).r  # Right
+    assert_equal(Bmp::Yellow.r, @image.get(50, 30).r)  # Top
+    assert_equal(Bmp::Yellow.r, @image.get(50, 70).r)  # Bottom
+    assert_equal(Bmp::Yellow.r, @image.get(30, 50).r)  # Left
+    assert_equal(Bmp::Yellow.r, @image.get(70, 50).r)  # Right
 
     # Check center is not filled
-    assert_equal Bmp::White.r, @image.get(50, 50).r
+    assert_equal(Bmp::White.r, @image.get(50, 50).r)
   end
 
   def test_fill_circle
     @image.fill_circle(50, 50, 20, Bmp::Orange)
 
     # Check center is filled
-    assert_equal Bmp::Orange.r, @image.get(50, 50).r
-    assert_equal Bmp::Orange.r, @image.get(45, 50).r
+    assert_equal(Bmp::Orange.r, @image.get(50, 50).r)
+    assert_equal(Bmp::Orange.r, @image.get(45, 50).r)
   end
 
   def test_out_of_bounds_raises_exception

test/file_io_test.rb

@@ -26,10 +26,10 @@ def test_save_and_load
     assert(File.size(path) > 0)
 
     loaded = Bmp::Bitmap.new(path)
-    assert_equal 100, loaded.width
-    assert_equal 50, loaded.height
-    assert_equal Bmp::Red.r, loaded.get(0, 0).r
-    assert_equal Bmp::Blue.b, loaded.get(50, 25).b
+    assert_equal(100, loaded.width)
+    assert_equal(50, loaded.height)
+    assert_equal(Bmp::Red.r, loaded.get(0, 0).r)
+    assert_equal(Bmp::Blue.b, loaded.get(50, 25).b)
   end
 
   def test_load_into_existing_bitmap
@@ -45,8 +45,8 @@ def test_load_into_existing_bitmap
 		std_path = Std::Filesystem::Path.new(path)
     image.load(std_path)
 
-    assert_equal 100, image.width
-    assert_equal 100, image.height
+    assert_equal(100, image.width)
+    assert_equal(100, image.height)
   end
 
   def test_load_nonexistent_file_raises
@@ -74,7 +74,7 @@ def test_bitmap_file_format
     # Check BMP magic number
     File.open(path, "rb") do |f|
       magic = f.read(2)
-      assert_equal "BM", magic
+      assert_equal("BM", magic)
     end
   end
 
@@ -100,9 +100,9 @@ def test_roundtrip_preserves_pixels
       50.times do |x|
         orig_pixel = original.get(x, y)
         load_pixel = loaded.get(x, y)
-        assert_equal orig_pixel.r, load_pixel.r, "Mismatch at (#{x}, #{y})"
-        assert_equal orig_pixel.g, load_pixel.g, "Mismatch at (#{x}, #{y})"
-        assert_equal orig_pixel.b, load_pixel.b, "Mismatch at (#{x}, #{y})"
+        assert_equal(orig_pixel.r, load_pixel.r, "Mismatch at (#{x}, #{y})")
+        assert_equal(orig_pixel.g, load_pixel.g, "Mismatch at (#{x}, #{y})")
+        assert_equal(orig_pixel.b, load_pixel.b, "Mismatch at (#{x}, #{y})")
       end
     end
   end