small update

- removed assertPixels()
- added exportImg() to help graphics test writing (sets the "expected" image for the test)
- added "deflate" variants to love.data.compress()

testing/classes/TestMethod.lua

@@ -123,38 +123,6 @@ TestMethod = {
   end,
 
 
-  -- @method - TestMethod:assertPixels()
-  -- @desc - checks a list of coloured pixels agaisnt given imgdata
-  -- @param {ImageData} imgdata - image data to check
-  -- @param {table} pixelchecks - map of colors to list of pixel coords, i.e.
-  --                              { blue = { {1, 1}, {2, 2}, {3, 4} } }
-  -- @return {nil}
-  assertPixels = function(self, imgdata, pixelchecks, label)
-    for i, v in pairs(pixelchecks) do
-      local col = self.colors[i]
-      local pixels = v
-      for p=1,#pixels do
-        local coord = pixels[p]
-        local tr, tg, tb, ta = imgdata:getPixel(coord[1], coord[2])
-        local compare_id = tostring(coord[1]) .. ',' .. tostring(coord[2])
-        -- prevent us getting stuff like 0.501960785 for 0.5 red 
-        tr = math.floor((tr*10)+0.5)/10
-        tg = math.floor((tg*10)+0.5)/10
-        tb = math.floor((tb*10)+0.5)/10
-        ta = math.floor((ta*10)+0.5)/10
-        col[1] = math.floor((col[1]*10)+0.5)/10
-        col[2] = math.floor((col[2]*10)+0.5)/10
-        col[3] = math.floor((col[3]*10)+0.5)/10
-        col[4] = math.floor((col[4]*10)+0.5)/10
-        self:assertEquals(col[1], tr, 'check pixel r for ' .. i .. ' at ' .. compare_id .. '(' .. label .. ')')
-        self:assertEquals(col[2], tg, 'check pixel g for ' .. i .. ' at ' .. compare_id .. '(' .. label .. ')')
-        self:assertEquals(col[3], tb, 'check pixel b for ' .. i .. ' at ' .. compare_id .. '(' .. label .. ')')
-        self:assertEquals(col[4], ta, 'check pixel a for ' .. i .. ' at ' .. compare_id .. '(' .. label .. ')')
-      end
-    end
-  end,
-
-
   -- @method - TestMethod:assertRange()
   -- @desc - used to check a value is within an expected range
   -- @param {number} actual - actual value of the test
@@ -350,13 +318,30 @@ TestMethod = {
         )
       end
     end
-    local path = 'tempoutput/actual/love.test.graphics.' .. 
+    local path = 'tempoutput/actual/love.test.graphics.' ..
       self.method .. '-' .. tostring(self.imgs) .. '.png'
     imgdata:encode('png', path)
     self.imgs = self.imgs + 1
   end,
 
 
+  -- @method - TestMethod:exportImg()
+  -- @desc - exports the given imgdata to the 'output/expected/' folder, to use when
+  --         writing new graphics tests to set the expected image output 
+  -- @NOTE - you should not leave this method in when you are finished this is 
+  --         for test writing only
+  -- @param {table} imgdata - imgdata to save as a png
+  -- @param {integer} imgdata - index of the png, graphic tests are run sequentially
+  --                            and each test image is numbered in order that its 
+  --                            compared to, so set the number here to match
+  -- @return {nil}
+  exportImg = function(self, imgdata, index)
+    local path = 'tempoutput/expected/love.test.graphics.' ..
+      self.method .. '-' .. tostring(index) .. '.png'
+    imgdata:encode('png', path)
+  end,
+
+
   -- @method - TestMethod:skipTest()
   -- @desc - used to mark this test as skipped for a specific reason
   -- @param {string} reason - reason why method is being skipped

testing/readme.md

@@ -82,7 +82,6 @@ Each module has a TestModule object created, and each test method has a TestMeth
 - **assertGreaterEqual**(expected, actual, label)
 - **assertLessEqual**(expected, actual, label)
 - **assertObject**(table)
-- **assertPixels**(imgdata, pixeltable, label)
 - **assertCoords**(expected, actual, label)
 
 Example test method:

testing/tests/data.lua

@@ -83,6 +83,10 @@ love.test.data.compress = function(test)
     { love.data.compress('string', 'gzip', 'helloworld', -1), 'string'},
     { love.data.compress('string', 'gzip', 'helloworld', 0), 'string'},
     { love.data.compress('string', 'gzip', 'helloworld', 9), 'string'},
+    { love.data.compress('string', 'deflate', 'aaaaaa', 1), 'string'},
+    { love.data.compress('string', 'deflate', 'heloworld', -1), 'string'},
+    { love.data.compress('string', 'deflate', 'heloworld', 0), 'string'},
+    { love.data.compress('string', 'deflate', 'heloworld', 9), 'string'},
     { love.data.compress('data', 'lz4', 'helloworld', -1), 'userdata'},
     { love.data.compress('data', 'lz4', 'helloworld', 0), 'userdata'},
     { love.data.compress('data', 'lz4', 'helloworld', 9), 'userdata'},
@@ -91,7 +95,10 @@ love.test.data.compress = function(test)
     { love.data.compress('data', 'zlib', 'helloworld', 9), 'userdata'},
     { love.data.compress('data', 'gzip', 'helloworld', -1), 'userdata'},
     { love.data.compress('data', 'gzip', 'helloworld', 0), 'userdata'},
-    { love.data.compress('data', 'gzip', 'helloworld', 9), 'userdata'}
+    { love.data.compress('data', 'gzip', 'helloworld', 9), 'userdata'},
+    { love.data.compress('data', 'deflate', 'heloworld', -1), 'userdata'},
+    { love.data.compress('data', 'deflate', 'heloworld', 0), 'userdata'},
+    { love.data.compress('data', 'deflate', 'heloworld', 9), 'userdata'},
   }
   for c=1,#compressions do
     test:assertNotNil(compressions[c][1])

