content: {-# LANGUAGE TemplateHaskell, ScopedTypeVariables #-}
  
  module Set8Test where
  
  import Data.List hiding (union)
  import Test.QuickCheck
  
  import Mooc.Th
  import Mooc.Test
  
  import Set8 hiding (main)
  
  main = score [(1,"dotAndLine",[ex1_line, ex1_dot, ex1_black, ex1_line_far])
               ,(2,"blend",[ex2_blendColor, ex2_render, ex2_solid, ex2_const])
               ,(3,"rectangle",[ex3])
               ,(4,"union",[ex4_union, ex4_cut])
               ,(5,"paintSolid",[ex5_render, ex5_dot])
               ,(6,"paint",[ex6_render, ex6_dot])
               ,(7,"Transform",[ex7_fill, ex7_zoom_xy, ex7_zoom_dot, ex7_flipx, ex7_flipy, ex7_flipxy])
               ,(8,"Chain",[ex8_inverse, ex8_order, ex8_zoom])
               ,(9,"Blur",[ex9_blur_dot, ex9_blur_solid])
               ,(10,"BlurMany",[ex10_blur_once, ex10_blur_many])]
  
  --
  
  checkPicture x y exp (Picture f) =
    counterexample (" color of point (" ++ show x ++ "," ++ show y ++ ")") $
    (f (Coord x y)) ?== exp
  
  checkShape x y exp (Shape f) =
    counterexample (" contains point (" ++ show x ++ "," ++ show y ++ ")") $
    f (Coord x y) ?== exp
  
  instance Arbitrary Color where
    arbitrary = Color <$> comp <*> comp <*> comp
      where comp = choose (0,255)
  
  ex1_line = $(testing' [|renderList dotAndLine (2,4) (8,8)|]) (?==[["ff69b4","ff69b4","ff69b4"]])
  ex1_dot = $(testing' [|renderList dotAndLine (2,4) (4,4)|]) (?==[["000000","ffffff","000000"]])
  ex1_black = forAll_ $ \(x,y) ->
    (x,y) /= (3,4) ==>
    y /= 8 ==>
    $(testing' [|getPixel dotAndLine x y|]) $ \val ->
    counterexample ("  with x = "++show x++" and y = "++show y) $
    val ?== "000000"
  ex1_line_far = forAll_ $ \x ->
    $(testing' [|getPixel dotAndLine x 8|]) $ \val ->
    counterexample ("  with x = "++show x) $
    val ?== "ff69b4"
  
  ex2_blendColor =
    forAll_ $ \(Color r g b) ->
    forAllBlind (choose (0,min r (255-r))) $ \r' ->
    forAllBlind (choose (0,min g (255-g))) $ \g' ->
    forAllBlind (choose (0,min b (255-r))) $ \b' ->
    $(testing [|blendColor (Color (r-r') (g-g') (b-b')) (Color (r+r') (g+g') (b+b'))|]) (?== Color r g b)
  
  ex2_render = conjoin
    [$(testing' [|renderList (combine blendColor (solid red) justADot) (9,11) (10,10)|])
     (?==[["7f0000","ff7f7f","7f0000"]])
    ,$(testing' [|renderList (combine blendColor justADot (solid white)) (9,11) (10,10)|])
     (?==[["7f7f7f","ffffff","7f7f7f"]])]
  
  ex2_solid = forAll_ $ \c1 ->
    forAll_ $ \c2 ->
    forAll_ $ \(x,y) ->
    counterexample ("combine blendColor (solid ("++show c1++")) (solid ("++show c2++"))") $
    checkPicture x y (blendColor c1 c2) (combine blendColor (solid c1) (solid c2))
  
  ex2_const = forAll_ $ \c1 ->
    forAll_ $ \c2 ->
    forAll_ $ \(x,y) ->
    counterexample ("combine (\\c1 c2 -> c1) (solid ("++show c1++")) (solid ("++show c2++"))") $
    checkPicture x y c1 (combine (\c1 c2 -> c1) (solid c1) (solid c2))
  
  ex3 = forAll_ $ \(Positive x0,Positive y0) ->
    forAllBlind (choose (1,10)) $ \w ->
    forAllBlind (choose (1,10)) $ \h ->
    $(testing [|rectangle x0 y0 w h|]) $ \rect ->
    conjoin [checkShape x y True rect | x <- [x0..x0+w-1], y <- [y0..y0+h-1]]
    .&&. conjoin [checkShape (x0-1) y False rect | y <- [y0-1..y0+h]] -- left
    .&&. conjoin [checkShape (x0+w) y False rect | y <- [y0-1..y0+h]] -- right
    .&&. conjoin [checkShape x (y0-1) False rect | x <- [x0-1..x0+w]] -- top
    .&&. conjoin [checkShape x (y0+h) False rect | x <- [x0-1..x0+w]] -- bottom
    .&&. conjoin [checkShape (x0-h) (y0-w) False rect
                 ,checkShape x0 (y0+h+w) False rect
                 ,checkShape (x0+max h w) (y0+1) False rect]
  
  ex4_union = forAll_ $ \(Positive x0,Positive y0,Positive x1,Positive y1) ->
    counterexample ("union (dot "++show x0++" "++show y0++") (dot "++show x1++" "++show y1++")") $
    let un = union (dot x0 y0) (dot x1 y1)
    in conjoin [checkShape x0 y0 True un
               ,checkShape x1 y1 True un
               ,x0 /= x1 && y0 /= y1 ==> checkShape x1 y0 False un
               ,x0 /= x1 && y0 /= y1 ==> checkShape x0 y1 False un
               ,forAll_ $ \(x,y) -> not (elem x [x0,x1]) && not (elem y [y0,y1]) ==> checkShape x y False un]
  
  ex4_cut = forAll_ $ \(Positive x0,Positive y0) ->
    forAllBlind (choose (2,10)) $ \w ->
    forAllBlind (choose (2,10)) $ \h ->
    forAllBlind (choose (x0,x0+w-1)) $ \x ->
    forAllBlind (choose (y0,y0+h-1)) $ \y ->
    counterexample ("cut (rectangle "++show x0++" "++show y0++" "++show w++" "++show h++") (dot "++show x++" "++show y++")") $
    let c = cut (rectangle x0 y0 w h) (dot x y)
    in conjoin [checkShape x y False c
               ,forAllBlind (choose (x0,x0+w-1) `suchThat` (/=x)) $ \x' ->
                forAllBlind (choose (y0,y0+h-1) `suchThat` (/=y)) $ \y' ->
                checkShape x' y' True c]
  
  ex5_render =
    $(testing' [|renderList (paintSolid white (dot 5 5) (solid black)) (4,6) (5,5)|])
    (?==[["000000","ffffff","000000"]])
  
  ex5_dot = forAll_ $ \(x,y) ->
    forAll_ $ \bg ->
    forAll_ $ \fg ->
    let pict = paintSolid fg (dot x y) (solid bg)
    in counterexample ("paintSolid ("++show fg++") (dot "++show x++" "++show y++") (solid (" ++ show bg ++"))") $
    conjoin [checkPicture x y fg pict
            ,forAll_ $ \(x1,y1) -> x1/=x || y1/=y ==> checkPicture x1 y1 bg pict]
  
  ex6_render =
    conjoin [$(testing' [|renderList (paint (stripes red white) (rectangle 0 0 2 4) (solid black)) (0,4) (1,1)|])
             (?==[["ffffff","ffffff","000000","000000","000000"]])
            ,$(testing' [|renderList (paint (stripes red white) (rectangle 0 0 2 4) (solid black)) (0,4) (0,0)|])
             (?==[["ff0000","ff0000","000000","000000","000000"]])]
  
  ex6_dot = forAll_ $ \(x,y) ->
    forAll_ $ \bg ->
    forAll_ $ \fg ->
    let pict = paint (solid fg) (dot x y) (solid bg)
    in counterexample ("paint (solid ("++show fg++")) (dot "++show x++" "++show y++") (solid (" ++ show bg ++"))") $
    conjoin [checkPicture x y fg pict
            ,forAll_ $ \(x1,y1) -> x1/=x || y1/=y ==> checkPicture x1 y1 bg pict]
  
  ex7_fill = $(testing' [|apply (Fill red) xy|]) $ \pic ->
    forAll_ $ \(x,y) ->
    checkPicture x y red pic
  
  ex7_zoom_xy = $(testing' [|apply (Zoom 3) xy|]) $ \pic ->
    forAllBlind (choose (0,32)) $ \x ->
    forAllBlind (choose (0,32)) $ \y ->
    forAllBlind (choose (0,2)) $ \dx ->
    forAllBlind (choose (0,2)) $ \dy ->
    checkPicture (3*x+dx) (3*y+dy) (Color x y 0) pic
  
  ex7_zoom_dot = forAll_ $ \(x,y) ->
    forAllBlind (choose (1,10)) $ \z ->
    $(testing' [|apply (Zoom z) (fill white (dot x y))|]) $ \pic ->
    counterexample ("with z=" ++ show z ++ ", x=" ++ show x ++ ", y=" ++ show y) $
    conjoin [checkPicture x' y' white pic | x' <- [x*z..(x+1)*z-1], y' <- [y*z..(y+1)*z-1]] -- inside
    .&&. conjoin [checkPicture (x*z-1) y' black pic | y' <- [y*z..(y+1)*z-1]] -- left
    .&&. conjoin [checkPicture ((x+1)*z) y' black pic | y' <- [y*z..(y+1)*z-1]] -- right
    .&&. conjoin [checkPicture x' (y*z-1) black pic | x' <- [x*z..(x+1)*z-1]] -- top
    .&&. conjoin [checkPicture x' ((y+1)*z) black pic | x' <- [x*z..(x+1)*z-1]] -- bottom
  
  ex7_flipx = $(testing' [|apply FlipX xy|]) $ \pic ->
    forAllBlind (choose (0,255)) $ \x ->
    forAllBlind (choose (0,255)) $ \y ->
    checkPicture x y (Color (if x==0 then x else (256-x)) y 0) pic
  
  ex7_flipy = $(testing' [|apply FlipY xy|]) $ \pic ->
    forAllBlind (choose (0,255)) $ \x ->
    forAllBlind (choose (0,255)) $ \y ->
    checkPicture x y (Color x (if y==0 then y else (256-y)) 0) pic
  
  ex7_flipxy = $(testing' [|apply FlipXY xy|]) $ \pic ->
    forAllBlind (choose (0,255)) $ \x ->
    forAllBlind (choose (0,255)) $ \y ->
    checkPicture x y (Color y x 0) pic
  
  ex8_inverse = $(testing' [|apply (Chain FlipX FlipX) xy|]) $ \pic ->
    forAllBlind (choose (0,255)) $ \x ->
    forAllBlind (choose (0,255)) $ \y ->
    checkPicture x y (Color x y 0) pic
  
  ex8_order = $(testing' [|apply (Chain (Fill white) (Fill red)) xy|]) $ \pic ->
    forAll_ $ \(x,y) ->
    checkPicture x y white pic
  
  ex8_zoom =
    forAllBlind (choose (1,4)) $ \z1 ->
    forAllBlind (choose (1,4)) $ \z2 ->
    $(testing [|apply (Chain (Zoom z1) (Zoom z2))|]) $ \app ->
    counterexample "applied to xy" $
    let pic = app xy
        z = z1*z2
    in forAllBlind (choose (0,32)) $ \x ->
      forAllBlind (choose (0,32)) $ \y ->
      forAllBlind (choose (0,z-1)) $ \dx ->
      forAllBlind (choose (0,z-1)) $ \dy ->
      checkPicture (z*x+dx) (z*y+dy) (Color x y 0) pic
  
  ex9_blur_dot = forAll_ $ \(x,y) ->
    forAllBlind (choose (0,50)) $ \c ->
    let blurred = Color c c c
        c1 = c*5
        color = Color c1 c1 c1
    in $(testing' [|apply Blur (fill color (dot x y))|]) $ \pic ->
      counterexample ("with color = " ++ show color ++ ", x = " ++ show x ++ ", y = " ++ show y) $
      conjoin [checkPicture x y blurred pic
              ,checkPicture (x+1) y blurred pic
              ,checkPicture (x-1) y blurred pic
              ,checkPicture x (y+1) blurred pic
              ,checkPicture x (y-1) blurred pic
              ,checkPicture (x-1) (y-1) black pic
              ,checkPicture (x+1) (y+1) black pic
              ,checkPicture (x-1) (y+1) black pic
              ,checkPicture (x+1) (y-1) black pic]
  
  ex9_blur_solid =
    forAll_ $ \color ->
    forAll_ $ \(x,y) ->
    $(testing' [|apply Blur (solid color)|]) $ \pic ->
    counterexample ("with color = "++show color) $
    checkPicture x y color pic
  
  ex10_blur_once = forAll_ $ \(x,y) ->
    forAllBlind (choose (0,50)) $ \c ->
    let blurred = Color c c c
        c1 = c*5
        color = Color c1 c1 c1
    in $(testing' [|apply (BlurMany 1) (fill color (dot x y))|]) $ \pic ->
      counterexample ("with color = " ++ show color ++ ", x = " ++ show x ++ ", y = " ++ show y) $
      conjoin [checkPicture x y blurred pic
              ,checkPicture (x+1) y blurred pic
              ,checkPicture (x-1) y blurred pic
              ,checkPicture x (y+1) blurred pic
              ,checkPicture x (y-1) blurred pic
              ,checkPicture (x-1) (y-1) black pic
              ,checkPicture (x+1) (y+1) black pic
              ,checkPicture (x-1) (y+1) black pic
              ,checkPicture (x+1) (y-1) black pic]
  
  m_blur_many n = forAll_ $ \(x,y) ->
    forAll_ $ \color ->
    let b = BlurMany n
        b' = BlurMany (n-1)
        f = apply b
        g = apply Blur . apply b'
        img = fill color (dot x y)
    in counterexample ("Checking that\n  apply ("++show b++")\ngives the same result as\n  apply Blur . apply ("++show b'++")\non the image") $
       counterexample ("  fill ("++show color++") (dot "++show x++" "++show y++")") $
       forAllBlind (choose (x-n,x+n)) $ \x' ->
       forAllBlind (choose (y-n,y+n)) $ \y' ->
       let (Picture color) = g img
           expected = color (Coord x' y')
       in checkPicture x' y' expected (f img)
  
  ex10_blur_many = withMaxSuccess 5 $ conjoin [m_blur_many n | n <- [2..5]]
  