From 17cecf2cf5e933adb3a8efca79d5e3cfb55a4acb Mon Sep 17 00:00:00 2001
From: Tinazhang <tina.mengting.zhang@huawei.com>
Date: Mon, 11 May 2020 17:52:12 -0400
Subject: [PATCH] Added TCs to RandomCrop and RandomCropAndResize and modified
 visalize() calling

---
 .../golden/random_crop_01_c_result.npz        | Bin 0 -> 644 bytes
 .../golden/random_crop_01_py_result.npz       | Bin 0 -> 644 bytes
 .../golden/random_crop_02_c_result.npz        | Bin 0 -> 644 bytes
 .../golden/random_crop_02_py_result.npz       | Bin 0 -> 644 bytes
 .../golden/random_crop_03_c_result.npz        | Bin 0 -> 644 bytes
 .../golden/random_crop_03_py_result.npz       | Bin 0 -> 644 bytes
 .../golden/random_crop_05_c_result.npz        | Bin 0 -> 644 bytes
 .../golden/random_crop_05_py_result.npz       | Bin 0 -> 644 bytes
 .../golden/random_crop_07_c_result.npz        | Bin 0 -> 644 bytes
 .../golden/random_crop_07_py_result.npz       | Bin 0 -> 644 bytes
 .../golden/random_crop_08_c_result.npz        | Bin 0 -> 644 bytes
 .../golden/random_crop_08_py_result.npz       | Bin 0 -> 644 bytes
 .../random_crop_and_resize_01_c_result.npz    | Bin 0 -> 644 bytes
 .../random_crop_and_resize_01_py_result.npz   | Bin 0 -> 644 bytes
 .../random_crop_and_resize_02_c_result.npz    | Bin 0 -> 644 bytes
 .../random_crop_and_resize_02_py_result.npz   | Bin 0 -> 644 bytes
 .../random_crop_and_resize_03_c_result.npz    | Bin 0 -> 644 bytes
 .../random_crop_and_resize_03_py_result.npz   | Bin 0 -> 644 bytes
 tests/ut/python/dataset/test_HWC2CHW.py       |  21 +-
 tests/ut/python/dataset/test_center_crop.py   |  11 +-
 tests/ut/python/dataset/test_random_crop.py   | 484 +++++++++++++++++-
 .../dataset/test_random_crop_and_resize.py    | 287 +++++++++--
 22 files changed, 728 insertions(+), 75 deletions(-)
 create mode 100644 tests/ut/data/dataset/golden/random_crop_01_c_result.npz
 create mode 100644 tests/ut/data/dataset/golden/random_crop_01_py_result.npz
 create mode 100644 tests/ut/data/dataset/golden/random_crop_02_c_result.npz
 create mode 100644 tests/ut/data/dataset/golden/random_crop_02_py_result.npz
 create mode 100644 tests/ut/data/dataset/golden/random_crop_03_c_result.npz
 create mode 100644 tests/ut/data/dataset/golden/random_crop_03_py_result.npz
 create mode 100644 tests/ut/data/dataset/golden/random_crop_05_c_result.npz
 create mode 100644 tests/ut/data/dataset/golden/random_crop_05_py_result.npz
 create mode 100644 tests/ut/data/dataset/golden/random_crop_07_c_result.npz
 create mode 100644 tests/ut/data/dataset/golden/random_crop_07_py_result.npz
 create mode 100644 tests/ut/data/dataset/golden/random_crop_08_c_result.npz
 create mode 100644 tests/ut/data/dataset/golden/random_crop_08_py_result.npz
 create mode 100644 tests/ut/data/dataset/golden/random_crop_and_resize_01_c_result.npz
 create mode 100644 tests/ut/data/dataset/golden/random_crop_and_resize_01_py_result.npz
 create mode 100644 tests/ut/data/dataset/golden/random_crop_and_resize_02_c_result.npz
 create mode 100644 tests/ut/data/dataset/golden/random_crop_and_resize_02_py_result.npz
 create mode 100644 tests/ut/data/dataset/golden/random_crop_and_resize_03_c_result.npz
 create mode 100644 tests/ut/data/dataset/golden/random_crop_and_resize_03_py_result.npz