testing/tests/graphics.lua

@@ -192,9 +192,6 @@ love.test.graphics.Canvas = function(test)
     love.graphics.setColor(1, 1, 1, 1)
   end)
   local imgdata1 = love.graphics.readbackTexture(canvas)
-  test:assertPixels(imgdata1, {
-    red = {{0, 0},{0,99},{99,0},{99,99}},
-  }, 'font draw check')
   test:compareImg(imgdata1)
 
   -- check using canvas in love.graphics.draw()
@@ -203,9 +200,6 @@ love.test.graphics.Canvas = function(test)
     love.graphics.draw(canvas, 0, 0)
   love.graphics.setCanvas()
   local imgdata2 = love.graphics.readbackTexture(canvas)
-  test:assertPixels(imgdata2, {
-    red = {{0, 0},{0,99},{99,0},{99,99}},
-  }, 'font draw check')
   test:compareImg(imgdata2)
 
   -- check depth samples
@@ -281,9 +275,6 @@ love.test.graphics.Font = function(test)
     love.graphics.print('Aa', 0, 5)
   love.graphics.setCanvas()
   local imgdata = love.graphics.readbackTexture(canvas)
-  test:assertPixels(imgdata, {
-    white = {{0,3},{4,3},{7,4},{9,4},{10,5},{0,8},{4,8},{10,8}},
-  }, 'font draw check')
   test:compareImg(imgdata)
 
   -- check font substitution
@@ -297,10 +288,6 @@ love.test.graphics.Font = function(test)
     love.graphics.print('CD', 0, 9) -- should come from fontcd
   love.graphics.setCanvas()
   local imgdata2 = love.graphics.readbackTexture(canvas)
-  test:assertPixels(imgdata2, {
-    green = {{1,8},{6,8},{2,10},{5,10},{9,10}},
-    black = {{9,9},{14,8},{14,10},{14,1},{1,10}}
-  }, 'font draw check')
   test:compareImg(imgdata2)
 
 end
@@ -789,11 +776,6 @@ love.test.graphics.Quad = function(test)
     love.graphics.draw(texture, quad, 32, 32)
   love.graphics.setCanvas()
   local imgdata = love.graphics.readbackTexture(canvas)
