diff --git a/intrinsiccv/include/intrinsiccv/intrinsiccv.h b/intrinsiccv/include/intrinsiccv/intrinsiccv.h
index 320d2f7654ea458bbbcc47215cabd6083a622803..c691afc7c516adb99815d7c3c3732f61a1ca8864 100644
--- a/intrinsiccv/include/intrinsiccv/intrinsiccv.h
+++ b/intrinsiccv/include/intrinsiccv/intrinsiccv.h
@@ -1153,8 +1153,8 @@ intrinsiccv_error_t intrinsiccv_merge(const void **srcs,
 ///                     start of the next row in the source data. Must not be
 ///                     less than width * sizeof(type).
 ///                     Must be a multiple of sizeof(type).
-/// @param width        Number of elements in a row.
-/// @param height       Number of rows in the data.
+/// @param width        Number of elements in a row. Must be greater than 0.
+/// @param height       Number of rows in the data. Must be greater than 0.
 /// @param min_value    Pointer to save result minimum value to, or nullptr if
 ///                     minimum is not to be calculated.
 /// @param max_value    Pointer to save result maximum value to, or nullptr if
@@ -1195,8 +1195,8 @@ intrinsiccv_error_t intrinsiccv_min_max_s32(const int32_t *src,
 ///                     start of the next row in the source data. Must not be
 ///                     less than width * sizeof(type).
 ///                     Must be a multiple of sizeof(type).
-/// @param width        Number of elements in a row.
-/// @param height       Number of rows in the data.
+/// @param width        Number of elements in a row. Must be greater than 0.
+/// @param height       Number of rows in the data. Must be greater than 0.
 /// @param min_offset   Pointer to save result offset of minimum value to, or
 ///                     nullptr if minimum is not to be calculated.
 /// @param max_offset   Pointer to save result offset of maximum value to, or
diff --git a/intrinsiccv/include/intrinsiccv/morphology/workspace.h b/intrinsiccv/include/intrinsiccv/morphology/workspace.h
index 0668ce8c76b996ea877df4a198398feccb144c81..022e1ab726f837d9b0dffac0f6d6d1c835b4f2e6 100644
--- a/intrinsiccv/include/intrinsiccv/morphology/workspace.h
+++ b/intrinsiccv/include/intrinsiccv/morphology/workspace.h
@@ -161,6 +161,10 @@ class MorphologyWorkspace final {
     using S = typename O::SourceType;
     using B = typename O::BufferType;
 
+    if (INTRINSICCV_UNLIKELY(rect.width() == 0 || rect.height() == 0)) {
+      return;
+    }
+
     // Wide rows which can hold data with left and right margins.
     auto wide_rows = Rows{reinterpret_cast<S *>(&data_[wide_rows_offset_]),
                           wide_rows_stride_, channels_};
diff --git a/intrinsiccv/include/intrinsiccv/workspace/separable.h b/intrinsiccv/include/intrinsiccv/workspace/separable.h
index c26d082aaf3c36c8e3fc188e0904a5e7f414c0c8..599e1186b58ef598496ac50371deeda91876ed9e 100644
--- a/intrinsiccv/include/intrinsiccv/workspace/separable.h
+++ b/intrinsiccv/include/intrinsiccv/workspace/separable.h
@@ -127,6 +127,10 @@ class SeparableFilterWorkspace final {
                Rows<typename FilterType::DestinationType> dst_rows,
                size_t channels, typename FilterType::BorderType border_type,
                FilterType filter) INTRINSICCV_STREAMING_COMPATIBLE {
+    if (INTRINSICCV_UNLIKELY(rect.width() == 0 || rect.height() == 0)) {
+      return;
+    }
+
     // Border helper which calculates border offsets.
     typename FilterType::BorderInfoType vertical_border{rect.height(),
                                                         border_type};
diff --git a/intrinsiccv/src/analysis/min_max_loc_neon.cpp b/intrinsiccv/src/analysis/min_max_loc_neon.cpp
index 99b355836a9da465c89a2dbdaef2dce05cc4ebb5..ef88a219a2db66bfb31aa0320f47721f34cb5e34 100644
--- a/intrinsiccv/src/analysis/min_max_loc_neon.cpp
+++ b/intrinsiccv/src/analysis/min_max_loc_neon.cpp
@@ -313,6 +313,10 @@ intrinsiccv_error_t min_max_loc(const ScalarType *src, size_t src_stride,
   CHECK_POINTER_AND_STRIDE(src, src_stride);
   CHECK_IMAGE_SIZE(width, height);
 
+  if (INTRINSICCV_UNLIKELY(width == 0 || height == 0)) {
+    return INTRINSICCV_ERROR_RANGE;
+  }
+
   Rectangle rect{width, height};
   Rows<const ScalarType> src_rows{src, src_stride};
   MinMaxLoc<ScalarType> operation;
diff --git a/intrinsiccv/src/analysis/min_max_neon.cpp b/intrinsiccv/src/analysis/min_max_neon.cpp
index 8d9b4583465a38343da4806d77b2bbb956341118..82af0e52369fa8a2e067c0139e08b6fb9c03c963 100644
--- a/intrinsiccv/src/analysis/min_max_neon.cpp
+++ b/intrinsiccv/src/analysis/min_max_neon.cpp
@@ -51,6 +51,10 @@ intrinsiccv_error_t min_max(const ScalarType *src, size_t src_stride,
   CHECK_POINTER_AND_STRIDE(src, src_stride);
   CHECK_IMAGE_SIZE(width, height);
 
+  if (INTRINSICCV_UNLIKELY(width == 0 || height == 0)) {
+    return INTRINSICCV_ERROR_RANGE;
+  }
+
   Rectangle rect{width, height};
   Rows<const ScalarType> src_rows{src, src_stride};
   MinMax<ScalarType> operation;
diff --git a/test/api/test_add_abs_with_threshold.cpp b/test/api/test_add_abs_with_threshold.cpp
index 1246d694893d8d19fff93f564e490fe3c0ec6623..d7d1ea890bb743d9e3a6acc5f2af6a5152ec9f12 100644
--- a/test/api/test_add_abs_with_threshold.cpp
+++ b/test/api/test_add_abs_with_threshold.cpp
@@ -182,7 +182,17 @@ TYPED_TEST(SaturatingAddAbsWithThresholdTest, Misalignment) {
                 sizeof(TypeParam) + 1, 1, 1, 1));
 }
 
-TYPED_TEST(SaturatingAddAbsWithThresholdTest, ImageSize) {
+TYPED_TEST(SaturatingAddAbsWithThresholdTest, ZeroImageSize) {
+  TypeParam src[1] = {}, dst[1];
+  EXPECT_EQ(INTRINSICCV_OK, intrinsiccv_saturating_add_abs_with_threshold_s16(
+                                src, sizeof(TypeParam), src, sizeof(TypeParam),
+                                dst, sizeof(TypeParam), 0, 1, 1));
+  EXPECT_EQ(INTRINSICCV_OK, intrinsiccv_saturating_add_abs_with_threshold_s16(
+                                src, sizeof(TypeParam), src, sizeof(TypeParam),
+                                dst, sizeof(TypeParam), 1, 0, 1));
+}
+
+TYPED_TEST(SaturatingAddAbsWithThresholdTest, OversizeImage) {
   TypeParam src[1] = {}, dst[1];
   EXPECT_EQ(INTRINSICCV_ERROR_RANGE,
             intrinsiccv_saturating_add_abs_with_threshold_s16(
diff --git a/test/api/test_canny.cpp b/test/api/test_canny.cpp
index 36f45577e0224d7ab3e386731118552f33e76a2f..4be2534d6a61282c510c2b30af4703dd445b42dc 100644
--- a/test/api/test_canny.cpp
+++ b/test/api/test_canny.cpp
@@ -41,7 +41,17 @@ TYPED_TEST(CannyTest, Misalignment) {
                                sizeof(TypeParam) + 1, 1, 1, 0.0, 1.0));
 }
 
-TYPED_TEST(CannyTest, ImageSize) {
+TYPED_TEST(CannyTest, ZeroImageSize) {
+  TypeParam src[1] = {}, dst[1];
+  EXPECT_EQ(INTRINSICCV_OK,
+            canny<TypeParam>()(src, sizeof(TypeParam), dst, sizeof(TypeParam),
+                               0, 1, 0.0, 1.0));
+  EXPECT_EQ(INTRINSICCV_OK,
+            canny<TypeParam>()(src, sizeof(TypeParam), dst, sizeof(TypeParam),
+                               1, 0, 0.0, 1.0));
+}
+
+TYPED_TEST(CannyTest, OversizeImage) {
   TypeParam src[1], dst[1];
   EXPECT_EQ(INTRINSICCV_ERROR_RANGE,
             canny<TypeParam>()(src, sizeof(TypeParam), dst, sizeof(TypeParam),
diff --git a/test/api/test_count_nonzeros.cpp b/test/api/test_count_nonzeros.cpp
index f8063cc9fcbdf10f200d87a82265fd3fe5eb8964..80abe474a6f2644fd59e8337e3e3261c3cb6af22 100644
--- a/test/api/test_count_nonzeros.cpp
+++ b/test/api/test_count_nonzeros.cpp
@@ -131,7 +131,17 @@ TYPED_TEST(CountNonZeros, Misalignment) {
       count_nonzeros<TypeParam>()(src, sizeof(TypeParam) + 1, 1, 1, &count));
 }
 
-TYPED_TEST(CountNonZeros, ImageSize) {
+TYPED_TEST(CountNonZeros, ZeroImageSize) {
+  TypeParam src[1] = {};
+  size_t count = 123;
+  EXPECT_EQ(INTRINSICCV_OK,
+            count_nonzeros<TypeParam>()(src, sizeof(TypeParam), 0, 1, &count));
+  EXPECT_EQ(INTRINSICCV_OK,
+            count_nonzeros<TypeParam>()(src, sizeof(TypeParam), 1, 0, &count));
+  EXPECT_EQ(0, count);
+}
+
+TYPED_TEST(CountNonZeros, OversizeImage) {
   TypeParam src[1] = {};
   size_t count = 0;
   EXPECT_EQ(
diff --git a/test/api/test_gaussian_blur.cpp b/test/api/test_gaussian_blur.cpp
index 51f29b428dfddf684a9c74b57888c9c9e0a2f17e..f0ed05f3b7bdcdc049f40fb6af9f870b19d45fab 100644
--- a/test/api/test_gaussian_blur.cpp
+++ b/test/api/test_gaussian_blur.cpp
@@ -257,7 +257,29 @@ TYPED_TEST(GaussianBlur, Misalignment) {
   EXPECT_EQ(INTRINSICCV_OK, intrinsiccv_filter_release(context));
 }
 
-TYPED_TEST(GaussianBlur, ImageSize) {
+TYPED_TEST(GaussianBlur, ZeroImageSize) {
+  TypeParam src[1] = {}, dst[1];
+  intrinsiccv_filter_context_t *context = nullptr;
+  ASSERT_EQ(INTRINSICCV_OK,
+            intrinsiccv_filter_create(&context, 1, 2 * sizeof(TypeParam),
+                                      intrinsiccv_rectangle_t{0, 1}));
+  EXPECT_EQ(INTRINSICCV_OK,
+            gaussian_blur_3x3<TypeParam>()(
+                src, sizeof(TypeParam), dst, sizeof(TypeParam), 0, 1, 1,
+                INTRINSICCV_BORDER_TYPE_REFLECT, context));
+  EXPECT_EQ(INTRINSICCV_OK, intrinsiccv_filter_release(context));
+
+  ASSERT_EQ(INTRINSICCV_OK,
+            intrinsiccv_filter_create(&context, 1, 2 * sizeof(TypeParam),
+                                      intrinsiccv_rectangle_t{1, 0}));
+  EXPECT_EQ(INTRINSICCV_OK,
+            gaussian_blur_3x3<TypeParam>()(
+                src, sizeof(TypeParam), dst, sizeof(TypeParam), 1, 0, 1,
+                INTRINSICCV_BORDER_TYPE_REFLECT, context));
+  EXPECT_EQ(INTRINSICCV_OK, intrinsiccv_filter_release(context));
+}
+
+TYPED_TEST(GaussianBlur, OversizeImage) {
   intrinsiccv_filter_context_t *context = nullptr;
   ASSERT_EQ(INTRINSICCV_OK,
             intrinsiccv_filter_create(&context, 1, 2 * sizeof(TypeParam),
@@ -356,7 +378,7 @@ TYPED_TEST(GaussianBlur, InvalidContextImageSize) {
   EXPECT_EQ(INTRINSICCV_OK, intrinsiccv_filter_release(context));
 }
 
-TEST(FilterCreate, TooBigImage) {
+TEST(FilterCreate, CannotAllocateFilter) {
   MockMallocToFail::enable();
   intrinsiccv_filter_context_t *context = nullptr;
   intrinsiccv_rectangle_t rect{INTRINSICCV_MAX_IMAGE_PIXELS, 1};
@@ -365,7 +387,7 @@ TEST(FilterCreate, TooBigImage) {
   MockMallocToFail::disable();
 }
 
-TEST(FilterCreate, ImageSize) {
+TEST(FilterCreate, OversizeImage) {
   intrinsiccv_filter_context_t *context = nullptr;
 
   for (intrinsiccv_rectangle_t rect : {
diff --git a/test/api/test_merge.cpp b/test/api/test_merge.cpp
index 61d8be67d5107a6fb616eb99b8fb8a1bb28c81de..6259929e500fd24609721a0ddaf9f4dc40711cb8 100644
--- a/test/api/test_merge.cpp
+++ b/test/api/test_merge.cpp
@@ -224,7 +224,22 @@ TYPED_TEST(Merge, Misalignment) {
   }
 }
 
-TYPED_TEST(Merge, ImageSize) {
+TYPED_TEST(Merge, ZeroImageSize) {
+  const size_t kChannels = 2;
+  TypeParam src1[1] = {}, src2[1] = {}, dst[1];
+  const void* srcs[kChannels] = {src1, src2};
+  size_t src_strides[kChannels] = {sizeof(TypeParam), sizeof(TypeParam)};
+  const size_t dst_stride = kChannels * sizeof(TypeParam);
+
+  EXPECT_EQ(INTRINSICCV_OK,
+            intrinsiccv_merge(srcs, src_strides, dst, dst_stride, 0, 1,
+                              kChannels, sizeof(TypeParam)));
+  EXPECT_EQ(INTRINSICCV_OK,
+            intrinsiccv_merge(srcs, src_strides, dst, dst_stride, 1, 0,
+                              kChannels, sizeof(TypeParam)));
+}
+
+TYPED_TEST(Merge, OversizeImage) {
   const size_t kChannels = 2;
   TypeParam src1[1], src2[1], dst[1];
   const void* srcs[kChannels] = {src1, src2};
diff --git a/test/api/test_min_max.cpp b/test/api/test_min_max.cpp
index 91a7542d06ed748ea6a35e5b4e21b11f4174480c..999c448c65e84cfb19134de46388422de2b2d91e 100644
--- a/test/api/test_min_max.cpp
+++ b/test/api/test_min_max.cpp
@@ -311,7 +311,17 @@ TYPED_TEST(MinMax, Misalignment) {
                                  &max_value));
 }
 
-TYPED_TEST(MinMax, ImageSize) {
+TYPED_TEST(MinMax, ZeroImageSize) {
+  TypeParam src[1] = {}, min_value, max_value;
+  EXPECT_EQ(INTRINSICCV_ERROR_RANGE,
+            min_max<TypeParam>()(src, sizeof(TypeParam), 0, 1, &min_value,
+                                 &max_value));
+  EXPECT_EQ(INTRINSICCV_ERROR_RANGE,
+            min_max<TypeParam>()(src, sizeof(TypeParam), 1, 0, &min_value,
+                                 &max_value));
+}
+
+TYPED_TEST(MinMax, OversizeImage) {
   TypeParam src[1] = {}, min_value, max_value;
   EXPECT_EQ(INTRINSICCV_ERROR_RANGE,
             min_max<TypeParam>()(src, sizeof(TypeParam),
@@ -334,7 +344,19 @@ TYPED_TEST(MinMaxLoc, API) {
   MinMaxLocTest<TypeParam, 100>{}.test();
 }
 
-TYPED_TEST(MinMaxLoc, ImageSize) {
+TYPED_TEST(MinMaxLoc, ZeroImageSize) {
+  TypeParam src[1] = {};
+  size_t min_offset = 0, max_offset = 0;
+
+  EXPECT_EQ(INTRINSICCV_ERROR_RANGE,
+            min_max_loc<TypeParam>()(src, sizeof(TypeParam), 0, 1, &min_offset,
+                                     &max_offset));
+  EXPECT_EQ(INTRINSICCV_ERROR_RANGE,
+            min_max_loc<TypeParam>()(src, sizeof(TypeParam), 1, 0, &min_offset,
+                                     &max_offset));
+}
+
+TYPED_TEST(MinMaxLoc, OversizeImage) {
   TypeParam src[1] = {};
   size_t min_offset = 0, max_offset = 8;
 
diff --git a/test/api/test_morphology.cpp b/test/api/test_morphology.cpp
index 0d189337d8bdefb55c848646544bffbf8e8ad984..ee49801e1791096093f5e00db74b7d9de430d888 100644
--- a/test/api/test_morphology.cpp
+++ b/test/api/test_morphology.cpp
@@ -507,7 +507,33 @@ TYPED_TEST(Morphology, ErodeMisalignment) {
   EXPECT_EQ(INTRINSICCV_OK, intrinsiccv_morphology_release(context));
 }
 
-TYPED_TEST(Morphology, DilateImageSize) {
+TYPED_TEST(Morphology, DilateZeroImageSize) {
+  intrinsiccv_morphology_context_t *context = nullptr;
+  TypeParam src[1], dst[1];
+  ASSERT_EQ(INTRINSICCV_OK,
+            intrinsiccv_morphology_create(
+                &context, intrinsiccv_rectangle_t{1, 1},
+                intrinsiccv_point_t{0, 0}, INTRINSICCV_BORDER_TYPE_REPLICATE,
+                intrinsiccv_border_values_t{0, 0, 1, 1}, 1, 1,
+                sizeof(TypeParam), intrinsiccv_rectangle_t{0, 1}));
+  EXPECT_EQ(INTRINSICCV_OK,
+            DilateParams<TypeParam>::api()(src, sizeof(TypeParam), dst,
+                                           sizeof(TypeParam), 0, 1, context));
+  EXPECT_EQ(INTRINSICCV_OK, intrinsiccv_morphology_release(context));
+
+  ASSERT_EQ(INTRINSICCV_OK,
+            intrinsiccv_morphology_create(
+                &context, intrinsiccv_rectangle_t{1, 1},
+                intrinsiccv_point_t{0, 0}, INTRINSICCV_BORDER_TYPE_REPLICATE,
+                intrinsiccv_border_values_t{0, 0, 1, 1}, 1, 1,
+                sizeof(TypeParam), intrinsiccv_rectangle_t{1, 0}));
+  EXPECT_EQ(INTRINSICCV_OK,
+            DilateParams<TypeParam>::api()(src, sizeof(TypeParam), dst,
+                                           sizeof(TypeParam), 1, 0, context));
+  EXPECT_EQ(INTRINSICCV_OK, intrinsiccv_morphology_release(context));
+}
+
+TYPED_TEST(Morphology, DilateOversizeImage) {
   intrinsiccv_morphology_context_t *context = nullptr;
   ASSERT_EQ(INTRINSICCV_OK, make_minimal_context(&context, sizeof(TypeParam)));
   TypeParam src[1], dst[1];
@@ -523,7 +549,33 @@ TYPED_TEST(Morphology, DilateImageSize) {
   EXPECT_EQ(INTRINSICCV_OK, intrinsiccv_morphology_release(context));
 }
 
-TYPED_TEST(Morphology, ErodeImageSize) {
+TYPED_TEST(Morphology, ErodeZeroImageSize) {
+  intrinsiccv_morphology_context_t *context = nullptr;
+  TypeParam src[1], dst[1];
+  ASSERT_EQ(INTRINSICCV_OK,
+            intrinsiccv_morphology_create(
+                &context, intrinsiccv_rectangle_t{1, 1},
+                intrinsiccv_point_t{0, 0}, INTRINSICCV_BORDER_TYPE_REPLICATE,
+                intrinsiccv_border_values_t{0, 0, 1, 1}, 1, 1,
+                sizeof(TypeParam), intrinsiccv_rectangle_t{0, 1}));
+  EXPECT_EQ(INTRINSICCV_OK,
+            ErodeParams<TypeParam>::api()(src, sizeof(TypeParam), dst,
+                                          sizeof(TypeParam), 0, 1, context));
+  EXPECT_EQ(INTRINSICCV_OK, intrinsiccv_morphology_release(context));
+
+  ASSERT_EQ(INTRINSICCV_OK,
+            intrinsiccv_morphology_create(
+                &context, intrinsiccv_rectangle_t{1, 1},
+                intrinsiccv_point_t{0, 0}, INTRINSICCV_BORDER_TYPE_REPLICATE,
+                intrinsiccv_border_values_t{0, 0, 1, 1}, 1, 1,
+                sizeof(TypeParam), intrinsiccv_rectangle_t{1, 0}));
+  EXPECT_EQ(INTRINSICCV_OK,
+            ErodeParams<TypeParam>::api()(src, sizeof(TypeParam), dst,
+                                          sizeof(TypeParam), 1, 0, context));
+  EXPECT_EQ(INTRINSICCV_OK, intrinsiccv_morphology_release(context));
+}
+
+TYPED_TEST(Morphology, ErodeOversizeImage) {
   intrinsiccv_morphology_context_t *context = nullptr;
   ASSERT_EQ(INTRINSICCV_OK, make_minimal_context(&context, sizeof(TypeParam)));
   TypeParam src[1], dst[1];
diff --git a/test/api/test_resize_to_quarter.cpp b/test/api/test_resize_to_quarter.cpp
index a9e7030483582be9514676cea937510300318ee9..7df0e8e88c3c949fc009a64408fea4a7cf3d492f 100644
--- a/test/api/test_resize_to_quarter.cpp
+++ b/test/api/test_resize_to_quarter.cpp
@@ -219,7 +219,17 @@ TEST(ResizeToQuarter, NullPointer) {
                        1, 1);
 }
 
-TEST(ResizeToQuarter, ImageSize) {
+TEST(ResizeToQuarter, ZeroImageSize) {
+  const uint8_t src[1] = {};
+  uint8_t dst[1];
+
+  EXPECT_EQ(INTRINSICCV_OK,
+            intrinsiccv_resize_to_quarter_u8(src, 1, 0, 1, dst, 1, 0, 1));
+  EXPECT_EQ(INTRINSICCV_OK,
+            intrinsiccv_resize_to_quarter_u8(src, 1, 1, 0, dst, 1, 1, 0));
+}
+
+TEST(ResizeToQuarter, InvalidImageSize) {
   const uint8_t src[1] = {};
   uint8_t dst[1];
 
diff --git a/test/api/test_rgb_and_gray.cpp b/test/api/test_rgb_and_gray.cpp
index 24ee251f9bb863da018554544f576e2b6d5d9ef9..5528589c7d55b12f939a77d329d755fa6ddcecca 100644
--- a/test/api/test_rgb_and_gray.cpp
+++ b/test/api/test_rgb_and_gray.cpp
@@ -100,6 +100,11 @@ class ColourTest final {
     test::test_null_args(impl, source.data(), source.stride(), actual.data(),
                          actual.stride(), logical_width, actual.height());
 
+    EXPECT_EQ(INTRINSICCV_OK, impl(source.data(), source.stride(),
+                                   actual.data(), actual.stride(), 0, 1));
+    EXPECT_EQ(INTRINSICCV_OK, impl(source.data(), source.stride(),
+                                   actual.data(), actual.stride(), 1, 0));
+
     EXPECT_EQ(INTRINSICCV_ERROR_RANGE,
               impl(source.data(), source.stride(), actual.data(),
                    actual.stride(), INTRINSICCV_MAX_IMAGE_PIXELS + 1, 1));
diff --git a/test/api/test_saturating_absdiff.cpp b/test/api/test_saturating_absdiff.cpp
index fa27a7670f3d5a9031843f0cf42016a138cdf91f..0fe9daad4364dd07c548b86907f122862c22aa28 100644
--- a/test/api/test_saturating_absdiff.cpp
+++ b/test/api/test_saturating_absdiff.cpp
@@ -123,7 +123,17 @@ TYPED_TEST(SaturatingAbsDiff, Misalignment) {
                                             sizeof(TypeParam) + 1, 1, 1));
 }
 
-TYPED_TEST(SaturatingAbsDiff, ImageSize) {
+TYPED_TEST(SaturatingAbsDiff, ZeroImageSize) {
+  TypeParam src[1] = {}, dst[1];
+  EXPECT_EQ(INTRINSICCV_OK, saturating_absdiff<TypeParam>()(
+                                src, sizeof(TypeParam), src, sizeof(TypeParam),
+                                dst, sizeof(TypeParam), 0, 1));
+  EXPECT_EQ(INTRINSICCV_OK, saturating_absdiff<TypeParam>()(
+                                src, sizeof(TypeParam), src, sizeof(TypeParam),
+                                dst, sizeof(TypeParam), 1, 0));
+}
+
+TYPED_TEST(SaturatingAbsDiff, OversizeImage) {
   TypeParam src[1] = {}, dst[1];
   EXPECT_EQ(INTRINSICCV_ERROR_RANGE,
             saturating_absdiff<TypeParam>()(
diff --git a/test/api/test_saturating_add.cpp b/test/api/test_saturating_add.cpp
index 2964f7d101a413e48135077f63a329344e4b5e9f..224d56c51a79181fa7be49c1fcef770c2d415ff7 100644
--- a/test/api/test_saturating_add.cpp
+++ b/test/api/test_saturating_add.cpp
@@ -115,7 +115,17 @@ TYPED_TEST(SaturatingAdd, Misalignment) {
                                         sizeof(TypeParam) + 1, 1, 1));
 }
 
-TYPED_TEST(SaturatingAdd, ImageSize) {
+TYPED_TEST(SaturatingAdd, ZeroImageSize) {
+  TypeParam src[1] = {}, dst[1];
+  EXPECT_EQ(INTRINSICCV_OK, saturating_add<TypeParam>()(
+                                src, sizeof(TypeParam), src, sizeof(TypeParam),
+                                dst, sizeof(TypeParam), 0, 1));
+  EXPECT_EQ(INTRINSICCV_OK, saturating_add<TypeParam>()(
+                                src, sizeof(TypeParam), src, sizeof(TypeParam),
+                                dst, sizeof(TypeParam), 1, 0));
+}
+
+TYPED_TEST(SaturatingAdd, OversizeImage) {
   TypeParam src[1] = {}, dst[1];
   EXPECT_EQ(INTRINSICCV_ERROR_RANGE,
             saturating_add<TypeParam>()(
diff --git a/test/api/test_saturating_multiply.cpp b/test/api/test_saturating_multiply.cpp
index 8112f373ba532cd5aa72fa19bbc337754945d975..321dcc1ed5fa9f961980975fe12a1eff6125db1c 100644
--- a/test/api/test_saturating_multiply.cpp
+++ b/test/api/test_saturating_multiply.cpp
@@ -123,7 +123,17 @@ TYPED_TEST(SaturatingMultiply, Misalignment) {
                                              sizeof(TypeParam) + 1, 1, 1, 1));
 }
 
-TYPED_TEST(SaturatingMultiply, ImageSize) {
+TYPED_TEST(SaturatingMultiply, ZeroImageSize) {
+  TypeParam src[1] = {}, dst[1];
+  EXPECT_EQ(INTRINSICCV_OK, saturating_multiply<TypeParam>()(
+                                src, sizeof(TypeParam), src, sizeof(TypeParam),
+                                dst, sizeof(TypeParam), 0, 1, 1));
+  EXPECT_EQ(INTRINSICCV_OK, saturating_multiply<TypeParam>()(
+                                src, sizeof(TypeParam), src, sizeof(TypeParam),
+                                dst, sizeof(TypeParam), 1, 0, 1));
+}
+
+TYPED_TEST(SaturatingMultiply, OversizeImage) {
   TypeParam src[1] = {}, dst[1];
   EXPECT_EQ(INTRINSICCV_ERROR_RANGE,
             saturating_multiply<TypeParam>()(
diff --git a/test/api/test_saturating_sub.cpp b/test/api/test_saturating_sub.cpp
index 71737b99d3d643499763651462a0876f08d50db1..0c1fb80a6d8ed0b8cc787b97936c932a0fcff0f6 100644
--- a/test/api/test_saturating_sub.cpp
+++ b/test/api/test_saturating_sub.cpp
@@ -117,7 +117,17 @@ TYPED_TEST(SaturatingSub, Misalignment) {
                                         sizeof(TypeParam) + 1, 1, 1));
 }
 
-TYPED_TEST(SaturatingSub, ImageSize) {
+TYPED_TEST(SaturatingSub, ZeroImageSize) {
+  TypeParam src[1] = {}, dst[1];
+  EXPECT_EQ(INTRINSICCV_OK, saturating_sub<TypeParam>()(
+                                src, sizeof(TypeParam), src, sizeof(TypeParam),
+                                dst, sizeof(TypeParam), 0, 1));
+  EXPECT_EQ(INTRINSICCV_OK, saturating_sub<TypeParam>()(
+                                src, sizeof(TypeParam), src, sizeof(TypeParam),
+                                dst, sizeof(TypeParam), 1, 0));
+}
+
+TYPED_TEST(SaturatingSub, OversizeImage) {
   TypeParam src[1] = {}, dst[1];
   EXPECT_EQ(INTRINSICCV_ERROR_RANGE,
             saturating_sub<TypeParam>()(
diff --git a/test/api/test_scale.cpp b/test/api/test_scale.cpp
index b1c0bef687a637fbb39aa1bbd52c67c25b790e29..df177a1faf6c0791fb4df16e99c36571f0681889 100644
--- a/test/api/test_scale.cpp
+++ b/test/api/test_scale.cpp
@@ -412,7 +412,15 @@ TYPED_TEST(ScaleTest, Misalignment) {
                                sizeof(TypeParam) + 1, 1, 1, 2, 0));
 }
 
-TYPED_TEST(ScaleTest, ImageSize) {
+TYPED_TEST(ScaleTest, ZeroImageSize) {
+  TypeParam src[1] = {}, dst[1];
+  EXPECT_EQ(INTRINSICCV_OK, scale<TypeParam>()(src, sizeof(TypeParam), dst,
+                                               sizeof(TypeParam), 0, 1, 2, 0));
+  EXPECT_EQ(INTRINSICCV_OK, scale<TypeParam>()(src, sizeof(TypeParam), dst,
+                                               sizeof(TypeParam), 1, 0, 2, 0));
+}
+
+TYPED_TEST(ScaleTest, OversizeImage) {
   TypeParam src[1] = {}, dst[1];
   EXPECT_EQ(INTRINSICCV_ERROR_RANGE,
             scale<TypeParam>()(src, sizeof(TypeParam), dst, sizeof(TypeParam),
diff --git a/test/api/test_sobel.cpp b/test/api/test_sobel.cpp
index 7c1829435854fee33cb02fb1209a6d455526e505..1d45d5835d1be07d064ecd5d22f9de997affd0b1 100644
--- a/test/api/test_sobel.cpp
+++ b/test/api/test_sobel.cpp
@@ -150,7 +150,18 @@ TYPED_TEST(Sobel, MisalignmentVertical) {
   }
 }
 
-TYPED_TEST(Sobel, ImageSizeHorizontal) {
+TYPED_TEST(Sobel, ZeroImageSizeHorizontal) {
+  using KernelTestParams = SobelKernelTestParams<TypeParam, false>;
+  typename KernelTestParams::InputType src[1] = {};
+  typename KernelTestParams::OutputType dst[1];
+
+  EXPECT_EQ(INTRINSICCV_OK, sobel_3x3_horizontal<TypeParam>()(
+                                src, sizeof(src), dst, sizeof(dst), 0, 1, 1));
+  EXPECT_EQ(INTRINSICCV_OK, sobel_3x3_horizontal<TypeParam>()(
+                                src, sizeof(src), dst, sizeof(dst), 1, 0, 1));
+}
+
+TYPED_TEST(Sobel, OversizeImageHorizontal) {
   MockMallocToFail::enable();
   using KernelTestParams = SobelKernelTestParams<TypeParam, true>;
   typename KernelTestParams::InputType src[1] = {};
@@ -172,7 +183,18 @@ TYPED_TEST(Sobel, ImageSizeHorizontal) {
   MockMallocToFail::disable();
 }
 
-TYPED_TEST(Sobel, ImageSizeVertical) {
+TYPED_TEST(Sobel, ZeroImageSizeVertical) {
+  using KernelTestParams = SobelKernelTestParams<TypeParam, false>;
+  typename KernelTestParams::InputType src[1] = {};
+  typename KernelTestParams::OutputType dst[1];
+
+  EXPECT_EQ(INTRINSICCV_OK, sobel_3x3_vertical<TypeParam>()(
+                                src, sizeof(src), dst, sizeof(dst), 0, 1, 1));
+  EXPECT_EQ(INTRINSICCV_OK, sobel_3x3_vertical<TypeParam>()(
+                                src, sizeof(src), dst, sizeof(dst), 1, 0, 1));
+}
+
+TYPED_TEST(Sobel, OversizeImageVertical) {
   MockMallocToFail::enable();
   using KernelTestParams = SobelKernelTestParams<TypeParam, false>;
   typename KernelTestParams::InputType src[1] = {};
diff --git a/test/api/test_split.cpp b/test/api/test_split.cpp
index af095db80709557ae29113cc698480f1c71b4006..3e750b23ed029402b16229a5a4bccae7582e818a 100644
--- a/test/api/test_split.cpp
+++ b/test/api/test_split.cpp
@@ -225,7 +225,22 @@ TYPED_TEST(Split, Misalignment) {
   }
 }
 
-TYPED_TEST(Split, ImageSize) {
+TYPED_TEST(Split, ZeroImageSize) {
+  const size_t kChannels = 2;
+  TypeParam src[1] = {}, dst1[1], dst2[1];
+  const size_t src_stride = kChannels * sizeof(TypeParam);
+  void* dsts[kChannels] = {dst1, dst2};
+  size_t dst_strides[kChannels] = {sizeof(TypeParam), sizeof(TypeParam)};
+
+  EXPECT_EQ(INTRINSICCV_OK,
+            intrinsiccv_split(src, src_stride, dsts, dst_strides, 0, 1,
+                              kChannels, sizeof(TypeParam)));
+  EXPECT_EQ(INTRINSICCV_OK,
+            intrinsiccv_split(src, src_stride, dsts, dst_strides, 1, 0,
+                              kChannels, sizeof(TypeParam)));
+}
+
+TYPED_TEST(Split, OversizeImage) {
   const size_t kChannels = 2;
   TypeParam src[1] = {}, dst1[1], dst2[1];
   const size_t src_stride = kChannels * sizeof(TypeParam);
diff --git a/test/api/test_threshold_binary.cpp b/test/api/test_threshold_binary.cpp
index f0d325aa792658e72ea33528b5cd5eaf62ac56b0..50205ff7516653814eb04ef5cdbed62b44bb552c 100644
--- a/test/api/test_threshold_binary.cpp
+++ b/test/api/test_threshold_binary.cpp
@@ -146,7 +146,17 @@ TYPED_TEST(ThresholdBinary, Misalignment) {
                                           sizeof(TypeParam) + 1, 1, 1, 1, 1));
 }
 
-TYPED_TEST(ThresholdBinary, ImageSize) {
+TYPED_TEST(ThresholdBinary, ZeroImageSize) {
+  TypeParam src[1] = {}, dst[1];
+  EXPECT_EQ(INTRINSICCV_OK,
+            threshold_binary<TypeParam>()(src, sizeof(TypeParam), dst,
+                                          sizeof(TypeParam), 0, 1, 1, 1));
+  EXPECT_EQ(INTRINSICCV_OK,
+            threshold_binary<TypeParam>()(src, sizeof(TypeParam), dst,
+                                          sizeof(TypeParam), 1, 0, 1, 1));
+}
+
+TYPED_TEST(ThresholdBinary, OversizeImage) {
   TypeParam src[1] = {}, dst[1];
   EXPECT_EQ(INTRINSICCV_ERROR_RANGE,
             threshold_binary<TypeParam>()(
diff --git a/test/api/test_transpose.cpp b/test/api/test_transpose.cpp
index 1da53a05966a0e9670659f08b8b8468f0eaa4787..e2fe7740f105a710c2f1bfe1ff05d451ba5f5b99 100644
--- a/test/api/test_transpose.cpp
+++ b/test/api/test_transpose.cpp
@@ -223,7 +223,17 @@ TYPED_TEST(Transpose, Misalignment) {
                             1, 1, sizeof(TypeParam)));
 }
 
-TYPED_TEST(Transpose, ImageSize) {
+TYPED_TEST(Transpose, ZeroImageSize) {
+  TypeParam src[1] = {}, dst[1];
+  EXPECT_EQ(INTRINSICCV_OK,
+            intrinsiccv_transpose(src, sizeof(TypeParam), dst,
+                                  sizeof(TypeParam), 0, 1, sizeof(TypeParam)));
+  EXPECT_EQ(INTRINSICCV_OK,
+            intrinsiccv_transpose(src, sizeof(TypeParam), dst,
+                                  sizeof(TypeParam), 1, 0, sizeof(TypeParam)));
+}
+
+TYPED_TEST(Transpose, OversizeImage) {
   TypeParam src[1] = {}, dst[1];
   EXPECT_EQ(INTRINSICCV_ERROR_RANGE,
             intrinsiccv_transpose(
diff --git a/test/api/test_yuv_to_rgb.cpp b/test/api/test_yuv_to_rgb.cpp
index 8e0924a9f1349772bc933eab6b283f81a27446a8..32cbf48c3bce8fa1286cc61db3d9d65a05b985e5 100644
--- a/test/api/test_yuv_to_rgb.cpp
+++ b/test/api/test_yuv_to_rgb.cpp
@@ -69,6 +69,15 @@ class YuvTest final {
                          actual.stride(), expected.width() / channel_number_,
                          expected.height(), is_nv21);
 
+    EXPECT_EQ(
+        INTRINSICCV_OK,
+        impl(input_y.data(), input_y.stride(), input_uv.data(),
+             input_uv.stride(), actual.data(), actual.stride(), 0, 1, is_nv21));
+    EXPECT_EQ(
+        INTRINSICCV_OK,
+        impl(input_y.data(), input_y.stride(), input_uv.data(),
+             input_uv.stride(), actual.data(), actual.stride(), 1, 0, is_nv21));
+
     EXPECT_EQ(INTRINSICCV_ERROR_RANGE,
               impl(input_y.data(), input_y.stride(), input_uv.data(),
                    input_uv.stride(), actual.data(), actual.stride(),