diff --git a/tests/ut/data/dataset/golden/random_crop_01_c_result.npz b/tests/ut/data/dataset/golden/random_crop_01_c_result.npz
new file mode 100644
index 0000000000000000000000000000000000000000..32e10a8d72f91fbc5b42eaf0097b4e15a17c28f3
GIT binary patch
literal 644
zcmWIWW@Zs#fB;2?#Jdkm{xC8yfG{V62t#5~QM`d(UO^=zg8*0%q!1(t0+anheFGvH
z8Oj){)l*W7lZ(`?6x3_{)pZoq)AEZ-iW2kU^NUhaLBei{ImM|!@#2icf>a=1!%#=T
zNK;3lR)KuL)xeybSDIT;sh6Bzl&Y6onp2VqbZ=rMSA0=wa(-TMNl|HX30ENlL={(F
z3PiS$(VL;Qkja@bsgSw7kR_;)Rl}PR2$|Xn*`P{ON-7IdxeD1Mn1J5&w<zTBX7FZg
zFXRj=<kIkFjsW?;rjXmu&(G^W5P%79`;tPQq|VqvUX2J=pnPU-VtQ&JUu+@2Mg~I$
z*h+y6pnZZtg+d_vSXv8(GaweEnG}jZED#MU6oXk{Qz(vV0YgclL{g`-fZUfmDG%09
z_kR=6leoNHDxy%bq);jeW{EV&5}BYvS*Rs)8Dc;^`|mU4#_ZxKT(WSw{Eo|y_ZP~S
z6e_^=D1!7T1r;ho^{9aLT->=nq0O83gY7+`EXf}W;|o<w3e}QQQ%efflk@_-8JR?w
gaU~p}|Dm7(oL1n;D8QSQ4J5+|gyuln92CF|0O!@QA^-pY

literal 0
HcmV?d00001

diff --git a/tests/ut/data/dataset/golden/random_crop_01_py_result.npz b/tests/ut/data/dataset/golden/random_crop_01_py_result.npz
new file mode 100644
index 0000000000000000000000000000000000000000..15041f8e52f81daccb8ee1d9228697a912085563
GIT binary patch
literal 644
zcmWIWW@Zs#fB;2?YsHou{xC8yfG{V62t#5~QM`d(UO^=zg8*0%q!1(t0+anheFGvH
z8Oj){)l*W7lZ(`?6x3_{)pZoq)AEZ-iW2kU^NUhaLBei{ImM|!@#2icf>a=1!%#=T
zNK;3lR)KuL)xeybSDIT;sh6Bzl&Y6onp2VqbZ=rMSA0=wa(-TMNl|HX30ENlL={(F
z3PiS$(VL;Qkja@bsgSw7kR_;)Rl}PR2$|Xn*`P{ON-7IdxeD1Mn1J5&w<zTBX7FZg
zFXRj=<kIkFjsW?;rjXmu&(G^W5P%79`;tPQq|VqvUX2J=pnPU-VtQ&JUu+@2Mg~I$
z*h+y6pnZZtg+d_vSXv8(GaweEnG}jZED#MU6oXk{Qz(vV0YgclL{g`-fP0tOya0=c
z&4uSbIMfs{#1u-F6iOw*ERhCTA`?_73$;WpLky@VCN-O@ZR3R~E6<gZ;VarV6v~$r
zD!}z9g7hc_6)HpZsDSkpx!!A2jhdO(P}Tdwf&Yd<p=wE?T2g9iNuhd@UVt|vlL#}e
fgah<H6f}U-3OpGFc(byBWEg?a97vmk0+;~+QR%E;

literal 0
HcmV?d00001

diff --git a/tests/ut/data/dataset/golden/random_crop_02_c_result.npz b/tests/ut/data/dataset/golden/random_crop_02_c_result.npz
new file mode 100644
index 0000000000000000000000000000000000000000..054676d997d309e1b89d9523479aa471a6a8e27a
GIT binary patch
literal 644
zcmWIWW@Zs#fB;2?Uxy@9{xC8yfG{V62t#5~QM`d(UO^=zg8*0%q!1(t0+anheFGvH
z8Oj){)l*W7lZ(`?6x3_{)pZoq)AEZ-iW2kU^NUhaLBei{ImM|!@#2icf>a=1!%#=T
zNK;3lR)KuL)xeybSDIT;sh6Bzl&Y6onp2VqbZ=rMSA0=wa(-TMNl|HX30ENlL={(F
z3PiS$(VL;Qkja@bsgSw7kR_;)Rl}PR2$|Xn*`P{ON-7IdxeD1Mn1J5&w<zTBX7FZg
zFXRj=<kIkFjsW?;rjXmu&(G^W5P%79`;tPQq|VqvUX2J=pnPU-VtQ&JUu+@2Mg~I$
z*h+y6pnZZtg+d_vSXv8(GaweEnG}jZED#MU6oXk{Qz(vV0YgclL{g`-z*UyNN(QH5
zMCU1cWG!?0pHV1TQYe)KvqTzXiA+$TEYuRY3^AY{tr+)Nf&x+!QT<K#r!1&0DwHoN
zRDkPI1nE%<DpZE*Q32~o3DepY!elM_o9{x1)<pN-Le-K&wWQS4l0x+)y#Q}UCJ|;_
f2?ywZC};qu6?ifV@MdKL$uI(;IgmC71uz2ubAGB<

literal 0
HcmV?d00001

diff --git a/tests/ut/data/dataset/golden/random_crop_02_py_result.npz b/tests/ut/data/dataset/golden/random_crop_02_py_result.npz
new file mode 100644
index 0000000000000000000000000000000000000000..14cf210d3ae2866a4fbab4d89d1afcb91b3b8221
GIT binary patch
literal 644
zcmWIWW@Zs#fB;2?7{iLEe;64UK$w$3gdwr0DBeIXub`5VK>#cWQV5a+fysWMz5$Vp
z3}p<}>M5zk$wlf`3hFif>N*PQY57GZMTvRw`9&$IAYr$}oZ?iVcyUHzK`M~1VW^{E
zq^YA&t3W>BYG6*zE6pva)Jx7UO4Z9P%_+$Qx;L?sE50Z-IX|zsq^LBxgsYGNqKYdo
z1tMF>=*`et$mGnJRLI<3$P!e@s^QHDgiLLPY*3{sC6xuKT!rirOh9k?TNHA5Gk7z$
z7jgy_a%p%oM}YiaQ^@V-=jZhw2*8B5eMuotQfF)-uSNtbP(Cv^F+H`AFSd|hBZDCW
zY^6X3&_2PSLLrcSEUksY84wH7ObSIH7KjEFioq<fDHKPwfT5&NBB|3^V4_UbsySEg
zPEL9iGRI}E!uLYSl0vB@m?hF6OJsryWucbHWrzXwFtV45J4n1r2wrut?(xTu9fk5G
zg$i&ziXc5oL50dtJt|;53uN@aTFeqDIJ2zp62rbt?+R5*3e}QQQ%efflk@_-8JR?w
gaU~p}|Dm7(oL1n;D8QSQ4J5+|gyuln92CF|0L;~|c>n+a

literal 0
HcmV?d00001

diff --git a/tests/ut/data/dataset/golden/random_crop_03_c_result.npz b/tests/ut/data/dataset/golden/random_crop_03_c_result.npz
new file mode 100644
index 0000000000000000000000000000000000000000..b3a52243a4d660ff8dfde41256c43e0c479a7e56
GIT binary patch
literal 644
zcmWIWW@Zs#fB;2?J%>!y{xC8yfG{V62t#5~QM`d(UO^=zg8*0%q!1(t0+anheFGvH
z8Oj){)l*W7lZ(`?6x3_{)pZoq)AEZ-iW2kU^NUhaLBei{ImM|!@#2icf>a=1!%#=T
zNK;3lR)KuL)xeybSDIT;sh6Bzl&Y6onp2VqbZ=rMSA0=wa(-TMNl|HX30ENlL={(F
z3PiS$(VL;Qkja@bsgSw7kR_;)Rl}PR2$|Xn*`P{ON-7IdxeD1Mn1J5&w<zTBX7FZg
zFXRj=<kIkFjsW?;rjXmu&(G^W5P%79`;tPQq|VqvUX2J=pnPU-VtQ&JUu+@2Mg~I$
z*h+y6pnZZtg+d_vSXv8(GaweEnG}jZED#MU6oXk{Qz(vV0YgclL{g`-z&CFO?hUH8
ziOjRtvY88UmlsNw6iOw*ERhCTA`?_73$;WpLky^ALiCC5w|(`?atpjA?Y7%2E|f1R
zRDkPI1nE%<DpZE*Q330za{5*CxL&&E?5mrP{`u})Rj680sFswPT2iQ<q!-}L$Rxsy
gE8zhB4+Rb2v;t2?0p6@^AQ?s=GzZe=pa5n70BWwSW&i*H

literal 0
HcmV?d00001

diff --git a/tests/ut/data/dataset/golden/random_crop_03_py_result.npz b/tests/ut/data/dataset/golden/random_crop_03_py_result.npz
new file mode 100644
index 0000000000000000000000000000000000000000..3333dd17841153a4453cb2a8e75dce6e8f10ce56
GIT binary patch
literal 644
zcmWIWW@Zs#fB;1Xmwhc2e;64UK$w$3gdwr0DBeIXub`5VK>#cWQV5a+fysWMz5$Vp
z3}p<}>M5zk$wlf`3hFif>N*PQY57GZMTvRw`9&$IAYr$}oZ?iVcyUHzK`M~1VW^{E
zq^YA&t3W>BYG6*zE6pva)Jx7UO4Z9P%_+$Qx;L?sE50Z-IX|zsq^LBxgsYGNqKYdo
z1tMF>=*`et$mGnJRLI<3$P!e@s^QHDgiLLPY*3{sC6xuKT!rirOh9k?TNHA5Gk7z$
z7jgy_a%p%oM}YiaQ^@V-=jZhw2*8B5eMuotQfF)-uSNtbP(Cv^F+H`AFSd|hBZDCW
zY^6X3&_2PSLLrcSEUksY84wH7ObSIH7KjEFioq<fDHKPwfT5&NBB|3^;8o-4F54&x
z2Styg>><iqV+$oq3Z;@@mPmsvkqIi4g<2w)AqLd5z*SLnMY{8Y6Q4gz$u&5u70Q<s
zD!}z9g7hc_6)HpZsDSmPm+bbAYyY5b<(Yl8rstPup=wE?T2g9iNuhd@UVt|vlL#}e
fgah<H6f}U-3OpGFc(byBWEg?a97vmk0+;~+px&$t

literal 0
HcmV?d00001

diff --git a/tests/ut/data/dataset/golden/random_crop_05_c_result.npz b/tests/ut/data/dataset/golden/random_crop_05_c_result.npz
new file mode 100644
index 0000000000000000000000000000000000000000..a5c914f5b7753c7bff98b59a9ddc423f49ac429a
GIT binary patch
literal 644
zcmWIWW@Zs#fB;2?mz}oWe;64UK$w$3gdwr0DBeIXub`5VK>#cWQV5a+fysWMz5$Vp
z3}p<}>M5zk$wlf`3hFif>N*PQY57GZMTvRw`9&$IAYr$}oZ?iVcyUHzK`M~1VW^{E
zq^YA&t3W>BYG6*zE6pva)Jx7UO4Z9P%_+$Qx;L?sE50Z-IX|zsq^LBxgsYGNqKYdo
z1tMF>=*`et$mGnJRLI<3$P!e@s^QHDgiLLPY*3{sC6xuKT!rirOh9k?TNHA5Gk7z$
z7jgy_a%p%oM}YiaQ^@V-=jZhw2*8B5eMuotQfF)-uSNtbP(Cv^F+H`AFSd|hBZDCW
zY^6X3&_2PSLLrcSEUksY84wH7ObSIH7KjEFioq<fDHKPwfT5&NBB|3^;D`Ci@GUBf
zi``C`_3pH~S63)mQYe)KvqTzXiA+$TEYuRY3^Aadsu0e3w{BeCc;MUK1H0tqw-m~k
z6e_^=D1!7T1r;ho^{9aLs4w=)*!Xjj%yLgr-90TV3kp?B3e}QQQ%efflk@_-8JR?w
gaU~p}|Dm7(oL1n;D8QSQ4J5+|gyuln92CF|04UL~U;qFB

literal 0
HcmV?d00001

diff --git a/tests/ut/data/dataset/golden/random_crop_05_py_result.npz b/tests/ut/data/dataset/golden/random_crop_05_py_result.npz
new file mode 100644
index 0000000000000000000000000000000000000000..35d187ac8a4c59aaef68ee0df1e349b1097f52e0
GIT binary patch
literal 644
zcmWIWW@Zs#fB;2?<3?sxe;64UK$w$3gdwr0DBeIXub`5VK>#cWQV5a+fysWMz5$Vp
z3}p<}>M5zk$wlf`3hFif>N*PQY57GZMTvRw`9&$IAYr$}oZ?iVcyUHzK`M~1VW^{E
zq^YA&t3W>BYG6*zE6pva)Jx7UO4Z9P%_+$Qx;L?sE50Z-IX|zsq^LBxgsYGNqKYdo
z1tMF>=*`et$mGnJRLI<3$P!e@s^QHDgiLLPY*3{sC6xuKT!rirOh9k?TNHA5Gk7z$
z7jgy_a%p%oM}YiaQ^@V-=jZhw2*8B5eMuotQfF)-uSNtbP(Cv^F+H`AFSd|hBZDCW
zY^6X3&_2PSLLrcSEUksY84wH7ObSIH7KjEFioq<fDHKPwfT5&NBB|3^fGu#YZ;!_#
z+tRM<{n@`3xfM#56iOw*ERhCTA`?_73$;WpLky@Va$|?lJ@=QLF_9;ps1<#`RVZIl
zr~uca2-2ezRHzKqqXO2$KKJh4P5kK$|K=$EQk-e3Rj680sFswPT2iQ<q!-}L$Rxsy
gE8zhB4+Rb2v;t2?0p6@^AQ?s=GzZe=pa5n70L9#{EC2ui

literal 0
HcmV?d00001