-  test:assertPixels(imgdata, {
-    white = {{17,31},{31,31},{31,24},{32,32},{46,32},{32,46}},
-    lovepink = {{2,31},{31,2}},
-    loveblue = {{32,61},{61,32}}
-  }, 'check quad drawing')
   test:compareImg(imgdata)
 
 end
@@ -867,10 +849,6 @@ love.test.graphics.Shader = function(test)
     love.graphics.setColor(1, 1, 1, 1)
   love.graphics.setCanvas()
   local imgdata = love.graphics.readbackTexture(canvas)
-  test:assertPixels(imgdata, {
-    red = {{1,1},{1,7},{7,7},{7,1}},
-    yellow = {{8,8},{8,15},{15,15},{15,8}}
-  }, 'shader draw check')
   test:compareImg(imgdata)
 
 end
@@ -945,9 +923,6 @@ love.test.graphics.SpriteBatch = function(test)
     love.graphics.draw(sbatch, 0, 0)
   love.graphics.setCanvas()
   local imgdata1 = love.graphics.readbackTexture(canvas)
-  test:assertPixels(imgdata1, {
-    lovepink = {{0,0},{63,2},{0,32},{63,32},{63,0},{63,2}}
-  }, 'sbatch draw normal')
   test:compareImg(imgdata1)
 
   -- use set to change some sprites
@@ -959,11 +934,6 @@ love.test.graphics.SpriteBatch = function(test)
     love.graphics.draw(sbatch, 0, 0)
   love.graphics.setCanvas()
   local imgdata2 = love.graphics.readbackTexture(canvas)
-  test:assertPixels(imgdata2, {
-    lovepink = {{0,32},{63,32}},
-    black = {{0,0},{63,0}},
-    white = {{0,1},{63,1},{0,31},{63,31}}
-  }, 'sbatch draw set')
   test:compareImg(imgdata2)
 
   -- set drawRange and redraw
@@ -973,11 +943,6 @@ love.test.graphics.SpriteBatch = function(test)
     love.graphics.draw(sbatch, 0, 0)
   love.graphics.setCanvas()
   local imgdata3 = love.graphics.readbackTexture(canvas)
-  test:assertPixels(imgdata3, {
-    lovepink = {{0,32},{63,32}},
-    black = {{0,0},{63,0},{0,48},{63,48}},
-    white = {{0,17},{63,17},{0,31},{63,31}}
-  }, 'sbatch draw drawrange')
   test:compareImg(imgdata3)
 
   -- clear and redraw
@@ -987,9 +952,6 @@ love.test.graphics.SpriteBatch = function(test)
     love.graphics.draw(sbatch, 0, 0)
   love.graphics.setCanvas()
   local imgdata4 = love.graphics.readbackTexture(canvas)
-  test:assertPixels(imgdata4, {
-    black = {{0,0},{63,0},{0,32},{63,32},{0,63},{63,63}},
-  }, 'sbatch draw clear')
   test:compareImg(imgdata4)
 
   -- array texture sbatch
@@ -1013,11 +975,6 @@ love.test.graphics.SpriteBatch = function(test)
     love.graphics.draw(asbatch, 0, 0)
   love.graphics.setCanvas()
   local imgdata5 = love.graphics.readbackTexture(canvas)
-  test:assertPixels(imgdata5, {
-    loveblue = {{31,2},{63,2},{3,30},{3,33},{16,47},{63,47}},
-    lovepink = {{17,48},{63,48},{31,61},{63,61}},
-    black = {{0,0},{63,0},{63,63},{63,0},{30,2},{30,61}},
-  }, 'sbatch draw layers')
   test:compareImg(imgdata5)
 
 end
@@ -1059,10 +1016,6 @@ love.test.graphics.Text = function(test)
     love.graphics.draw(colortext, 0, 10)
   love.graphics.setCanvas()
   local imgdata = love.graphics.readbackTexture(canvas)
-  test:assertPixels(imgdata, {
-    yellow = {{1,9},{8,13},{16,11},{22,10},{25,7},{29,9},{32,13},{34,15}},
-    white = {{17,13},{30,12},{38,9},{44,13},{58,13},{8,29},{58,29},{57,37},{5,39},{57,45},{1,55}}
-  }, 'text draw check')
   test:compareImg(imgdata)
 
 end
@@ -1124,10 +1077,6 @@ love.test.graphics.Video = function(test)
     love.graphics.draw(video, 0, 0)
   love.graphics.setCanvas()
   local imgdata = love.graphics.readbackTexture(canvas)
-  test:assertPixels(imgdata, {
-    black = {{0,0},{495,0},{495,499},{0,499}},
-    red = {{499,0},{499,499}}
-  }, 'video draw')
   test:compareImg(imgdata)
 
 end
@@ -1211,19 +1160,6 @@ love.test.graphics.circle = function(test)
     love.graphics.setColor(1, 1, 1, 1)
   love.graphics.setCanvas()
   local imgdata = love.graphics.readbackTexture(canvas)
-  test:assertPixels(imgdata, {
-    white = {{13,8},{18,8},{23,13},{23,18}},
-    green = {
-      {15,12},{16,12},{13,13},{18,13},{12,15},{12,16},{13,18},{18,18},
-      {15,19},{16,19},{19,15},{19,16}
-    },
-    black = {{10,0},{21,0},{0,10},{0,21},{31,10},{31,21},{10,31},{21,31}},
-    yellow = {
-      {11,10},{10,11},{8,14},{8,17},{10,20},{11,21},{14,23},{17,23},{20,21},
-      {21,20},{23,17},{23,14},{20,10},{21,11},{17,8},{14,8}
-    },
-    red = {{11,0},{20,0},{11,31},{20,31},{0,11},{0,20},{31,20},{31,11}}
-  }, 'circle')
   test:compareImg(imgdata)
 end
 
@@ -1237,9 +1173,6 @@ love.test.graphics.clear = function(test)
     love.graphics.clear(1, 1, 0, 1)
   love.graphics.setCanvas()
   local imgdata = love.graphics.readbackTexture(canvas)
-  test:assertPixels(imgdata, {
-    yellow = {{0,0},{15,0},{0,15},{15,15},{8,8}}
-  }, 'clear')
   test:compareImg(imgdata)
 end
 
@@ -1272,12 +1205,6 @@ love.test.graphics.draw = function(test)
     love.graphics.draw(canvas1, transform)
   love.graphics.setCanvas()
   local imgdata = love.graphics.readbackTexture(canvas2)
-  test:assertPixels(imgdata, {
-    lovepink = {{23,3},{23,19},{7,19},{0,0},{16,0},{0,16},{16,16}},
-    loveblue = {{0,31},{15,17},{15,31},{16,31},{31,17},{31,31},{16,15},{31,15}},
-    white = {{6,19},{8,19},{22,19},{24,19},{22,3},{24,3}},
-    red = {{0,1},{1,0},{15,0},{15,7},{0,15},{7,15}}
-  }, 'drawing')
   test:compareImg(imgdata)
 end
 
@@ -1298,12 +1225,6 @@ love.test.graphics.drawInstanced = function(test)
     love.graphics.drawInstanced(mesh, 1000, 0, 0, 0, 1, 1)
   love.graphics.setCanvas()
   local imgdata = love.graphics.readbackTexture(canvas)
-  test:assertPixels(imgdata, {
-    red = {{0,0}},
-    green = {{63,0}},
-    blue = {{63,63}},
-    yellow = {{0,63}}
-  }, 'draw instances')
   -- need 1 tolerance here just cos of the amount of colors
   test.rgba_tolerance = 1
   test:compareImg(imgdata)
@@ -1325,12 +1246,6 @@ love.test.graphics.drawLayer = function(test)
     love.graphics.drawLayer(image, 3, 32, 32, 0, 2, 2, 16, 16)
   love.graphics.setCanvas()
   local imgdata = love.graphics.readbackTexture(canvas)