diff --git a/tests/ut/data/dataset/golden/random_crop_07_c_result.npz b/tests/ut/data/dataset/golden/random_crop_07_c_result.npz
new file mode 100644
index 0000000000000000000000000000000000000000..d4d08cb224c4b93b51cae2998b283f5bb443734b
GIT binary patch
literal 644
zcmWIWW@Zs#fB;2?JFb=8e;64UK$w$3gdwr0DBeIXub`5VK>#cWQV5a+fysWMz5$Vp
z3}p<}>M5zk$wlf`3hFif>N*PQY57GZMTvRw`9&$IAYr$}oZ?iVcyUHzK`M~1VW^{E
zq^YA&t3W>BYG6*zE6pva)Jx7UO4Z9P%_+$Qx;L?sE50Z-IX|zsq^LBxgsYGNqKYdo
z1tMF>=*`et$mGnJRLI<3$P!e@s^QHDgiLLPY*3{sC6xuKT!rirOh9k?TNHA5Gk7z$
z7jgy_a%p%oM}YiaQ^@V-=jZhw2*8B5eMuotQfF)-uSNtbP(Cv^F+H`AFSd|hBZDCW
zY^6X3&_2PSLLrcSEUksY84wH7ObSIH7KjEFioq<fDHKPwfT5&NBB|3^VDYDy8Q(XZ
zN{u@f)Xw>8;)z1Zl0vB@m?hF6OJsryWucbHWrzXw$lb1rxO7%iE#~g&M`=2_`i1f(
zg$i&ziXc5oL50dtJt|;5@v=9U%ZRKEFk9&^xc~Ok6@{uLg=$HusU?N#NqPa^j7%cT
gxDpP~|4`5XPAl+a6yVLu29jX}LUSN(4hmof03gt?KmY&$

literal 0
HcmV?d00001

diff --git a/tests/ut/data/dataset/golden/random_crop_07_py_result.npz b/tests/ut/data/dataset/golden/random_crop_07_py_result.npz
new file mode 100644
index 0000000000000000000000000000000000000000..68339c0aa46c2b362e1bd180bb1a17e6ca088ffa
GIT binary patch
literal 644
zcmWIWW@Zs#fB;1X{-n}Pe;64UK$w$3gdwr0DBeIXub`5VK>#cWQV5a+fysWMz5$Vp
z3}p<}>M5zk$wlf`3hFif>N*PQY57GZMTvRw`9&$IAYr$}oZ?iVcyUHzK`M~1VW^{E
zq^YA&t3W>BYG6*zE6pva)Jx7UO4Z9P%_+$Qx;L?sE50Z-IX|zsq^LBxgsYGNqKYdo
z1tMF>=*`et$mGnJRLI<3$P!e@s^QHDgiLLPY*3{sC6xuKT!rirOh9k?TNHA5Gk7z$
z7jgy_a%p%oM}YiaQ^@V-=jZhw2*8B5eMuotQfF)-uSNtbP(Cv^F+H`AFSd|hBZDCW
zY^6X3&_2PSLLrcSEUksY84wH7ObSIH7KjEFioq<fDHKPwfT5&NBB|3^fHy*5$1h=r
zV^4yob-vqazNb*Kq);jeW{EV&5}BYvS*Rs)8Dc;^Z#>WLx;Ja*zHqadm-1#O`xnZW
z6e_^=D1!7T1r;ho^{9aLtXQoc|BX#*a)0T^cHN%suM1U63e}QQQ%efflk@_-8JR?w
gaU~p}|Dm7(oL1n;D8QSQ4J5+|gyuln92CF|0A%a0vH$=8

literal 0
HcmV?d00001

diff --git a/tests/ut/data/dataset/golden/random_crop_08_c_result.npz b/tests/ut/data/dataset/golden/random_crop_08_c_result.npz
new file mode 100644
index 0000000000000000000000000000000000000000..d4d08cb224c4b93b51cae2998b283f5bb443734b
GIT binary patch
literal 644
zcmWIWW@Zs#fB;2?JFb=8e;64UK$w$3gdwr0DBeIXub`5VK>#cWQV5a+fysWMz5$Vp
z3}p<}>M5zk$wlf`3hFif>N*PQY57GZMTvRw`9&$IAYr$}oZ?iVcyUHzK`M~1VW^{E
zq^YA&t3W>BYG6*zE6pva)Jx7UO4Z9P%_+$Qx;L?sE50Z-IX|zsq^LBxgsYGNqKYdo
z1tMF>=*`et$mGnJRLI<3$P!e@s^QHDgiLLPY*3{sC6xuKT!rirOh9k?TNHA5Gk7z$
z7jgy_a%p%oM}YiaQ^@V-=jZhw2*8B5eMuotQfF)-uSNtbP(Cv^F+H`AFSd|hBZDCW
zY^6X3&_2PSLLrcSEUksY84wH7ObSIH7KjEFioq<fDHKPwfT5&NBB|3^VDYDy8Q(XZ
zN{u@f)Xw>8;)z1Zl0vB@m?hF6OJsryWucbHWrzXw$lb1rxO7%iE#~g&M`=2_`i1f(
zg$i&ziXc5oL50dtJt|;5@v=9U%ZRKEFk9&^xc~Ok6@{uLg=$HusU?N#NqPa^j7%cT
gxDpP~|4`5XPAl+a6yVLu29jX}LUSN(4hmof03gt?KmY&$

literal 0
HcmV?d00001

diff --git a/tests/ut/data/dataset/golden/random_crop_08_py_result.npz b/tests/ut/data/dataset/golden/random_crop_08_py_result.npz
new file mode 100644
index 0000000000000000000000000000000000000000..cc26b0322f806944446ead425aee540c2110844d
GIT binary patch
literal 644
zcmWIWW@Zs#fB;2?lG!bxe;64UK$w$3gdwr0DBeIXub`5VK>#cWQV5a+fysWMz5$Vp
z3}p<}>M5zk$wlf`3hFif>N*PQY57GZMTvRw`9&$IAYr$}oZ?iVcyUHzK`M~1VW^{E
zq^YA&t3W>BYG6*zE6pva)Jx7UO4Z9P%_+$Qx;L?sE50Z-IX|zsq^LBxgsYGNqKYdo
z1tMF>=*`et$mGnJRLI<3$P!e@s^QHDgiLLPY*3{sC6xuKT!rirOh9k?TNHA5Gk7z$
z7jgy_a%p%oM}YiaQ^@V-=jZhw2*8B5eMuotQfF)-uSNtbP(Cv^F+H`AFSd|hBZDCW
zY^6X3&_2PSLLrcSEUksY84wH7ObSIH7KjEFioq<fDHKPwfT5&NBB|3^fHy*5$1h=r
zV^4yob-vqazNb*Kq);jeW{EV&5}BYvS*Rs)8Dc;^7LMjNLK8aqZgzh6opbQ6W}$pZ
zp#ofwB1n%?P@ytZj|y1Niq-1z-`J!k_m_Tb*X`N<x=^*GP%SAnwWLrzNiV>gkx7IZ
gSHc1M9|{`4X$78)0=!w-Kr)O#Xbz;!K>^GF0OK^SA^-pY

literal 0
HcmV?d00001