-  test:assertPixels(imgdata, {
-    lovepink = {{30,2},{33,2},{2,30},{2,33},{4,60},{4,63},{60,4},{63,4},{31,23},{32,23}},
-    loveblue = {{14,33},{17,33},{46,1},{49,1},{1,46},{1,49},{33,14},{33,17}},
-    black = {{0,0},{63,0},{0,63},{39,6},{40,6},{6,39},{6,40},{6,55},{55,6}},
-    white = {{46,11},{48,11},{14,43},{16,43},{30,23},{33,23},{34,54},{53,40},{63,63}}
-  }, 'draw layer')
   test:compareImg(imgdata)
 end
 
@@ -1349,11 +1264,6 @@ love.test.graphics.ellipse = function(test)
     love.graphics.setColor(1, 1, 1, 1)
   love.graphics.setCanvas()
   local imgdata = love.graphics.readbackTexture(canvas)
-  test:assertPixels(imgdata, {
-    red = {{0,14},{0,17},{7,9},{7,22},{14,15},{14,16}},
-    pink = {{15,15},{16,15},{8,0},{8,4},{23,0},{23,4},{13,14},{18,14}},
-    yellow = {{24,0},{25,0},{14,17},{14,30},{15,31},{31,8}}
-  }, 'ellipses')
   test:compareImg(imgdata)
 end
 
@@ -1386,10 +1296,6 @@ love.test.graphics.line = function(test)
     love.graphics.setColor(1, 1, 1, 1)
   love.graphics.setCanvas()
   local imgdata = love.graphics.readbackTexture(canvas)
-  test:assertPixels(imgdata, {
-    yellow = {{0,0},{15,0},{0,15},{15,15},{7,7},{8,7},{8,7},{8,8}},
-    red = {{1,0},{14,0},{0,1},{0,14},{15,1},{15,14},{1,15},{14,15}}
-  }, 'lines')
   test:compareImg(imgdata)
 end
 
@@ -1423,10 +1329,6 @@ love.test.graphics.polygon = function(test)
     love.graphics.setColor(1, 1, 1, 1)
   love.graphics.setCanvas()
   local imgdata = love.graphics.readbackTexture(canvas)
-  test:assertPixels(imgdata, {
-    yellow = {{1,0},{1,1},{5,9},{7,14},{8,14},{12,3}},
-    red = {{2,1},{1,2},{1,7},{5,15},{14,15},{8,8},{14,2},{7,1}}
-  }, 'polygon')
   test:compareImg(imgdata)
 end
 
@@ -1446,17 +1348,6 @@ love.test.graphics.print = function(test)
     love.graphics.setColor(1, 1, 1, 1)
   love.graphics.setCanvas()
   local imgdata = love.graphics.readbackTexture(canvas)
-  test:assertPixels(imgdata, {
-    red = {{0,0},{1,0},{1,1},{2,6},{4,4},{7,6},{10,2},{11,5},{14,3},{14,4}},
-    green = {
-      {2,1},{2,2},{0,3},{1,3},{1,8},{2,9},{7,10},{8,8},{9,4},{13,3},{14,2},
-      {13,8},{14,9}
-    },
-    blue = {
-      {4,15},{10,15},{4,12},{6,12},{8,12},{5,9},{7,9},{4,3},{10,3},{8,6},{7,7},
-      {4,7},{7,13},{8,12}
-    }
-  }, 'print')
   test:compareImg(imgdata)
 end
 
@@ -1476,17 +1367,6 @@ love.test.graphics.printf = function(test)
     love.graphics.setColor(1, 1, 1, 1)
   love.graphics.setCanvas()
   local imgdata = love.graphics.readbackTexture(canvas)
-  test:assertPixels(imgdata, {
-    red = {
-      {1,0},{1,1},{0,3},{2,3},{2,7},{0,9},{3,11},{4,10},{0,15},{4,15},{2,19},
-      {0,24},{1,23},{3,23},{4,24},{0,26},{1,27},{2,27},{3,27}
-    },
-    green = {
-      {1,2},{0,8},{1,8},{2,8},{4,7},{5,8},{7,8},{8,7},{10,4},{14,4},{11,7},
-      {12,8},{10,13},{11,12},{13,12},{14,13},{10,15},{11,16}
-    },
-    blue = {{6,4},{6,10},{9,7},{10,6},{16,9},{18,9},{21,8},{25,8}}
-  }, 'printf')
   test:compareImg(imgdata)
 end
 
@@ -1504,11 +1384,7 @@ love.test.graphics.rectangle = function(test)
     love.graphics.setColor(1, 1, 1, 1)
   love.graphics.setCanvas()
   local imgdata1 = love.graphics.readbackTexture(canvas)
-  -- test, check red bg and blue central square
-  test:assertPixels(imgdata1, {
-    red = {{0,0},{15,0},{15,15},{0,15}},
-    blue = {{6,6},{9,6},{9,9},{6,9}}
-  }, 'fill')
+  test:compareImg(imgdata1)
   -- clear canvas to do some line testing
   love.graphics.setCanvas(canvas)
     love.graphics.clear(0, 0, 0, 1)
@@ -1521,17 +1397,6 @@ love.test.graphics.rectangle = function(test)
     love.graphics.setColor(1, 1, 1, 1)
   love.graphics.setCanvas()
   local imgdata2 = love.graphics.readbackTexture(canvas)
-  -- -- check corners and inner corners
-  test:assertPixels(imgdata2, {
-    red = {{3,0},{9,0},{3,15,9,15}},
-    blue = {{0,0},{2,0},{0,15},{2,15}},
-    green = {{10,0},{15,0},{10,15},{15,15}},
-    black = {
-      {1,1},{1,14},{3,1},{9,1},{3,14},
-      {9,14},{11,1},{14,1},{11,14},{14,14}
-    }
-  }, 'line')
-  test:compareImg(imgdata1)
   test:compareImg(imgdata2)
 end
 
@@ -1978,10 +1843,6 @@ love.test.graphics.intersectScissor = function(test)
     love.graphics.setScissor()
   love.graphics.setCanvas()
   local imgdata = love.graphics.readbackTexture(canvas)
-  test:assertPixels(imgdata, { 
-    red = {{0,0},{3,3}},
-    black ={{4,0},{0,4},{4,4}}
-  }, 'intersect scissor')
   test:compareImg(imgdata)
 end
 
@@ -2074,13 +1935,6 @@ love.test.graphics.setBlendMode = function(test)
     love.graphics.setColor(1, 1, 1, 1)
   love.graphics.setCanvas()
   local imgdata = love.graphics.readbackTexture(canvas)
-  -- check the 4 corners
-  test:assertPixels(imgdata, {
-    redpale = {{0,0}},
-    black = {{15,0}},
-    greenhalf = {{15,15}},
-    bluefade = {{0,15}}
-  }, 'blend mode')
   love.graphics.setBlendMode('alpha', 'alphamultiply') -- reset 
   -- need 1rgba tolerance here on some machines
   test.rgba_tolerance = 1
@@ -2103,10 +1957,6 @@ love.test.graphics.setCanvas = function(test)
   love.graphics.setCanvas()
   test:assertEquals(nil, love.graphics.getCanvas(), 'check no canvas set')
   local imgdata = love.graphics.readbackTexture(canvas2)
-  -- check 2nd canvas is red
-  test:assertPixels(imgdata, {
-    red = {{0,0},{15,0},{15,15},{0,15}}
-  }, 'set canvas')
   test:compareImg(imgdata)
 end
 
@@ -2134,12 +1984,6 @@ love.test.graphics.setColor = function(test)
     love.graphics.setColor(1, 1, 1, 1)
   love.graphics.setCanvas()
   local imgdata = love.graphics.readbackTexture(canvas)
-  test:assertPixels(imgdata, {
-    red = {{0,0},{5,0},{10,0},{15,0}},
-    yellow = {{0,1},{5,1},{10,1},{15,1}},
-    greenhalf = {{0,2},{5,2},{10,2},{15,2}},
-    blue = {{0,3},{5,3},{10,3},{15,3}}
-  }, 'set color')
   test:compareImg(imgdata)
 end
 
@@ -2163,9 +2007,6 @@ love.test.graphics.setColorMask = function(test)
     love.graphics.setColorMask(true, true, true, true)
   love.graphics.setCanvas()
   local imgdata = love.graphics.readbackTexture(canvas)