diff --git a/tests/ut/data/dataset/golden/random_crop_and_resize_01_c_result.npz b/tests/ut/data/dataset/golden/random_crop_and_resize_01_c_result.npz
new file mode 100644
index 0000000000000000000000000000000000000000..9deccf5eec53e39e47a1f6ccee341efb844d25bc
GIT binary patch
literal 644
zcmWIWW@Zs#fB;2?6(86`|1dHzfG{V62t#5~QM`d(UO^=zg8*0%q!1(t0+anheFGvH
z8Oj){)l*W7lZ(`?6x3_{)pZoq)AEZ-iW2kU^NUhaLBei{ImM|!@#2icf>a=1!%#=T
zNK;3lR)KuL)xeybSDIT;sh6Bzl&Y6onp2VqbZ=rMSA0=wa(-TMNl|HX30ENlL={(F
z3PiS$(VL;Qkja@bsgSw7kR_;)Rl}PR2$|Xn*`P{ON-7IdxeD1Mn1J5&w<zTBX7FZg
zFXRj=<kIkFjsW?;rjXmu&(G^W5P%79`;tPQq|VqvUX2J=pnPU-VtQ&JUu+@2Mg~I$
z*h+y6pnZZtg+d_vSXv8(GaweEnG}jZED#MU6oXk{Qz(vV0YgclL{g`-z_iD6&Ga{|
zoHtSP>9lu2x5^47OA4iuV3tUOERhK+l!aO%mmvn!W0sbZzE*9Ohk?wp=hpKDCl<<=
z6e_^=D1!7T1r;ho^{9aLaBkz`Fp>Lpd(VQ|g{L&O$``7Z6sjeqrj`_{C+P)vGct)V
g<4QO{|3g6oIIX~wQGhoq8%Tx`2+e`CIVgY`00`TyV*mgE

literal 0
HcmV?d00001

diff --git a/tests/ut/data/dataset/golden/random_crop_and_resize_01_py_result.npz b/tests/ut/data/dataset/golden/random_crop_and_resize_01_py_result.npz
new file mode 100644
index 0000000000000000000000000000000000000000..67459b2e824bad588b2b0b7c322b95d742c0bba8
GIT binary patch
literal 644
zcmWIWW@Zs#fB;1X|Lb?+{xC8yfG{V62t#5~QM`d(UO^=zg8*0%q!1(t0+anheFGvH
z8Oj){)l*W7lZ(`?6x3_{)pZoq)AEZ-iW2kU^NUhaLBei{ImM|!@#2icf>a=1!%#=T
zNK;3lR)KuL)xeybSDIT;sh6Bzl&Y6onp2VqbZ=rMSA0=wa(-TMNl|HX30ENlL={(F
z3PiS$(VL;Qkja@bsgSw7kR_;)Rl}PR2$|Xn*`P{ON-7IdxeD1Mn1J5&w<zTBX7FZg
zFXRj=<kIkFjsW?;rjXmu&(G^W5P%79`;tPQq|VqvUX2J=pnPU-VtQ&JUu+@2Mg~I$
z*h+y6pnZZtg+d_vSXv8(GaweEnG}jZED#MU6oXk{Qz(vV0YgclL{g`-fNt%CwafHR
zf7*GZLR_`1$-Ypsq);jeW{EV&5}BYvS*Rs)8Dc;^8+l%2D1G`rEmZhQ?>A-D=0f?B
zLIt=UMUWn)ph9J+9u=^j6Z7TmCtsTXCot0Dxhii>NTF&;p;}UEYDuAbl3su}Ba;X-
gu7m^hKNK{8(+WHp1$eWvfn*qg&>Tpcg94ZV0ADAs3;+NC

literal 0
HcmV?d00001

diff --git a/tests/ut/data/dataset/golden/random_crop_and_resize_02_c_result.npz b/tests/ut/data/dataset/golden/random_crop_and_resize_02_c_result.npz
new file mode 100644
index 0000000000000000000000000000000000000000..6f1b0517698d5379f4a92a3d6f101462fa915f71
GIT binary patch
literal 644
zcmWIWW@Zs#fB;1X-A$i`{xC8yfG{V62t#5~QM`d(UO^=zg8*0%q!1(t0+anheFGvH
z8Oj){)l*W7lZ(`?6x3_{)pZoq)AEZ-iW2kU^NUhaLBei{ImM|!@#2icf>a=1!%#=T
zNK;3lR)KuL)xeybSDIT;sh6Bzl&Y6onp2VqbZ=rMSA0=wa(-TMNl|HX30ENlL={(F
z3PiS$(VL;Qkja@bsgSw7kR_;)Rl}PR2$|Xn*`P{ON-7IdxeD1Mn1J5&w<zTBX7FZg
zFXRj=<kIkFjsW?;rjXmu&(G^W5P%79`;tPQq|VqvUX2J=pnPU-VtQ&JUu+@2Mg~I$
z*h+y6pnZZtg+d_vSXv8(GaweEnG}jZED#MU6oXk{Qz(vV0YgclL{g`-fay1BSw6v-
z2eENnmUpyge=d|PDU?crSt1RxL?)<E7HWxHh8R#!mCW;RJBt?be>PIN=TzLnQz&0j
zr~uca2-2ezRHzKqqXO1r<6(bOQo%7v{8?g2yU<VBLe-K&wWQS4l0x+)y#Q}UCJ|;_
f2?ywZC};qu6?ifV@MdKL$uI(;IgmC71uz2u*#@d-

literal 0
HcmV?d00001

diff --git a/tests/ut/data/dataset/golden/random_crop_and_resize_02_py_result.npz b/tests/ut/data/dataset/golden/random_crop_and_resize_02_py_result.npz
new file mode 100644
index 0000000000000000000000000000000000000000..dd30307bc5f4d7f2cededcf0d5ccf0402af10223
GIT binary patch
literal 644
zcmWIWW@Zs#fB;2?1G?^+e;64UK$w$3gdwr0DBeIXub`5VK>#cWQV5a+fysWMz5$Vp
z3}p<}>M5zk$wlf`3hFif>N*PQY57GZMTvRw`9&$IAYr$}oZ?iVcyUHzK`M~1VW^{E
zq^YA&t3W>BYG6*zE6pva)Jx7UO4Z9P%_+$Qx;L?sE50Z-IX|zsq^LBxgsYGNqKYdo
z1tMF>=*`et$mGnJRLI<3$P!e@s^QHDgiLLPY*3{sC6xuKT!rirOh9k?TNHA5Gk7z$
z7jgy_a%p%oM}YiaQ^@V-=jZhw2*8B5eMuotQfF)-uSNtbP(Cv^F+H`AFSd|hBZDCW
zY^6X3&_2PSLLrcSEUksY84wH7ObSIH7KjEFioq<fDHKPwfT5&NBB|3^V4b(I#7*^=
zx}O;x{@9eNyBA896iOw*ERhCTA`?_73$;WpLky^gZ<6c7dxs_1j$OU@!<p;<mO}ZG
zLIt=UMUWn)ph9J+9u=^jdX<7o(b?g1#Lk`IS*e=lRj680sFswPT2iQ<q!-}L$Rxsy
gE8zhB4+Rb2v;t2?0p6@^AQ?s=GzZe=pa5n706j~q%m4rY

literal 0
HcmV?d00001

diff --git a/tests/ut/data/dataset/golden/random_crop_and_resize_03_c_result.npz b/tests/ut/data/dataset/golden/random_crop_and_resize_03_c_result.npz
new file mode 100644
index 0000000000000000000000000000000000000000..90903ec22fb3ad3f2d72ec1819af12a342a57bbf
GIT binary patch
literal 644
zcmWIWW@Zs#fB;2?b8~;#{b6Ka0AWrB5r)K~qId(nyn;$b1_7`jNFhiP1Sb21`UXTY
zGL$h?tEZ$ECl{$(DX7=@tLrGJr{x!w6eZ@x=NF}<f`r`?bBa@e;>8(>1*t&3hM|sv
zk*1D9tpfRgtARN=uQa!yQZG5bC{-`FG^ZpJ=-$LiuK1$V<ovwilA_Y&60Sl9h$^nU
z6o_mgqc=lqA(Jy>QXzADAxlsptA;lt5HhtDvO$%mlvEa^auu>iFaf>kZ&AqM&EU=0
zUdS0#$fe=U90BrwO(D0RpP$!%AOI8I_9cZpNu9BUyc!X#K>5tv#PrlczSu&3jSPki
zu$2NCK>GxP3WY%Sv9uNnXFx1SGbt2-SRfiyC<e2@rcfN!0)~=8iKI?vf#v*vxPGsH
z)%=H3NqWIt=@o^NC52K+FiWICmdFGZ%0exX%Mb(VX`WzWy7%3TnTy=!WN&HHbuW}J
zDO7;#Q3UBx3My2F>QMpfdAIYsji-0)48!8=uQJ;L))%Ul6sjeqrj`_{C+P)vGct)V
g<4QO{|3g6oIIX~wQGhoq8%Tx`2+e`CIVgY`085Cl9{>OV

literal 0
HcmV?d00001

diff --git a/tests/ut/data/dataset/golden/random_crop_and_resize_03_py_result.npz b/tests/ut/data/dataset/golden/random_crop_and_resize_03_py_result.npz
new file mode 100644
index 0000000000000000000000000000000000000000..621460e34ca7ba50d60de400e2d18d8e7ee93ef4
GIT binary patch
literal 644
zcmWIWW@Zs#fB;2?Yc(vAe;64UK$w$3gdwr0DBeIXub`5VK>#cWQV5a+fysWMz5$Vp
z3}p<}>M5zk$wlf`3hFif>N*PQY57GZMTvRw`9&$IAYr$}oZ?iVcyUHzK`M~1VW^{E
zq^YA&t3W>BYG6*zE6pva)Jx7UO4Z9P%_+$Qx;L?sE50Z-IX|zsq^LBxgsYGNqKYdo
z1tMF>=*`et$mGnJRLI<3$P!e@s^QHDgiLLPY*3{sC6xuKT!rirOh9k?TNHA5Gk7z$
z7jgy_a%p%oM}YiaQ^@V-=jZhw2*8B5eMuotQfF)-uSNtbP(Cv^F+H`AFSd|hBZDCW
zY^6X3&_2PSLLrcSEUksY84wH7ObSIH7KjEFioq<fDHKPwfT5&NBB|3^pip}2>UHxb
z-xl2$`~Boglh{JZl0vB@m?hF6OJsryWucbHWrzXw><sakaC>%D^jfL(3%2(|gbU?M
z3Kigb6hV5Ff(n(PdQ`xA#2B<cN~y;6s`a%!YctNhT&P-7sFswPT2iQ<q!-}L$Rxsy
gE8zhB4+Rb2v;t2?0p6@^AQ?s=GzZe=pa5n70Q3B;uK)l5

literal 0
HcmV?d00001

diff --git a/tests/ut/python/dataset/test_HWC2CHW.py b/tests/ut/python/dataset/test_HWC2CHW.py
index b15cedd726..98e9ba72ba 100644
--- a/tests/ut/python/dataset/test_HWC2CHW.py
+++ b/tests/ut/python/dataset/test_HWC2CHW.py
@@ -13,12 +13,11 @@
 # limitations under the License.
 # ==============================================================================
 import numpy as np
-from util import diff_mse, visualize, save_and_check_md5
-
 import mindspore.dataset as ds
 import mindspore.dataset.transforms.vision.c_transforms as c_vision
 import mindspore.dataset.transforms.vision.py_transforms as py_vision
 from mindspore import log as logger
+from util import diff_mse, visualize, save_and_check_md5
 
 GENERATE_GOLDEN = False
 
@@ -46,12 +45,14 @@ def test_HWC2CHW(plot=False):
     image_transposed = []
     image = []
     for item1, item2 in zip(data1.create_dict_iterator(), data2.create_dict_iterator()):
-        image_transposed.append(item1["image"].copy())
-        image.append(item2["image"].copy())
+        transposed_item = item1["image"].copy()
+        original_item = item2["image"].copy()
+        image_transposed.append(transposed_item.transpose(1, 2, 0))
+        image.append(original_item)
 
         # check if the shape of data is transposed correctly
         # transpose the original image from shape (H,W,C) to (C,H,W)
-        mse = diff_mse(item1['image'], item2['image'].transpose(2, 0, 1))
+        mse = diff_mse(transposed_item, original_item.transpose(2, 0, 1))
         assert mse == 0
     if plot:
         visualize(image, image_transposed)
@@ -108,15 +109,13 @@ def test_HWC2CHW_comp(plot=False):
         mse = diff_mse(py_image, c_image)
         # Note: The images aren't exactly the same due to rounding error
         assert mse < 0.001
-
-        image_c_transposed.append(item1["image"].copy())
-        image_py_transposed.append(item2["image"].copy())
-
+        image_c_transposed.append(c_image.transpose(1, 2, 0))
+        image_py_transposed.append(py_image.transpose(1, 2, 0))
     if plot:
         visualize(image_c_transposed, image_py_transposed)
 
 
 if __name__ == '__main__':
-    test_HWC2CHW()
+    test_HWC2CHW(True)
     test_HWC2CHW_md5()
-    test_HWC2CHW_comp()
+    test_HWC2CHW_comp(True)
diff --git a/tests/ut/python/dataset/test_center_crop.py b/tests/ut/python/dataset/test_center_crop.py
index c0731c855d..bbe284edc3 100644
--- a/tests/ut/python/dataset/test_center_crop.py
+++ b/tests/ut/python/dataset/test_center_crop.py
@@ -13,12 +13,11 @@
 # limitations under the License.
 # ==============================================================================
 import numpy as np
-from util import diff_mse, visualize, save_and_check_md5
-
 import mindspore.dataset as ds
 import mindspore.dataset.transforms.vision.c_transforms as vision
 import mindspore.dataset.transforms.vision.py_transforms as py_vision
 from mindspore import log as logger
+from util import diff_mse, visualize, save_and_check_md5
 
 GENERATE_GOLDEN = False
 
@@ -101,8 +100,8 @@ def test_center_crop_comp(height=375, width=375, plot=False):
         py_image = (item2["image"].transpose(1, 2, 0) * 255).astype(np.uint8)
         # Note: The images aren't exactly the same due to rounding error
         assert diff_mse(py_image, c_image) < 0.001
-        image_cropped.append(item1["image"].copy())
-        image.append(item2["image"].copy())
+        image_cropped.append(c_image.copy())
+        image.append(py_image.copy())
     if plot:
         visualize(image, image_cropped)
 
@@ -141,9 +140,9 @@ def test_crop_grayscale(height=375, width=375):
 
 
 if __name__ == "__main__":
-    test_center_crop_op(600, 600)
+    test_center_crop_op(600, 600, True)
     test_center_crop_op(300, 600)
     test_center_crop_op(600, 300)
     test_center_crop_md5()
-    test_center_crop_comp()
+    test_center_crop_comp(True)
     test_crop_grayscale()
diff --git a/tests/ut/python/dataset/test_random_crop.py b/tests/ut/python/dataset/test_random_crop.py
index 9647f31a36..de94986e48 100644
--- a/tests/ut/python/dataset/test_random_crop.py
+++ b/tests/ut/python/dataset/test_random_crop.py
@@ -13,37 +13,24 @@
 # limitations under the License.
 # ==============================================================================
 """
-Testing RandomCropAndResize op in DE
+Testing RandomCrop op in DE
 """
-import matplotlib.pyplot as plt
-
+import numpy as np
+import mindspore.dataset.transforms.vision.c_transforms as c_vision
+import mindspore.dataset.transforms.vision.py_transforms as py_vision
+import mindspore.dataset.transforms.vision.utils as mode
 import mindspore.dataset as ds
-import mindspore.dataset.transforms.vision.c_transforms as vision
 from mindspore import log as logger
+from util import save_and_check_md5, visualize
 
-DATA_DIR = ["../data/dataset/test_tf_file_3_images/train-0000-of-0001.data"]
-SCHEMA_DIR = "../data/dataset/test_tf_file_3_images/datasetSchema.json"
-
-
-def visualize(a, mse, original):
-    """
-    visualizes the image using DE op and Numpy op
-    """
-    plt.subplot(141)
-    plt.imshow(original)
-    plt.title("Original image")
 
-    plt.subplot(142)
-    plt.imshow(a)
-    plt.title("DE random_crop image")
+GENERATE_GOLDEN = False
 
-    plt.subplot(143)
-    plt.imshow(a - original)
-    plt.title("Difference image, mse : {}".format(mse))
-    plt.show()
+DATA_DIR = ["../data/dataset/test_tf_file_3_images/train-0000-of-0001.data"]
+SCHEMA_DIR = "../data/dataset/test_tf_file_3_images/datasetSchema.json"
 
 
-def test_random_crop_op():
+def test_random_crop_op(plot=False):
     """
     Test RandomCrop Op
     """
@@ -51,8 +38,9 @@ def test_random_crop_op():
 
     # First dataset
     data1 = ds.TFRecordDataset(DATA_DIR, SCHEMA_DIR, columns_list=["image"], shuffle=False)
-    random_crop_op = vision.RandomCrop([512, 512], [200, 200, 200, 200])
-    decode_op = vision.Decode()
+    random_crop_op = c_vision.RandomCrop([512, 512], [200, 200, 200, 200])
+    decode_op = c_vision.Decode()
+
     data1 = data1.map(input_columns=["image"], operations=decode_op)
     data1 = data1.map(input_columns=["image"], operations=random_crop_op)
 
@@ -60,10 +48,454 @@ def test_random_crop_op():
     data2 = ds.TFRecordDataset(DATA_DIR, SCHEMA_DIR, columns_list=["image"], shuffle=False)
     data2 = data2.map(input_columns=["image"], operations=decode_op)
 
+    image_cropped = []
+    image = []
     for item1, item2 in zip(data1.create_dict_iterator(), data2.create_dict_iterator()):
         image1 = item1["image"]
         image2 = item2["image"]
+        image_cropped.append(image1)
+        image.append(image2)
+    if plot:
+        visualize(image, image_cropped)
+
+def test_random_crop_01_c():
+    """
+    Test RandomCrop op with c_transforms: size is a single integer, expected to pass
+    """
+    logger.info("test_random_crop_01_c")
+    ds.config.set_seed(0)
+    ds.config.set_num_parallel_workers(1)
+
+    # Generate dataset
+    data = ds.TFRecordDataset(DATA_DIR, SCHEMA_DIR, columns_list=["image"], shuffle=False)
+    # Note: If size is an int, a square crop of size (size, size) is returned.
+    random_crop_op = c_vision.RandomCrop(512)
+    decode_op = c_vision.Decode()
+    data = data.map(input_columns=["image"], operations=decode_op)
+    data = data.map(input_columns=["image"], operations=random_crop_op)
+
+    filename = "random_crop_01_c_result.npz"
+    save_and_check_md5(data, filename, generate_golden=GENERATE_GOLDEN)
+
+def test_random_crop_01_py():
+    """
+    Test RandomCrop op with py_transforms: size is a single integer, expected to pass
+    """
+    logger.info("test_random_crop_01_py")
+    ds.config.set_seed(0)
+    ds.config.set_num_parallel_workers(1)
+
+    # Generate dataset
+    data = ds.TFRecordDataset(DATA_DIR, SCHEMA_DIR, columns_list=["image"], shuffle=False)
+    # Note: If size is an int, a square crop of size (size, size) is returned.
+    transforms = [
+        py_vision.Decode(),
+        py_vision.RandomCrop(512),
+        py_vision.ToTensor()
+    ]
+    transform = py_vision.ComposeOp(transforms)
+    data = data.map(input_columns=["image"], operations=transform())
+
+    filename = "random_crop_01_py_result.npz"
+    save_and_check_md5(data, filename, generate_golden=GENERATE_GOLDEN)
+
+def test_random_crop_02_c():
+    """
+    Test RandomCrop op with c_transforms: size is a list/tuple with length 2, expected to pass
+    """
+    logger.info("test_random_crop_02_c")
+    ds.config.set_seed(0)
+    ds.config.set_num_parallel_workers(1)
+
+    # Generate dataset
+    data = ds.TFRecordDataset(DATA_DIR, SCHEMA_DIR, columns_list=["image"], shuffle=False)
+    # Note: If size is a sequence of length 2, it should be (height, width).
+    random_crop_op = c_vision.RandomCrop([512, 375])
+    decode_op = c_vision.Decode()
+    data = data.map(input_columns=["image"], operations=decode_op)
+    data = data.map(input_columns=["image"], operations=random_crop_op)
+
+    filename = "random_crop_02_c_result.npz"
+    save_and_check_md5(data, filename, generate_golden=GENERATE_GOLDEN)
+
+def test_random_crop_02_py():
+    """
+    Test RandomCrop op with py_transforms: size is a list/tuple with length 2, expected to pass
+    """
+    logger.info("test_random_crop_02_py")
+    ds.config.set_seed(0)
+    ds.config.set_num_parallel_workers(1)
+
+    # Generate dataset
+    data = ds.TFRecordDataset(DATA_DIR, SCHEMA_DIR, columns_list=["image"], shuffle=False)
+    # Note: If size is a sequence of length 2, it should be (height, width).
+    transforms = [
+        py_vision.Decode(),
+        py_vision.RandomCrop([512, 375]),
+        py_vision.ToTensor()
+    ]
+    transform = py_vision.ComposeOp(transforms)
+    data = data.map(input_columns=["image"], operations=transform())
+
+    filename = "random_crop_02_py_result.npz"
+    save_and_check_md5(data, filename, generate_golden=GENERATE_GOLDEN)
+
+def test_random_crop_03_c():
+    """
+    Test RandomCrop op with c_transforms: input image size == crop size, expected to pass
+    """
+    logger.info("test_random_crop_03_c")
+    ds.config.set_seed(0)
+    ds.config.set_num_parallel_workers(1)
+
+    # Generate dataset
+    data = ds.TFRecordDataset(DATA_DIR, SCHEMA_DIR, columns_list=["image"], shuffle=False)
+    # Note: The size of the image is 4032*2268
+    random_crop_op = c_vision.RandomCrop([2268, 4032])
+    decode_op = c_vision.Decode()
+    data = data.map(input_columns=["image"], operations=decode_op)
+    data = data.map(input_columns=["image"], operations=random_crop_op)
+
+    filename = "random_crop_03_c_result.npz"
+    save_and_check_md5(data, filename, generate_golden=GENERATE_GOLDEN)
+
+def test_random_crop_03_py():
+    """
+    Test RandomCrop op with py_transforms: input image size == crop size, expected to pass
+    """
+    logger.info("test_random_crop_03_py")
+    ds.config.set_seed(0)
+    ds.config.set_num_parallel_workers(1)
+
+    # Generate dataset
+    data = ds.TFRecordDataset(DATA_DIR, SCHEMA_DIR, columns_list=["image"], shuffle=False)
+    # Note: The size of the image is 4032*2268
+    transforms = [
+        py_vision.Decode(),
+        py_vision.RandomCrop([2268, 4032]),
+        py_vision.ToTensor()
+    ]
+    transform = py_vision.ComposeOp(transforms)
+    data = data.map(input_columns=["image"], operations=transform())
+
+    filename = "random_crop_03_py_result.npz"
+    save_and_check_md5(data, filename, generate_golden=GENERATE_GOLDEN)
+
+def test_random_crop_04_c():
+    """
+    Test RandomCrop op with c_transforms: input image size < crop size, expected to fail
+    """
+    logger.info("test_random_crop_04_c")
+    ds.config.set_seed(0)
+    ds.config.set_num_parallel_workers(1)
+    try:
+        # Generate dataset
+        data = ds.TFRecordDataset(DATA_DIR, SCHEMA_DIR, columns_list=["image"], shuffle=False)
+        # Note: The size of the image is 4032*2268
+        random_crop_op = c_vision.RandomCrop([2268, 4033])
+        decode_op = c_vision.Decode()
+        data = data.map(input_columns=["image"], operations=decode_op)
+        data = data.map(input_columns=["image"], operations=random_crop_op)
+        image_list = []
+        for item in data.create_dict_iterator():
+            image = item["image"]
+            image_list.append(image.shape)
+    except BaseException as e:
+        logger.info("Got an exception in DE: {}".format(str(e)))
+
+def test_random_crop_04_py():
+    """
+    Test RandomCrop op with py_transforms:
+    input image size < crop size, expected to fail
+    """
+    logger.info("test_random_crop_04_py")
+    ds.config.set_seed(0)
+    ds.config.set_num_parallel_workers(1)
+
+    try:
+        # Generate dataset
+        data = ds.TFRecordDataset(DATA_DIR, SCHEMA_DIR, columns_list=["image"], shuffle=False)
+        # Note: The size of the image is 4032*2268
+        transforms = [
+            py_vision.Decode(),
+            py_vision.RandomCrop([2268, 4033]),
+            py_vision.ToTensor()
+        ]
+        transform = py_vision.ComposeOp(transforms)
+        data = data.map(input_columns=["image"], operations=transform())
+        image_list = []
+        for item in data.create_dict_iterator():
+            image = (item["image"].transpose(1, 2, 0) * 255).astype(np.uint8)
+            image_list.append(image.shape)
+    except BaseException as e:
+        logger.info("Got an exception in DE: {}".format(str(e)))
+
+def test_random_crop_05_c():
+    """
+    Test RandomCrop op with c_transforms:
+    input image size < crop size but pad_if_needed is enabled,
+    expected to pass
+    """
+    logger.info("test_random_crop_05_c")
+    ds.config.set_seed(0)
+    ds.config.set_num_parallel_workers(1)
+
+    # Generate dataset
+    data = ds.TFRecordDataset(DATA_DIR, SCHEMA_DIR, columns_list=["image"], shuffle=False)
+    # Note: The size of the image is 4032*2268
+    random_crop_op = c_vision.RandomCrop([2268, 4033], [200, 200, 200, 200], pad_if_needed=True)
+    decode_op = c_vision.Decode()
+    data = data.map(input_columns=["image"], operations=decode_op)
+    data = data.map(input_columns=["image"], operations=random_crop_op)
 
+    filename = "random_crop_05_c_result.npz"
+    save_and_check_md5(data, filename, generate_golden=GENERATE_GOLDEN)
+
+def test_random_crop_05_py():
+    """
+    Test RandomCrop op with py_transforms:
+    input image size < crop size but pad_if_needed is enabled,
+    expected to pass
+    """
+    logger.info("test_random_crop_05_py")
+    ds.config.set_seed(0)
+    ds.config.set_num_parallel_workers(1)
+
+    # Generate dataset
+    data = ds.TFRecordDataset(DATA_DIR, SCHEMA_DIR, columns_list=["image"], shuffle=False)
+    # Note: The size of the image is 4032*2268
+    transforms = [
+        py_vision.Decode(),
+        py_vision.RandomCrop([2268, 4033], [200, 200, 200, 200], pad_if_needed=True),
+        py_vision.ToTensor()
+    ]
+    transform = py_vision.ComposeOp(transforms)
+    data = data.map(input_columns=["image"], operations=transform())
+
+    filename = "random_crop_05_py_result.npz"
+    save_and_check_md5(data, filename, generate_golden=GENERATE_GOLDEN)
+
+def test_random_crop_06_c():
+    """
+    Test RandomCrop op with c_transforms:
+    invalid size, expected to raise TypeError
+    """
+    logger.info("test_random_crop_06_c")
+    ds.config.set_seed(0)
+    ds.config.set_num_parallel_workers(1)
+
+    try:
+        # Generate dataset
+        data = ds.TFRecordDataset(DATA_DIR, SCHEMA_DIR, columns_list=["image"], shuffle=False)
+        # Note: if size is neither an int nor a list of length 2, an exception will raise
+        random_crop_op = c_vision.RandomCrop([512, 512, 375])
+        decode_op = c_vision.Decode()
+        data = data.map(input_columns=["image"], operations=decode_op)
+        data = data.map(input_columns=["image"], operations=random_crop_op)
+        image_list = []
+        for item in data.create_dict_iterator():
+            image = item["image"]
+            image_list.append(image.shape)
+    except TypeError as e:
+        logger.info("Got an exception in DE: {}".format(str(e)))
+        assert "Size" in str(e)
+
+def test_random_crop_06_py():
+    """
+    Test RandomCrop op with py_transforms:
+    invalid size, expected to raise TypeError
+    """
+    logger.info("test_random_crop_06_py")
+    ds.config.set_seed(0)
+    ds.config.set_num_parallel_workers(1)
+
+    try:
+        # Generate dataset
+        data = ds.TFRecordDataset(DATA_DIR, SCHEMA_DIR, columns_list=["image"], shuffle=False)
+        # Note: if size is neither an int nor a list of length 2, an exception will raise
+        transforms = [
+            py_vision.Decode(),
+            py_vision.RandomCrop([512, 512, 375]),
+            py_vision.ToTensor()
+        ]
+        transform = py_vision.ComposeOp(transforms)
+        data = data.map(input_columns=["image"], operations=transform())
+        image_list = []
+        for item in data.create_dict_iterator():
+            image = (item["image"].transpose(1, 2, 0) * 255).astype(np.uint8)
+            image_list.append(image.shape)
+    except TypeError as e:
+        logger.info("Got an exception in DE: {}".format(str(e)))
+        assert "Size" in str(e)
+
+def test_random_crop_07_c():
+    """
+    Test RandomCrop op with c_transforms:
+    padding_mode is Border.CONSTANT and fill_value is 255 (White),
+    expected to pass
+    """
+    logger.info("test_random_crop_07_c")
+    ds.config.set_seed(0)
+    ds.config.set_num_parallel_workers(1)
+
+    # Generate dataset
+    data = ds.TFRecordDataset(DATA_DIR, SCHEMA_DIR, columns_list=["image"], shuffle=False)
+    # Note: The padding_mode is default as Border.CONSTANT and set filling color to be white.
+    random_crop_op = c_vision.RandomCrop(512, [200, 200, 200, 200], fill_value=(255, 255, 255))
+    decode_op = c_vision.Decode()
+    data = data.map(input_columns=["image"], operations=decode_op)
+    data = data.map(input_columns=["image"], operations=random_crop_op)
+
+    filename = "random_crop_07_c_result.npz"
+    save_and_check_md5(data, filename, generate_golden=GENERATE_GOLDEN)
+
+def test_random_crop_07_py():
+    """
+    Test RandomCrop op with py_transforms:
+    padding_mode is Border.CONSTANT and fill_value is 255 (White),
+    expected to pass
+    """
+    logger.info("test_random_crop_07_py")
+    ds.config.set_seed(0)
+    ds.config.set_num_parallel_workers(1)
+
+    # Generate dataset
+    data = ds.TFRecordDataset(DATA_DIR, SCHEMA_DIR, columns_list=["image"], shuffle=False)
+    # Note: The padding_mode is default as Border.CONSTANT and set filling color to be white.
+    transforms = [
+        py_vision.Decode(),
+        py_vision.RandomCrop(512, [200, 200, 200, 200], fill_value=(255, 255, 255)),
+        py_vision.ToTensor()
+    ]
+    transform = py_vision.ComposeOp(transforms)
+    data = data.map(input_columns=["image"], operations=transform())
+
+    filename = "random_crop_07_py_result.npz"
+    save_and_check_md5(data, filename, generate_golden=GENERATE_GOLDEN)
+
+def test_random_crop_08_c():
+    """
+    Test RandomCrop op with c_transforms: padding_mode is Border.EDGE,
+    expected to pass
+    """
+    logger.info("test_random_crop_08_c")
+    ds.config.set_seed(0)
+    ds.config.set_num_parallel_workers(1)
+
+    # Generate dataset
+    data = ds.TFRecordDataset(DATA_DIR, SCHEMA_DIR, columns_list=["image"], shuffle=False)
+    # Note: The padding_mode is Border.EDGE.
+    random_crop_op = c_vision.RandomCrop(512, [200, 200, 200, 200], padding_mode=mode.Border.EDGE)
+    decode_op = c_vision.Decode()
+    data = data.map(input_columns=["image"], operations=decode_op)
+    data = data.map(input_columns=["image"], operations=random_crop_op)
+
+    filename = "random_crop_08_c_result.npz"
+    save_and_check_md5(data, filename, generate_golden=GENERATE_GOLDEN)
+
+def test_random_crop_08_py():
+    """
+    Test RandomCrop op with py_transforms: padding_mode is Border.EDGE,
+    expected to pass
+    """
+    logger.info("test_random_crop_08_py")
+    ds.config.set_seed(0)
+    ds.config.set_num_parallel_workers(1)
+
+    # Generate dataset
+    data = ds.TFRecordDataset(DATA_DIR, SCHEMA_DIR, columns_list=["image"], shuffle=False)
+    # Note: The padding_mode is Border.EDGE.
+    transforms = [
+        py_vision.Decode(),
+        py_vision.RandomCrop(512, [200, 200, 200, 200], padding_mode=mode.Border.EDGE),
+        py_vision.ToTensor()
+    ]
+    transform = py_vision.ComposeOp(transforms)
+    data = data.map(input_columns=["image"], operations=transform())
+
+    filename = "random_crop_08_py_result.npz"
+    save_and_check_md5(data, filename, generate_golden=GENERATE_GOLDEN)
+
+def test_random_crop_09():
+    """
+    Test RandomCrop op: invalid type of input image (not PIL), expected to raise TypeError
+    """
+    logger.info("test_random_crop_09")
+    ds.config.set_seed(0)
+    ds.config.set_num_parallel_workers(1)
+
+    # Generate dataset
+    data = ds.TFRecordDataset(DATA_DIR, SCHEMA_DIR, columns_list=["image"], shuffle=False)
+    transforms = [
+        py_vision.Decode(),
+        py_vision.ToTensor(),
+        # Note: if input is not PIL image, TypeError will raise
+        py_vision.RandomCrop(512)
+    ]
+    transform = py_vision.ComposeOp(transforms)
+    try:
+        data = data.map(input_columns=["image"], operations=transform())
+        image_list = []
+        for item in data.create_dict_iterator():
+            image = item["image"]
+            image_list.append(image.shape)
+    except BaseException as e:
+        logger.info("Got an exception in DE: {}".format(str(e)))
+        assert "should be PIL Image" in str(e)
+
+def test_random_crop_comp(plot=False):
+    """
+    Test RandomCrop and compare between python and c image augmentation
+    """
+    logger.info("Test RandomCrop with c_transform and py_transform comparison")
+    ds.config.set_seed(0)
+    ds.config.set_num_parallel_workers(1)
+    cropped_size = 512
+
+    # First dataset
+    data1 = ds.TFRecordDataset(DATA_DIR, SCHEMA_DIR, columns_list=["image"], shuffle=False)
+    random_crop_op = c_vision.RandomCrop(cropped_size)
+    decode_op = c_vision.Decode()
+    data1 = data1.map(input_columns=["image"], operations=decode_op)
+    data1 = data1.map(input_columns=["image"], operations=random_crop_op)
+
+    # Second dataset
+    data2 = ds.TFRecordDataset(DATA_DIR, SCHEMA_DIR, columns_list=["image"], shuffle=False)
+    transforms = [
+        py_vision.Decode(),
+        py_vision.RandomCrop(cropped_size),
+        py_vision.ToTensor()
+    ]
+    transform = py_vision.ComposeOp(transforms)
+    data2 = data2.map(input_columns=["image"], operations=transform())
+
+    image_c_cropped = []
+    image_py_cropped = []
+    for item1, item2 in zip(data1.create_dict_iterator(), data2.create_dict_iterator()):
+        c_image = item1["image"]
+        py_image = (item2["image"].transpose(1, 2, 0) * 255).astype(np.uint8)
+        image_c_cropped.append(c_image)
+        image_py_cropped.append(py_image)
+    if plot:
+        visualize(image_c_cropped, image_py_cropped)
 
 if __name__ == "__main__":
-    test_random_crop_op()
+    test_random_crop_01_c()
+    test_random_crop_02_c()
+    test_random_crop_03_c()
+    test_random_crop_04_c()
+    test_random_crop_05_c()
+    test_random_crop_06_c()
+    test_random_crop_07_c()
+    test_random_crop_08_c()
+    test_random_crop_01_py()
+    test_random_crop_02_py()
+    test_random_crop_03_py()
+    test_random_crop_04_py()
+    test_random_crop_05_py()
+    test_random_crop_06_py()
+    test_random_crop_07_py()
+    test_random_crop_08_py()
+    test_random_crop_09()
+    test_random_crop_op(True)
+    test_random_crop_comp(True)
diff --git a/tests/ut/python/dataset/test_random_crop_and_resize.py b/tests/ut/python/dataset/test_random_crop_and_resize.py
index 8138e9e431..ce286ec43b 100644
--- a/tests/ut/python/dataset/test_random_crop_and_resize.py
+++ b/tests/ut/python/dataset/test_random_crop_and_resize.py
@@ -16,36 +16,21 @@
 Testing RandomCropAndResize op in DE
 """
 import cv2
-import matplotlib.pyplot as plt
 import numpy as np
-
+import mindspore.dataset.transforms.vision.c_transforms as c_vision
+import mindspore.dataset.transforms.vision.py_transforms as py_vision
+import mindspore.dataset.transforms.vision.utils as mode
 import mindspore.dataset as ds
-import mindspore.dataset.transforms.vision.c_transforms as vision
 from mindspore import log as logger
+from util import diff_mse, save_and_check_md5, visualize
 
 DATA_DIR = ["../data/dataset/test_tf_file_3_images/train-0000-of-0001.data"]
 SCHEMA_DIR = "../data/dataset/test_tf_file_3_images/datasetSchema.json"
 
+GENERATE_GOLDEN = False
 
-def visualize(a, mse, original):
-    """
-    visualizes the image using DE op and Numpy op
-    """
-    plt.subplot(141)
-    plt.imshow(original)
-    plt.title("Original image")
-
-    plt.subplot(142)
-    plt.imshow(a)
-    plt.title("DE random_crop_and_resize image")
-
-    plt.subplot(143)
-    plt.imshow(a - original)
-    plt.title("Difference image, mse : {}".format(mse))
-    plt.show()
 
-
-def test_random_crop_and_resize_op():
+def test_random_crop_and_resize_op(plot=False):
     """
     Test RandomCropAndResize op
     """
@@ -53,30 +38,268 @@ def test_random_crop_and_resize_op():
 
     # First dataset
     data1 = ds.TFRecordDataset(DATA_DIR, SCHEMA_DIR, columns_list=["image"], shuffle=False)
-    decode_op = vision.Decode()
-    random_crop_and_resize_op = vision.RandomResizedCrop((256, 512), (1, 1), (0.5, 0.5))
+    decode_op = c_vision.Decode()
+    random_crop_and_resize_op = c_vision.RandomResizedCrop((256, 512), (1, 1), (0.5, 0.5))
     data1 = data1.map(input_columns=["image"], operations=decode_op)
     data1 = data1.map(input_columns=["image"], operations=random_crop_and_resize_op)
 
     # Second dataset
     data2 = ds.TFRecordDataset(DATA_DIR, SCHEMA_DIR, columns_list=["image"], shuffle=False)
     data2 = data2.map(input_columns=["image"], operations=decode_op)
-
     num_iter = 0
+    crop_and_resize_images = []
+    original_images = []
     for item1, item2 in zip(data1.create_dict_iterator(), data2.create_dict_iterator()):
-
-        if num_iter > 0:
-            break
         crop_and_resize = item1["image"]
         original = item2["image"]
+        # Note: resize the original image with the same size as the one applied RandomResizedCrop()
         original = cv2.resize(original, (512, 256))
-        diff = crop_and_resize - original
-        mse = np.sum(np.power(diff, 2))
+        mse = diff_mse(crop_and_resize, original)
+        assert mse == 0
         logger.info("random_crop_and_resize_op_{}, mse: {}".format(num_iter + 1, mse))
-        # Uncomment below line if you want to visualize images
-        # visualize(crop_and_resize, mse, original)
         num_iter += 1
+        crop_and_resize_images.append(crop_and_resize)
+        original_images.append(original)
+    if plot:
+        visualize(original_images, crop_and_resize_images)
+
+def test_random_crop_and_resize_01():
+    """
+    Test RandomCropAndResize with md5 check, expected to pass
+    """
+    logger.info("test_random_crop_and_resize_01")
+    ds.config.set_seed(0)
+    ds.config.set_num_parallel_workers(1)
+
+    # First dataset
+    data1 = ds.TFRecordDataset(DATA_DIR, SCHEMA_DIR, columns_list=["image"], shuffle=False)
+    decode_op = c_vision.Decode()
+    random_crop_and_resize_op = c_vision.RandomResizedCrop((256, 512), (0.5, 1), (0.5, 1))
+    data1 = data1.map(input_columns=["image"], operations=decode_op)
+    data1 = data1.map(input_columns=["image"], operations=random_crop_and_resize_op)
+
+    # Second dataset
+    data2 = ds.TFRecordDataset(DATA_DIR, SCHEMA_DIR, columns_list=["image"], shuffle=False)
+    transforms = [
+        py_vision.Decode(),
+        py_vision.RandomResizedCrop((256, 512), (0.5, 1), (0.5, 1)),
+        py_vision.ToTensor()
+    ]
+    transform = py_vision.ComposeOp(transforms)
+    data2 = data2.map(input_columns=["image"], operations=transform())
+
+    filename1 = "random_crop_and_resize_01_c_result.npz"
+    filename2 = "random_crop_and_resize_01_py_result.npz"
+    save_and_check_md5(data1, filename1, generate_golden=GENERATE_GOLDEN)
+    save_and_check_md5(data2, filename2, generate_golden=GENERATE_GOLDEN)
+
+def test_random_crop_and_resize_02():
+    """
+    Test RandomCropAndResize with md5 check:Image interpolation mode is Inter.NEAREST,
+    expected to pass
+    """
+    logger.info("test_random_crop_and_resize_02")
+    ds.config.set_seed(0)
+    ds.config.set_num_parallel_workers(1)
+
+    # First dataset
+    data1 = ds.TFRecordDataset(DATA_DIR, SCHEMA_DIR, columns_list=["image"], shuffle=False)
+    decode_op = c_vision.Decode()
+    random_crop_and_resize_op = c_vision.RandomResizedCrop((256, 512), interpolation=mode.Inter.NEAREST)
+    data1 = data1.map(input_columns=["image"], operations=decode_op)
+    data1 = data1.map(input_columns=["image"], operations=random_crop_and_resize_op)
+
+    # Second dataset
+    data2 = ds.TFRecordDataset(DATA_DIR, SCHEMA_DIR, columns_list=["image"], shuffle=False)
+    transforms = [
+        py_vision.Decode(),
+        py_vision.RandomResizedCrop((256, 512), interpolation=mode.Inter.NEAREST),
+        py_vision.ToTensor()
+    ]
+    transform = py_vision.ComposeOp(transforms)
+    data2 = data2.map(input_columns=["image"], operations=transform())
+
+    filename1 = "random_crop_and_resize_02_c_result.npz"
+    filename2 = "random_crop_and_resize_02_py_result.npz"
+    save_and_check_md5(data1, filename1, generate_golden=GENERATE_GOLDEN)
+    save_and_check_md5(data2, filename2, generate_golden=GENERATE_GOLDEN)
+
+def test_random_crop_and_resize_03():
+    """
+    Test RandomCropAndResize with md5 check: max_attempts is 1, expected to pass
+    """
+    logger.info("test_random_crop_and_resize_03")
+    ds.config.set_seed(0)
+    ds.config.set_num_parallel_workers(1)
+
+    # First dataset
+    data1 = ds.TFRecordDataset(DATA_DIR, SCHEMA_DIR, columns_list=["image"], shuffle=False)
+    decode_op = c_vision.Decode()
+    random_crop_and_resize_op = c_vision.RandomResizedCrop((256, 512), max_attempts=1)
+    data1 = data1.map(input_columns=["image"], operations=decode_op)
+    data1 = data1.map(input_columns=["image"], operations=random_crop_and_resize_op)
+
+    # Second dataset
+    data2 = ds.TFRecordDataset(DATA_DIR, SCHEMA_DIR, columns_list=["image"], shuffle=False)
+    transforms = [
+        py_vision.Decode(),
+        py_vision.RandomResizedCrop((256, 512), max_attempts=1),
+        py_vision.ToTensor()
+    ]
+    transform = py_vision.ComposeOp(transforms)
+    data2 = data2.map(input_columns=["image"], operations=transform())
+
+    filename1 = "random_crop_and_resize_03_c_result.npz"
+    filename2 = "random_crop_and_resize_03_py_result.npz"
+    save_and_check_md5(data1, filename1, generate_golden=GENERATE_GOLDEN)
+    save_and_check_md5(data2, filename2, generate_golden=GENERATE_GOLDEN)
+
+def test_random_crop_and_resize_04_c():
+    """
+    Test RandomCropAndResize with c_tranforms: invalid range of scale (max<min),
+    expected to raise ValueError
+    """
+    logger.info("test_random_crop_and_resize_04_c")
+    ds.config.set_seed(0)
+    ds.config.set_num_parallel_workers(1)
+
+    try:
+        # Generate dataset
+        data = ds.TFRecordDataset(DATA_DIR, SCHEMA_DIR, columns_list=["image"], shuffle=False)
+        decode_op = c_vision.Decode()
+        # If input range of scale is not in the order of (min, max), ValueError will be raised.
+        random_crop_and_resize_op = c_vision.RandomResizedCrop((256, 512), (1, 0.5), (0.5, 0.5))
+        data = data.map(input_columns=["image"], operations=decode_op)
+        data = data.map(input_columns=["image"], operations=random_crop_and_resize_op)
+        image_list = []
+        for item in data.create_dict_iterator():
+            image = item["image"]
+            image_list.append(image.shape)
+    except ValueError as e:
+        logger.info("Got an exception in DE: {}".format(str(e)))
+        assert "Input range is not valid" in str(e)
+
+def test_random_crop_and_resize_04_py():
+    """
+    Test RandomCropAndResize with py_transforms: invalid range of scale (max<min),
+    expected to raise ValueError
+    """
+    logger.info("test_random_crop_and_resize_04_py")
+    ds.config.set_seed(0)
+    ds.config.set_num_parallel_workers(1)
+
+    try:
+        # Generate dataset
+        data = ds.TFRecordDataset(DATA_DIR, SCHEMA_DIR, columns_list=["image"], shuffle=False)
+        transforms = [
+            py_vision.Decode(),
+            # If input range of scale is not in the order of (min, max), ValueError will be raised.
+            py_vision.RandomResizedCrop((256, 512), (1, 0.5), (0.5, 0.5)),
+            py_vision.ToTensor()
+        ]
+        transform = py_vision.ComposeOp(transforms)
+        data = data.map(input_columns=["image"], operations=transform())
+        image_list = []
+        for item in data.create_dict_iterator():
+            image = item["image"]
+            image_list.append(image.shape)
+    except ValueError as e:
+        logger.info("Got an exception in DE: {}".format(str(e)))
+        assert "Input range is not valid" in str(e)
+
+def test_random_crop_and_resize_05_c():
+    """
+    Test RandomCropAndResize with c_transforms: invalid range of ratio (max<min),
+    expected to raise ValueError
+    """
+    logger.info("test_random_crop_and_resize_05_c")
+    ds.config.set_seed(0)
+    ds.config.set_num_parallel_workers(1)
+
+    try:
+        # Generate dataset
+        data = ds.TFRecordDataset(DATA_DIR, SCHEMA_DIR, columns_list=["image"], shuffle=False)
+        decode_op = c_vision.Decode()
+        random_crop_and_resize_op = c_vision.RandomResizedCrop((256, 512), (1, 1), (1, 0.5))
+        # If input range of ratio is not in the order of (min, max), ValueError will be raised.
+        data = data.map(input_columns=["image"], operations=decode_op)
+        data = data.map(input_columns=["image"], operations=random_crop_and_resize_op)
+        image_list = []
+        for item in data.create_dict_iterator():
+            image = item["image"]
+            image_list.append(image.shape)
+    except ValueError as e:
+        logger.info("Got an exception in DE: {}".format(str(e)))
+        assert "Input range is not valid" in str(e)
+
+def test_random_crop_and_resize_05_py():
+    """
+    Test RandomCropAndResize with py_transforms: invalid range of ratio (max<min),
+    expected to raise ValueError
+    """
+    logger.info("test_random_crop_and_resize_05_py")
+    ds.config.set_seed(0)
+    ds.config.set_num_parallel_workers(1)
+
+    try:
+        # Generate dataset
+        data = ds.TFRecordDataset(DATA_DIR, SCHEMA_DIR, columns_list=["image"], shuffle=False)
+        transforms = [
+            py_vision.Decode(),
+            # If input range of ratio is not in the order of (min, max), ValueError will be raised.
+            py_vision.RandomResizedCrop((256, 512), (1, 1), (1, 0.5)),
+            py_vision.ToTensor()
+        ]
+        transform = py_vision.ComposeOp(transforms)
+        data = data.map(input_columns=["image"], operations=transform())
+        image_list = []
+        for item in data.create_dict_iterator():
+            image = item["image"]
+            image_list.append(image.shape)
+    except ValueError as e:
+        logger.info("Got an exception in DE: {}".format(str(e)))
+        assert "Input range is not valid" in str(e)
+
+def test_random_crop_and_resize_comp(plot=False):
+    """
+    Test RandomCropAndResize and compare between python and c image augmentation
+    """
+    logger.info("test_random_crop_and_resize_comp")
 
+    # First dataset
+    data1 = ds.TFRecordDataset(DATA_DIR, SCHEMA_DIR, columns_list=["image"], shuffle=False)
+    decode_op = c_vision.Decode()
+    random_crop_and_resize_op = c_vision.RandomResizedCrop(512, (1, 1), (0.5, 0.5))
+    data1 = data1.map(input_columns=["image"], operations=decode_op)
+    data1 = data1.map(input_columns=["image"], operations=random_crop_and_resize_op)
+
+    # Second dataset
+    data2 = ds.TFRecordDataset(DATA_DIR, SCHEMA_DIR, columns_list=["image"], shuffle=False)
+    transforms = [
+        py_vision.Decode(),
+        py_vision.RandomResizedCrop(512, (1, 1), (0.5, 0.5)),
+        py_vision.ToTensor()
+    ]
+    transform = py_vision.ComposeOp(transforms)
+    data2 = data2.map(input_columns=["image"], operations=transform())
+
+    image_c_cropped = []
+    image_py_cropped = []
+    for item1, item2 in zip(data1.create_dict_iterator(), data2.create_dict_iterator()):
+        c_image = item1["image"]
+        py_image = (item2["image"].transpose(1, 2, 0) * 255).astype(np.uint8)
+        image_c_cropped.append(c_image)
+        image_py_cropped.append(py_image)
+    if plot:
+        visualize(image_c_cropped, image_py_cropped)
 
 if __name__ == "__main__":
-    test_random_crop_and_resize_op()
+    test_random_crop_and_resize_op(True)
+    test_random_crop_and_resize_01()
+    test_random_crop_and_resize_02()
+    test_random_crop_and_resize_03()
+    test_random_crop_and_resize_04_c()
+    test_random_crop_and_resize_04_py()
+    test_random_crop_and_resize_05_c()
+    test_random_crop_and_resize_05_py()
+    test_random_crop_and_resize_comp(True)