-  test:assertPixels(imgdata, {
-    yellow = {{0,0},{0,15},{15,15},{15,0}}
-  }, 'set color mask')
   test:compareImg(imgdata)
 end
 
@@ -2211,13 +2052,6 @@ love.test.graphics.setFont = function(test)
     love.graphics.setColor(1, 1, 1, 1)
   love.graphics.setCanvas()
   local imgdata = love.graphics.readbackTexture(canvas)
-  test:assertPixels(imgdata, {
-    red = {
-      {0,0},{0,6},{2,6},{6,2},
-      {4,4},{8,4},{6,6},{10,2},
-      {14,2},{12,6}
-    }
-  }, 'set font for print')
   test:compareImg(imgdata)
 end
 
@@ -2260,12 +2094,6 @@ love.test.graphics.setLineJoin = function(test)
     love.graphics.origin()
   love.graphics.setCanvas()
   local imgdata = love.graphics.readbackTexture(canvas)
-  test:assertPixels(imgdata, {
-    black = {{8,0}},
-    red = {{8,4}},
-    yellow = {{8,7}},
-    blue = {{8,8}}
-  }, 'set line join')
   test:compareImg(imgdata)
 end
 
@@ -2288,10 +2116,6 @@ love.test.graphics.setLineStyle = function(test)
     love.graphics.origin()
   love.graphics.setCanvas()
   local imgdata = love.graphics.readbackTexture(canvas)
-  test:assertPixels(imgdata, {
-    red = {{0,0},{7,0},{15,0}},
-    red07 = {{0,4},{7,4},{15,4}}
-  }, 'set line style')
   -- linux runner needs a 1/255 tolerance for the blend between a rough line + bg 
   if GITHUB_RUNNER and love.system.getOS() == 'Linux' then
     test.rgba_tolerance = 1
@@ -2323,12 +2147,6 @@ love.test.graphics.setLineWidth = function(test)
     love.graphics.origin()
   love.graphics.setCanvas()
   local imgdata = love.graphics.readbackTexture(canvas)
-  test:assertPixels(imgdata, {
-    black = {{0,2},{6,2},{0,6},{5,6},{0,11},{5,11}},
-    red = {{0,0},{0,1},{7,2},{8,2}},
-    yellow = {{0,3},{0,5},{6,6},{8,6}},
-    blue = {{0,7},{0,10},{6,15},{9,15}}
-  }, 'set line width')
   test:compareImg(imgdata)
 end
 
@@ -2362,10 +2180,6 @@ love.test.graphics.setScissor = function(test)
     love.graphics.setScissor()
   love.graphics.setCanvas()
   local imgdata = love.graphics.readbackTexture(canvas)
-  test:assertPixels(imgdata, { 
-    red = {{0,0},{7,0},{0,15},{7,15}},
-    black ={{8,0},{8,15},{15,0},{15,15}}
-  }, 'set scissor')
   test:compareImg(imgdata)
 end
 
@@ -2396,9 +2210,6 @@ love.test.graphics.setShader = function(test)
     love.graphics.setColor(1, 1, 1, 1)
   love.graphics.setCanvas()
   local imgdata = love.graphics.readbackTexture(canvas)
-  test:assertPixels(imgdata, { 
-    yellow = {{0,0},{15,0},{0,15},{15,15}},
-  }, 'check shader set to yellow')
   test:compareImg(imgdata)
 end
 
@@ -2417,9 +2228,6 @@ love.test.graphics.setStencilState = function(test)
     love.graphics.setStencilState()
   love.graphics.setCanvas()
   local imgdata = love.graphics.readbackTexture(canvas)
-  test:assertPixels(imgdata, { 
-    red = {{6,2},{9,2},{2,6},{2,9},{13,6},{9,6},{6,13},{9,13}}
-  }, 'check stencil test')
   test:compareImg(imgdata)
 end
 
@@ -2471,7 +2279,6 @@ love.test.graphics.applyTransform = function(test)
     love.graphics.setColor(1, 1, 1, 1)
   love.graphics.setCanvas()
   local imgdata = love.graphics.readbackTexture(canvas)
-  test:assertPixels(imgdata, { red = {{10, 0}} }, 'apply transform 10')
   test:compareImg(imgdata)
 end
 
@@ -2508,7 +2315,6 @@ love.test.graphics.origin = function(test)
     love.graphics.setColor(1, 1, 1, 1)
   love.graphics.setCanvas()
   local imgdata = love.graphics.readbackTexture(canvas)
-  test:assertPixels(imgdata, { red = {{0, 0}} }, 'origin check')
   test:compareImg(imgdata)
 end
 
@@ -2530,7 +2336,6 @@ love.test.graphics.pop = function(test)
     love.graphics.setColor(1, 1, 1, 1)
   love.graphics.setCanvas()
   local imgdata = love.graphics.readbackTexture(canvas)
-  test:assertPixels(imgdata, { red = {{0, 0}} }, 'pop 1')
   test:compareImg(imgdata)
 end
 
@@ -2553,7 +2358,6 @@ love.test.graphics.push = function(test)
     love.graphics.setColor(1, 1, 1, 1)
   love.graphics.setCanvas()
   local imgdata = love.graphics.readbackTexture(canvas)
-  test:assertPixels(imgdata, { red = {{1, 1}} }, 'push 1')
   test:compareImg(imgdata)
 end
 
@@ -2575,7 +2379,6 @@ love.test.graphics.replaceTransform = function(test)
     love.graphics.setColor(1, 1, 1, 1)
   love.graphics.setCanvas()
   local imgdata = love.graphics.readbackTexture(canvas)
-  test:assertPixels(imgdata, { red = {{10, 0}} }, 'replace transform 10')
   test:compareImg(imgdata)
 end
 
@@ -2594,7 +2397,6 @@ love.test.graphics.rotate = function(test)
     love.graphics.setColor(1, 1, 1, 1)
   love.graphics.setCanvas()
   local imgdata = love.graphics.readbackTexture(canvas)
-  test:assertPixels(imgdata, { red = {{0,0},{3,0},{3,3},{0,3}} }, 'rotate 90')
   test:compareImg(imgdata)
 end
 
@@ -2612,7 +2414,7 @@ love.test.graphics.scale = function(test)
     love.graphics.setColor(1, 1, 1, 1)
   love.graphics.setCanvas()
   local imgdata = love.graphics.readbackTexture(canvas)
-  test:assertPixels(imgdata, { red = {{1,1},{1,15},{15,1},{15,15}} }, 'scale 4x')
+  test:compareImg(imgdata)
 end
 
 
@@ -2630,7 +2432,7 @@ love.test.graphics.shear = function(test)
     love.graphics.setColor(1, 1, 1, 1)
   love.graphics.setCanvas()
   local imgdata1 = love.graphics.readbackTexture(canvas)
-  test:assertPixels(imgdata1, { red = {{1,0},{4,0},{7,3},{10,3}} }, 'shear x')
+  test:compareImg(imgdata1)
   -- same again at 0,0, we shear by 2y and then draw
   -- we can then check the drawn rectangle has moved down
   love.graphics.setCanvas(canvas)
@@ -2642,8 +2444,6 @@ love.test.graphics.shear = function(test)
     love.graphics.setColor(1, 1, 1, 1)
   love.graphics.setCanvas()
   local imgdata2 = love.graphics.readbackTexture(canvas)
-  test:assertPixels(imgdata2, { red = { {0,1},{0,4},{3,7},{3,10}} }, 'shear y')
-  test:compareImg(imgdata1)
   test:compareImg(imgdata2)
 end
 
@@ -2681,7 +2481,6 @@ love.test.graphics.translate = function(test)
     love.graphics.setColor(1, 1, 1, 1)
   love.graphics.setCanvas()
   local imgdata = love.graphics.readbackTexture(canvas)
-  test:assertPixels(imgdata, { red = {{5,0},{0,5},{5,5},{0,0}} }, 'translate 4x')
   test:compareImg(imgdata)
 end