diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index b625499..d7a7214 100644
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -42,16 +42,6 @@
 ################################################################################
 # GoogleTest
 
-add_library(avifincrtest_helpers OBJECT gtest/avifincrtest_helpers.c)
-target_link_libraries(avifincrtest_helpers avif ${AVIF_PLATFORM_LIBRARIES})
-
-add_executable(avifincrtest gtest/avifincrtest.c)
-if(AVIF_LOCAL_LIBGAV1)
-    set_target_properties(avifincrtest PROPERTIES LINKER_LANGUAGE "CXX")
-endif()
-target_link_libraries(avifincrtest avifincrtest_helpers)
-add_test(NAME avifincrtest COMMAND avifincrtest ${CMAKE_CURRENT_SOURCE_DIR}/data/sofa_grid1x5_420.avif)
-
 if(AVIF_ENABLE_GTEST)
     enable_language(CXX)
     set(CMAKE_CXX_STANDARD 11)
@@ -81,6 +71,14 @@
     target_include_directories(avifgridapitest PRIVATE ${GTEST_INCLUDE_DIRS})
     add_test(NAME avifgridapitest COMMAND avifgridapitest)
 
+    add_library(avifincrtest_helpers OBJECT gtest/avifincrtest_helpers.cc)
+    target_link_libraries(avifincrtest_helpers avif ${AVIF_PLATFORM_LIBRARIES} ${GTEST_LIBRARIES})
+    target_include_directories(avifincrtest_helpers PUBLIC ${GTEST_INCLUDE_DIRS})
+
+    add_executable(avifincrtest gtest/avifincrtest.cc)
+    target_link_libraries(avifincrtest aviftest_helpers avifincrtest_helpers)
+    add_test(NAME avifincrtest COMMAND avifincrtest ${CMAKE_CURRENT_SOURCE_DIR}/data/)
+
     add_executable(avifmetadatatest gtest/avifmetadatatest.cc)
     target_link_libraries(avifmetadatatest aviftest_helpers ${GTEST_BOTH_LIBRARIES})
     target_include_directories(avifmetadatatest PRIVATE ${GTEST_INCLUDE_DIRS})
diff --git a/tests/gtest/avifincrtest.c b/tests/gtest/avifincrtest.c
deleted file mode 100644
index fe04616..0000000
--- a/tests/gtest/avifincrtest.c
+++ /dev/null
@@ -1,151 +0,0 @@
-// Copyright 2022 Google LLC. All rights reserved.
-// SPDX-License-Identifier: BSD-2-Clause
-
-#include "avif/avif.h"
-#include "avifincrtest_helpers.h"
-
-#include <stdint.h>
-#include <stdio.h>
-#include <stdlib.h>
-
-//------------------------------------------------------------------------------
-
-// Reads the file at path into bytes or returns false.
-static avifBool readFile(const char * path, avifRWData * bytes)
-{
-    FILE * file;
-    avifRWDataFree(bytes);
-    file = fopen(path, "rb");
-    if (!file) {
-        return AVIF_FALSE;
-    }
-    if (fseek(file, 0, SEEK_END)) {
-        fclose(file);
-        return AVIF_FALSE;
-    }
-    avifRWDataRealloc(bytes, ftell(file));
-    rewind(file);
-    if (fread(bytes->data, bytes->size, 1, file) != 1) {
-        avifRWDataFree(bytes);
-        fclose(file);
-        return AVIF_FALSE;
-    }
-    fclose(file);
-    return AVIF_TRUE;
-}
-
-//------------------------------------------------------------------------------
-
-// Encodes then decodes a window of width*height pixels at the middle of the image.
-// Check that non-incremental and incremental decodings produce the same pixels.
-static avifBool encodeDecodeNonIncrementallyAndIncrementally(const avifImage * image,
-                                                             uint32_t width,
-                                                             uint32_t height,
-                                                             avifBool createAlphaIfNone,
-                                                             avifBool flatCells,
-                                                             avifBool encodedAvifIsPersistent,
-                                                             avifBool giveSizeHint,
-                                                             avifBool useNthImageApi)
-{
-    avifBool success = AVIF_FALSE;
-    avifRWData encodedAvif = { 0 };
-    uint32_t cellWidth, cellHeight;
-    if (!encodeRectAsIncremental(image, width, height, createAlphaIfNone, flatCells, &encodedAvif, &cellWidth, &cellHeight)) {
-        goto cleanup;
-    }
-    if (!decodeNonIncrementallyAndIncrementally(&encodedAvif, encodedAvifIsPersistent, giveSizeHint, useNthImageApi, cellHeight)) {
-        goto cleanup;
-    }
-    success = AVIF_TRUE;
-cleanup:
-    avifRWDataFree(&encodedAvif);
-    return success;
-}
-
-//------------------------------------------------------------------------------
-
-int main(int argc, char * argv[])
-{
-    int exitCode = EXIT_FAILURE;
-    avifRWData encodedAvif = { NULL, 0 };
-
-    if (argc != 2) {
-        printf("ERROR: bad arguments\n");
-        printf("Usage: avifincrtest <AVIF>\n");
-        goto cleanup;
-    }
-    const char * const avifFilePath = argv[1];
-
-    if (!readFile(avifFilePath, &encodedAvif)) {
-        printf("ERROR: cannot read AVIF: %s\n", avifFilePath);
-        goto cleanup;
-    }
-
-    // First test: decode the input image incrementally and compare it with a non-incrementally decoded reference.
-    avifImage * reference = avifImageCreateEmpty();
-    if (!reference || !decodeNonIncrementally(&encodedAvif, reference)) {
-        goto cleanup;
-    }
-    // Cell height is hardcoded because there is no API to extract it from an encoded payload.
-    if (!decodeIncrementally(&encodedAvif,
-                             /*isPersistent=*/AVIF_TRUE,
-                             /*giveSizeHint=*/AVIF_TRUE,
-                             /*useNthImageApi=*/AVIF_FALSE,
-                             reference,
-                             /*cellHeight=*/154)) {
-        goto cleanup;
-    }
-
-    // Second test: encode a bunch of different dimension combinations and decode them incrementally and non-incrementally.
-    // Chroma subsampling requires even dimensions. See ISO 23000-22 section 7.3.11.4.2.
-    const uint32_t widths[] = { 1, 64, 66 };
-    const uint32_t heights[] = { 1, 64, 66 };
-    for (uint32_t w = 0; w < sizeof(widths) / sizeof(widths[0]); ++w) {
-        for (uint32_t h = 0; h < sizeof(heights) / sizeof(heights[0]); ++h) {
-            // avifEncoderAddImageInternal() only accepts grids of one unique cell, or grids where width and height are both at least 64.
-            if ((widths[w] >= 64) != (heights[h] >= 64)) {
-                continue;
-            }
-
-            for (avifBool createAlpha = AVIF_FALSE; createAlpha <= AVIF_TRUE; ++createAlpha) {
-                for (avifBool flatCells = AVIF_FALSE; flatCells <= AVIF_TRUE; ++flatCells) {
-                    for (avifBool encodedAvifIsPersistent = AVIF_FALSE; encodedAvifIsPersistent <= AVIF_TRUE; ++encodedAvifIsPersistent) {
-                        for (avifBool giveSizeHint = AVIF_FALSE; giveSizeHint <= AVIF_TRUE; ++giveSizeHint) {
-                            for (avifBool useNthImageApi = AVIF_FALSE; useNthImageApi <= AVIF_TRUE; ++useNthImageApi) {
-                                if (!encodeDecodeNonIncrementallyAndIncrementally(reference,
-                                                                                  widths[w],
-                                                                                  heights[h],
-                                                                                  createAlpha,
-                                                                                  flatCells,
-                                                                                  encodedAvifIsPersistent,
-                                                                                  giveSizeHint,
-                                                                                  useNthImageApi)) {
-                                    goto cleanup;
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-        }
-    }
-
-    // Third test: full image.
-    for (avifBool flatCells = AVIF_FALSE; flatCells <= AVIF_TRUE; ++flatCells) {
-        if (!encodeDecodeNonIncrementallyAndIncrementally(reference,
-                                                          reference->width,
-                                                          reference->height,
-                                                          /*createAlphaIfNone=*/AVIF_TRUE,
-                                                          flatCells,
-                                                          /*encodedAvifIsPersistent=*/AVIF_TRUE,
-                                                          /*giveSizeHint=*/AVIF_TRUE,
-                                                          /*useNthImageApi=*/AVIF_FALSE)) {
-            goto cleanup;
-        }
-    }
-
-    exitCode = EXIT_SUCCESS;
-cleanup:
-    avifRWDataFree(&encodedAvif);
-    return exitCode;
-}
diff --git a/tests/gtest/avifincrtest.cc b/tests/gtest/avifincrtest.cc
new file mode 100644
index 0000000..6aae233
--- /dev/null
+++ b/tests/gtest/avifincrtest.cc
@@ -0,0 +1,142 @@
+// Copyright 2022 Google LLC. All rights reserved.
+// SPDX-License-Identifier: BSD-2-Clause
+
+#include "avif/avif.h"
+
+#include <fstream>
+#include <iostream>
+#include <tuple>
+
+#include "avifincrtest_helpers.h"
+#include "aviftest_helpers.h"
+#include "gtest/gtest.h"
+
+using testing::Bool;
+using testing::Combine;
+using testing::Values;
+
+namespace libavif
+{
+namespace
+{
+
+//------------------------------------------------------------------------------
+
+// Used to pass the data folder path to the GoogleTest suites.
+const char * dataPath = nullptr;
+
+// Reads the file with fileName into bytes and returns them.
+testutil::avifRWDataCleaner readFile(const char * fileName)
+{
+    std::ifstream file(std::string(dataPath) + fileName, std::ios::binary | std::ios::ate);
+    testutil::avifRWDataCleaner bytes;
+    avifRWDataRealloc(&bytes, file.good() ? static_cast<size_t>(file.tellg()) : 0);
+    file.seekg(0, std::ios::beg);
+    file.read(reinterpret_cast<char *>(bytes.data), static_cast<std::streamsize>(bytes.size));
+    return bytes;
+}
+
+//------------------------------------------------------------------------------
+
+// Check that non-incremental and incremental decodings of a grid AVIF produce the same pixels.
+TEST(IncrementalTest, Decode)
+{
+    const testutil::avifRWDataCleaner encodedAvif = readFile("sofa_grid1x5_420.avif");
+    ASSERT_NE(encodedAvif.size, 0u);
+    testutil::avifImagePtr reference(avifImageCreateEmpty(), avifImageDestroy);
+    ASSERT_NE(reference, nullptr);
+    testutil::avifDecoderPtr decoder(avifDecoderCreate(), avifDecoderDestroy);
+    ASSERT_NE(decoder, nullptr);
+    ASSERT_EQ(avifDecoderReadMemory(decoder.get(), reference.get(), encodedAvif.data, encodedAvif.size), AVIF_RESULT_OK);
+
+    // Cell height is hardcoded because there is no API to extract it from an encoded payload.
+    testutil::decodeIncrementally(encodedAvif, /*isPersistent=*/true, /*giveSizeHint=*/true, /*useNthImageApi=*/false, *reference, /*cellHeight=*/154);
+}
+
+//------------------------------------------------------------------------------
+
+class IncrementalTest : public testing::TestWithParam<std::tuple</*width=*/uint32_t,
+                                                                 /*height=*/uint32_t,
+                                                                 /*createAlpha=*/bool,
+                                                                 /*flatCells=*/bool,
+                                                                 /*encodedAvifIsPersistent=*/bool,
+                                                                 /*giveSizeHint=*/bool,
+                                                                 /*useNthImageApi=*/bool>>
+{
+};
+
+// Encodes then decodes a window of width*height pixels at the middle of the image.
+// Check that non-incremental and incremental decodings produce the same pixels.
+TEST_P(IncrementalTest, EncodeDecode)
+{
+    const uint32_t width = std::get<0>(GetParam());
+    const uint32_t height = std::get<1>(GetParam());
+    const bool createAlpha = std::get<2>(GetParam());
+    const bool flatCells = std::get<3>(GetParam());
+    const bool encodedAvifIsPersistent = std::get<4>(GetParam());
+    const bool giveSizeHint = std::get<5>(GetParam());
+    const bool useNthImageApi = std::get<6>(GetParam());
+
+    // Load an image. It does not matter that it comes from an AVIF file.
+    testutil::avifImagePtr image(avifImageCreateEmpty(), avifImageDestroy);
+    ASSERT_NE(image, nullptr);
+    const testutil::avifRWDataCleaner imageBytes = readFile("sofa_grid1x5_420.avif");
+    ASSERT_NE(imageBytes.size, 0u);
+    testutil::avifDecoderPtr decoder(avifDecoderCreate(), avifDecoderDestroy);
+    ASSERT_NE(decoder, nullptr);
+    ASSERT_EQ(avifDecoderReadMemory(decoder.get(), image.get(), imageBytes.data, imageBytes.size), AVIF_RESULT_OK);
+
+    // Encode then decode it.
+    testutil::avifRWDataCleaner encodedAvif;
+    uint32_t cellWidth, cellHeight;
+    testutil::encodeRectAsIncremental(*image, width, height, createAlpha, flatCells, &encodedAvif, &cellWidth, &cellHeight);
+    testutil::decodeNonIncrementallyAndIncrementally(encodedAvif, encodedAvifIsPersistent, giveSizeHint, useNthImageApi, cellHeight);
+}
+
+INSTANTIATE_TEST_SUITE_P(WholeImage,
+                         IncrementalTest,
+                         Combine(/*width=*/Values(1024),
+                                 /*height=*/Values(770),
+                                 /*createAlpha=*/Values(true),
+                                 /*flatCells=*/Bool(),
+                                 /*encodedAvifIsPersistent=*/Values(true),
+                                 /*giveSizeHint=*/Values(true),
+                                 /*useNthImageApi=*/Values(false)));
+
+// avifEncoderAddImageInternal() only accepts grids of one unique cell, or grids where width and height are both at least 64.
+INSTANTIATE_TEST_SUITE_P(SingleCell,
+                         IncrementalTest,
+                         Combine(/*width=*/Values(1),
+                                 /*height=*/Values(1),
+                                 /*createAlpha=*/Bool(),
+                                 /*flatCells=*/Bool(),
+                                 /*encodedAvifIsPersistent=*/Bool(),
+                                 /*giveSizeHint=*/Bool(),
+                                 /*useNthImageApi=*/Bool()));
+
+// Chroma subsampling requires even dimensions. See ISO 23000-22 section 7.3.11.4.2.
+INSTANTIATE_TEST_SUITE_P(SinglePixel,
+                         IncrementalTest,
+                         Combine(/*width=*/Values(64, 66),
+                                 /*height=*/Values(64, 66),
+                                 /*createAlpha=*/Bool(),
+                                 /*flatCells=*/Bool(),
+                                 /*encodedAvifIsPersistent=*/Bool(),
+                                 /*giveSizeHint=*/Bool(),
+                                 /*useNthImageApi=*/Bool()));
+
+//------------------------------------------------------------------------------
+
+} // namespace
+} // namespace libavif
+
+int main(int argc, char ** argv)
+{
+    ::testing::InitGoogleTest(&argc, argv);
+    if (argc < 2) {
+        std::cerr << "The path to the test data folder must be provided as an argument" << std::endl;
+        return 1;
+    }
+    libavif::dataPath = argv[1];
+    return RUN_ALL_TESTS();
+}
diff --git a/tests/gtest/avifincrtest_helpers.c b/tests/gtest/avifincrtest_helpers.c
deleted file mode 100644
index b15f740..0000000
--- a/tests/gtest/avifincrtest_helpers.c
+++ /dev/null
@@ -1,423 +0,0 @@
-// Copyright 2022 Google LLC. All rights reserved.
-// SPDX-License-Identifier: BSD-2-Clause
-
-#include "avifincrtest_helpers.h"
-#include "avif/avif.h"
-
-#include <assert.h>
-#include <inttypes.h>
-#include <stdio.h>
-#include <string.h>
-
-//------------------------------------------------------------------------------
-
-// Returns true if the first (top) rowCount rows of image1 and image2 are identical.
-static avifBool comparePartialYUVA(const avifImage * image1, const avifImage * image2, uint32_t rowCount)
-{
-    if (rowCount == 0) {
-        return AVIF_TRUE;
-    }
-    if (!image1 || !image2 || (image1->width != image2->width) || (image1->depth != image2->depth) ||
-        (image1->yuvFormat != image2->yuvFormat) || (image1->yuvRange != image2->yuvRange)) {
-        printf("ERROR: input mismatch\n");
-        return AVIF_FALSE;
-    }
-    if ((image1->height < rowCount) || (image2->height < rowCount)) {
-        printf("ERROR: not enough rows to compare\n");
-        return AVIF_FALSE;
-    }
-
-    avifPixelFormatInfo info;
-    avifGetPixelFormatInfo(image1->yuvFormat, &info);
-    const uint32_t uvWidth = (image1->width + info.chromaShiftX) >> info.chromaShiftX;
-    const uint32_t uvHeight = (rowCount + info.chromaShiftY) >> info.chromaShiftY;
-    const uint32_t pixelByteCount = (image1->depth > 8) ? sizeof(uint16_t) : sizeof(uint8_t);
-
-    for (uint32_t plane = 0; plane < (info.monochrome ? 1 : AVIF_PLANE_COUNT_YUV); ++plane) {
-        const uint32_t width = (plane == AVIF_CHAN_Y) ? image1->width : uvWidth;
-        const uint32_t widthByteCount = width * pixelByteCount;
-        const uint32_t height = (plane == AVIF_CHAN_Y) ? rowCount : uvHeight;
-        const uint8_t * data1 = image1->yuvPlanes[plane];
-        const uint8_t * data2 = image2->yuvPlanes[plane];
-        for (uint32_t y = 0; y < height; ++y) {
-            if (memcmp(data1, data2, widthByteCount)) {
-                printf("ERROR: different px at row %" PRIu32 ", channel %" PRIu32 "\n", y, plane);
-                return AVIF_FALSE;
-            }
-            data1 += image1->yuvRowBytes[plane];
-            data2 += image2->yuvRowBytes[plane];
-        }
-    }
-
-    if (image1->alphaPlane) {
-        if (!image2->alphaPlane || (image1->alphaPremultiplied != image2->alphaPremultiplied)) {
-            printf("ERROR: input mismatch\n");
-            return AVIF_FALSE;
-        }
-        const uint32_t widthByteCount = image1->width * pixelByteCount;
-        const uint8_t * data1 = image1->alphaPlane;
-        const uint8_t * data2 = image2->alphaPlane;
-        for (uint32_t y = 0; y < rowCount; ++y) {
-            if (memcmp(data1, data2, widthByteCount)) {
-                printf("ERROR: different px at row %" PRIu32 ", alpha\n", y);
-                return AVIF_FALSE;
-            }
-            data1 += image1->alphaRowBytes;
-            data2 += image2->alphaRowBytes;
-        }
-    }
-    return AVIF_TRUE;
-}
-
-// Returns the expected number of decoded rows when availableByteCount out of byteCount were
-// given to the decoder, for an image of height rows, split into cells of cellHeight rows.
-static uint32_t getMinDecodedRowCount(uint32_t height, uint32_t cellHeight, avifBool hasAlpha, size_t availableByteCount, size_t byteCount)
-{
-    // The whole image should be available when the full input is.
-    if (availableByteCount >= byteCount) {
-        return height;
-    }
-    // All but one cell should be decoded if at most 10 bytes are missing.
-    if ((availableByteCount + 10) >= byteCount) {
-        return height - cellHeight;
-    }
-
-    // Subtract the header because decoding it does not output any pixel.
-    // Most AVIF headers are below 500 bytes.
-    if (availableByteCount <= 500) {
-        return 0;
-    }
-    availableByteCount -= 500;
-    byteCount -= 500;
-    // Alpha, if any, is assumed to be located before the other planes and to
-    // represent at most 50% of the payload.
-    if (hasAlpha) {
-        if (availableByteCount <= (byteCount / 2)) {
-            return 0;
-        }
-        availableByteCount -= byteCount / 2;
-        byteCount -= byteCount / 2;
-    }
-    // Linearly map the input availability ratio to the decoded row ratio.
-    const uint32_t minDecodedCellRowCount = (height / cellHeight) * availableByteCount / byteCount;
-    const uint32_t minDecodedPxRowCount = minDecodedCellRowCount * cellHeight;
-    // One cell is the incremental decoding granularity.
-    // It is unlikely that bytes are evenly distributed among cells. Offset two of them.
-    if (minDecodedPxRowCount <= (2 * cellHeight)) {
-        return 0;
-    }
-    return minDecodedPxRowCount - 2 * cellHeight;
-}
-
-//------------------------------------------------------------------------------
-
-typedef struct
-{
-    avifROData available;
-    size_t fullSize;
-} avifROPartialData;
-
-// Implementation of avifIOReadFunc simulating a stream from an array. See avifIOReadFunc documentation.
-// io->data is expected to point to avifROPartialData.
-static avifResult avifIOPartialRead(struct avifIO * io, uint32_t readFlags, uint64_t offset, size_t size, avifROData * out)
-{
-    const avifROPartialData * data = (avifROPartialData *)io->data;
-    if ((readFlags != 0) || !data || (data->fullSize < offset)) {
-        return AVIF_RESULT_IO_ERROR;
-    }
-    if (data->fullSize < (offset + size)) {
-        size = data->fullSize - offset;
-    }
-    if (data->available.size < (offset + size)) {
-        return AVIF_RESULT_WAITING_ON_IO;
-    }
-    out->data = data->available.data + offset;
-    out->size = size;
-    return AVIF_RESULT_OK;
-}
-
-//------------------------------------------------------------------------------
-
-// Encodes the image as a grid of at most gridCols*gridRows cells. Returns AVIF_FALSE in case of error.
-// The cell count is reduced to fit libavif or AVIF format constraints. If impossible, AVIF_TRUE is returned with no encoded output.
-// The final cellWidth and cellHeight are output.
-static avifBool encodeAsGrid(const avifImage * image, uint32_t gridCols, uint32_t gridRows, avifRWData * output, uint32_t * cellWidth, uint32_t * cellHeight)
-{
-    avifBool success = AVIF_FALSE;
-    avifEncoder * encoder = NULL;
-    avifImage ** cellImages = NULL;
-    // Chroma subsampling requires even dimensions. See ISO 23000-22 - 7.3.11.4.2
-    const avifBool needEvenWidths = ((image->yuvFormat == AVIF_PIXEL_FORMAT_YUV420) || (image->yuvFormat == AVIF_PIXEL_FORMAT_YUV422));
-    const avifBool needEvenHeights = (image->yuvFormat == AVIF_PIXEL_FORMAT_YUV420);
-
-    if ((gridCols == 0) || (gridRows == 0)) {
-        printf("ERROR: Bad grid dimensions\n");
-        return AVIF_FALSE;
-    }
-
-    *cellWidth = image->width / gridCols;
-    *cellHeight = image->height / gridRows;
-
-    // avifEncoderAddImageGrid() only accepts grids that evenly split the image
-    // into cells at least 64 pixels wide and tall.
-    while ((gridCols > 1) &&
-           (((*cellWidth * gridCols) != image->width) || (*cellWidth < 64) || (needEvenWidths && ((*cellWidth & 1) != 0)))) {
-        --gridCols;
-        *cellWidth = image->width / gridCols;
-    }
-    while ((gridRows > 1) &&
-           (((*cellHeight * gridRows) != image->height) || (*cellHeight < 64) || (needEvenHeights && ((*cellHeight & 1) != 0)))) {
-        --gridRows;
-        *cellHeight = image->height / gridRows;
-    }
-
-    cellImages = avifAlloc(sizeof(avifImage *) * gridCols * gridRows);
-    memset(cellImages, 0, sizeof(avifImage *) * gridCols * gridRows);
-    for (uint32_t row = 0, iCell = 0; row < gridRows; ++row) {
-        for (uint32_t col = 0; col < gridCols; ++col, ++iCell) {
-            avifCropRect cell;
-            cell.x = col * *cellWidth;
-            cell.y = row * *cellHeight;
-            cell.width = ((cell.x + *cellWidth) <= image->width) ? *cellWidth : (image->width - cell.x);
-            cell.height = ((cell.y + *cellHeight) <= image->height) ? *cellHeight : (image->height - cell.y);
-            cellImages[iCell] = avifImageCreateEmpty();
-            if (!cellImages[iCell] || (avifImageSetViewRect(cellImages[iCell], image, &cell) != AVIF_RESULT_OK)) {
-                printf("ERROR: avifImageCreateEmpty() failed\n");
-                goto cleanup;
-            }
-        }
-    }
-
-    encoder = avifEncoderCreate();
-    if (!encoder) {
-        printf("ERROR: avifEncoderCreate() failed\n");
-        goto cleanup;
-    }
-    encoder->speed = AVIF_SPEED_FASTEST;
-    if (avifEncoderAddImageGrid(encoder, gridCols, gridRows, (const avifImage * const *)cellImages, AVIF_ADD_IMAGE_FLAG_SINGLE) !=
-        AVIF_RESULT_OK) {
-        printf("ERROR: avifEncoderAddImageGrid() failed\n");
-        goto cleanup;
-    }
-    if (avifEncoderFinish(encoder, output) != AVIF_RESULT_OK) {
-        printf("ERROR: avifEncoderFinish() failed\n");
-        goto cleanup;
-    }
-
-    success = AVIF_TRUE;
-cleanup:
-    if (encoder) {
-        avifEncoderDestroy(encoder);
-    }
-    if (cellImages) {
-        for (uint32_t i = 0; i < (gridCols * gridRows); ++i) {
-            if (cellImages[i]) {
-                avifImageDestroy(cellImages[i]);
-            }
-        }
-        avifFree(cellImages);
-    }
-    return success;
-}
-
-// Encodes the image to be decoded incrementally.
-static avifBool encodeAsIncremental(const avifImage * image, avifBool flatCells, avifRWData * output, uint32_t * cellWidth, uint32_t * cellHeight)
-{
-    const uint32_t gridCols = image->width / 64; // 64px is the min cell width.
-    const uint32_t gridRows = flatCells ? 1 : (image->height / 64);
-    return encodeAsGrid(image, (gridCols > 1) ? gridCols : 1, (gridRows > 1) ? gridRows : 1, output, cellWidth, cellHeight);
-}
-
-avifBool encodeRectAsIncremental(const avifImage * image,
-                                 uint32_t width,
-                                 uint32_t height,
-                                 avifBool createAlphaIfNone,
-                                 avifBool flatCells,
-                                 avifRWData * output,
-                                 uint32_t * cellWidth,
-                                 uint32_t * cellHeight)
-{
-    avifBool success = AVIF_FALSE;
-    avifImage * subImage = avifImageCreateEmpty();
-    if (!subImage) {
-        printf("ERROR: avifImageCreateEmpty() failed\n");
-        goto cleanup;
-    }
-    if ((width > image->width) || (height > image->height)) {
-        printf("ERROR: Bad dimensions\n");
-        goto cleanup;
-    }
-    avifPixelFormatInfo info;
-    avifGetPixelFormatInfo(image->yuvFormat, &info);
-    avifCropRect rect;
-    rect.x = ((image->width - width) / 2) & ~info.chromaShiftX;
-    rect.y = ((image->height - height) / 2) & ~info.chromaShiftX;
-    rect.width = width;
-    rect.height = height;
-    if (avifImageSetViewRect(subImage, image, &rect) != AVIF_RESULT_OK) {
-        printf("ERROR: avifImageSetViewRect() failed\n");
-        goto cleanup;
-    }
-    if (createAlphaIfNone && !subImage->alphaPlane) {
-        if (!image->yuvPlanes[AVIF_CHAN_Y]) {
-            printf("ERROR: No luma plane to simulate an alpha plane\n");
-            goto cleanup;
-        }
-        subImage->alphaPlane = image->yuvPlanes[AVIF_CHAN_Y];
-        subImage->alphaRowBytes = image->yuvRowBytes[AVIF_CHAN_Y];
-        subImage->alphaPremultiplied = AVIF_FALSE;
-        subImage->imageOwnsAlphaPlane = AVIF_FALSE;
-    }
-    success = encodeAsIncremental(subImage, flatCells, output, cellWidth, cellHeight);
-cleanup:
-    if (subImage) {
-        avifImageDestroy(subImage);
-    }
-    return success;
-}
-
-//------------------------------------------------------------------------------
-
-avifBool decodeNonIncrementally(const avifRWData * encodedAvif, avifImage * image)
-{
-    avifBool success = AVIF_FALSE;
-    avifDecoder * decoder = avifDecoderCreate();
-    if (!decoder || avifDecoderReadMemory(decoder, image, encodedAvif->data, encodedAvif->size) != AVIF_RESULT_OK) {
-        printf("ERROR: avifDecoderReadMemory() failed\n");
-        goto cleanup;
-    }
-    success = AVIF_TRUE;
-cleanup:
-    if (decoder) {
-        avifDecoderDestroy(decoder);
-    }
-    return success;
-}
-
-avifBool decodeIncrementally(const avifRWData * encodedAvif,
-                             avifBool isPersistent,
-                             avifBool giveSizeHint,
-                             avifBool useNthImageApi,
-                             const avifImage * reference,
-                             uint32_t cellHeight)
-{
-    avifBool success = AVIF_FALSE;
-    avifDecoder * decoder = NULL;
-    // AVIF cells are at least 64 pixels tall.
-    if ((cellHeight == 0) || ((cellHeight > reference->height) && (cellHeight != 64))) {
-        printf("ERROR: cell height %" PRIu32 " is invalid\n", cellHeight);
-        goto cleanup;
-    }
-
-    // Emulate a byte-by-byte stream.
-    avifROPartialData data = { /*available=*/ { encodedAvif->data, 0 }, /*fullSize=*/encodedAvif->size };
-    avifIO io = { 0 };
-    io.read = avifIOPartialRead;
-    if (giveSizeHint) {
-        io.sizeHint = encodedAvif->size;
-    }
-    io.persistent = isPersistent;
-    io.data = &data;
-
-    decoder = avifDecoderCreate();
-    if (!decoder) {
-        printf("ERROR: avifDecoderCreate() failed\n");
-        goto cleanup;
-    }
-    avifDecoderSetIO(decoder, &io);
-    decoder->allowIncremental = AVIF_TRUE;
-
-    // Parsing is not incremental.
-    avifResult parseResult = avifDecoderParse(decoder);
-    while (parseResult == AVIF_RESULT_WAITING_ON_IO) {
-        if (data.available.size >= data.fullSize) {
-            printf("ERROR: avifDecoderParse() returned WAITING_ON_IO instead of OK\n");
-            goto cleanup;
-        }
-        data.available.size = data.available.size + 1;
-        parseResult = avifDecoderParse(decoder);
-    }
-    if (parseResult != AVIF_RESULT_OK) {
-        printf("ERROR: avifDecoderParse() failed (%s)\n", avifResultToString(parseResult));
-        goto cleanup;
-    }
-
-    // Decoding is incremental.
-    uint32_t previouslyDecodedRowCount = 0;
-    avifResult nextImageResult = useNthImageApi ? avifDecoderNthImage(decoder, 0) : avifDecoderNextImage(decoder);
-    while (nextImageResult == AVIF_RESULT_WAITING_ON_IO) {
-        if (data.available.size >= data.fullSize) {
-            printf("ERROR: avifDecoderNextImage() or avifDecoderNthImage(0) returned WAITING_ON_IO instead of OK\n");
-            goto cleanup;
-        }
-        const uint32_t decodedRowCount = avifDecoderDecodedRowCount(decoder);
-        if (decodedRowCount < previouslyDecodedRowCount) {
-            printf("ERROR: %" PRIu32 " decoded rows decreased to %" PRIu32 "\n", previouslyDecodedRowCount, decodedRowCount);
-            goto cleanup;
-        }
-        const uint32_t minDecodedRowCount =
-            getMinDecodedRowCount(reference->height, cellHeight, reference->alphaPlane != NULL, data.available.size, data.fullSize);
-        if (decodedRowCount < minDecodedRowCount) {
-            printf("ERROR: %" PRIu32 " is fewer than %" PRIu32 " decoded rows\n", decodedRowCount, minDecodedRowCount);
-            goto cleanup;
-        }
-        if (!comparePartialYUVA(reference, decoder->image, decodedRowCount)) {
-            goto cleanup;
-        }
-
-        previouslyDecodedRowCount = decodedRowCount;
-        data.available.size = data.available.size + 1;
-        nextImageResult = useNthImageApi ? avifDecoderNthImage(decoder, 0) : avifDecoderNextImage(decoder);
-    }
-    if (nextImageResult != AVIF_RESULT_OK) {
-        printf("ERROR: avifDecoderNextImage() or avifDecoderNthImage(0) failed (%s)\n", avifResultToString(nextImageResult));
-        goto cleanup;
-    }
-    if (data.available.size != data.fullSize) {
-        printf("ERROR: not all bytes were read\n");
-        goto cleanup;
-    }
-    if (avifDecoderDecodedRowCount(decoder) != decoder->image->height) {
-        printf("ERROR: avifDecoderDecodedRowCount() should be decoder->image->height after OK\n");
-        goto cleanup;
-    }
-
-    if (!comparePartialYUVA(reference, decoder->image, reference->height)) {
-        goto cleanup;
-    }
-    success = AVIF_TRUE;
-cleanup:
-    if (decoder) {
-        avifDecoderDestroy(decoder);
-    }
-    return success;
-}
-
-avifBool decodeNonIncrementallyAndIncrementally(const avifRWData * encodedAvif,
-                                                avifBool isPersistent,
-                                                avifBool giveSizeHint,
-                                                avifBool useNthImageApi,
-                                                uint32_t cellHeight)
-{
-    // TODO(wtc): Remove this assertion when this file is converted to C++.
-    assert((useNthImageApi == AVIF_FALSE) || (useNthImageApi == AVIF_TRUE));
-    avifBool success = AVIF_FALSE;
-    avifImage * reference = avifImageCreateEmpty();
-    if (!reference) {
-        goto cleanup;
-    }
-    if (!decodeNonIncrementally(encodedAvif, reference)) {
-        goto cleanup;
-    }
-    if (!decodeIncrementally(encodedAvif, isPersistent, giveSizeHint, useNthImageApi, reference, cellHeight)) {
-        goto cleanup;
-    }
-    success = AVIF_TRUE;
-cleanup:
-    if (reference) {
-        avifImageDestroy(reference);
-    }
-    return success;
-}
-
-//------------------------------------------------------------------------------
diff --git a/tests/gtest/avifincrtest_helpers.cc b/tests/gtest/avifincrtest_helpers.cc
new file mode 100644
index 0000000..2078daa
--- /dev/null
+++ b/tests/gtest/avifincrtest_helpers.cc
@@ -0,0 +1,299 @@
+// Copyright 2022 Google LLC. All rights reserved.
+// SPDX-License-Identifier: BSD-2-Clause
+
+#include "avif/avif.h"
+
+#include <algorithm>
+#include <vector>
+
+#include "avifincrtest_helpers.h"
+#include "aviftest_helpers.h"
+#include "gtest/gtest.h"
+
+namespace libavif
+{
+namespace testutil
+{
+namespace
+{
+
+//------------------------------------------------------------------------------
+
+// Verifies that the first (top) rowCount rows of image1 and image2 are identical.
+void comparePartialYUVA(const avifImage & image1, const avifImage & image2, uint32_t rowCount)
+{
+    if (rowCount == 0) {
+        return;
+    }
+    ASSERT_EQ(image1.width, image2.width);
+    ASSERT_GE(image1.height, rowCount);
+    ASSERT_GE(image2.height, rowCount);
+    ASSERT_EQ(image1.depth, image2.depth);
+    ASSERT_EQ(image1.yuvFormat, image2.yuvFormat);
+    ASSERT_EQ(image1.yuvRange, image2.yuvRange);
+
+    avifPixelFormatInfo info;
+    avifGetPixelFormatInfo(image1.yuvFormat, &info);
+    const uint32_t uvWidth = (image1.width + info.chromaShiftX) >> info.chromaShiftX;
+    const uint32_t uvHeight = (rowCount + info.chromaShiftY) >> info.chromaShiftY;
+    const uint32_t pixelByteCount = (image1.depth > 8) ? sizeof(uint16_t) : sizeof(uint8_t);
+
+    for (uint32_t plane = 0; plane < (info.monochrome ? 1 : AVIF_PLANE_COUNT_YUV); ++plane) {
+        const uint32_t width = (plane == AVIF_CHAN_Y) ? image1.width : uvWidth;
+        const uint32_t widthByteCount = width * pixelByteCount;
+        const uint32_t height = (plane == AVIF_CHAN_Y) ? rowCount : uvHeight;
+        const uint8_t * data1 = image1.yuvPlanes[plane];
+        const uint8_t * data2 = image2.yuvPlanes[plane];
+        for (uint32_t y = 0; y < height; ++y) {
+            ASSERT_TRUE(std::equal(data1, data1 + widthByteCount, data2));
+            data1 += image1.yuvRowBytes[plane];
+            data2 += image2.yuvRowBytes[plane];
+        }
+    }
+
+    if (image1.alphaPlane) {
+        ASSERT_NE(image2.alphaPlane, nullptr);
+        ASSERT_EQ(image1.alphaPremultiplied, image2.alphaPremultiplied);
+        const uint32_t widthByteCount = image1.width * pixelByteCount;
+        const uint8_t * data1 = image1.alphaPlane;
+        const uint8_t * data2 = image2.alphaPlane;
+        for (uint32_t y = 0; y < rowCount; ++y) {
+            ASSERT_TRUE(std::equal(data1, data1 + widthByteCount, data2));
+            data1 += image1.alphaRowBytes;
+            data2 += image2.alphaRowBytes;
+        }
+    }
+}
+
+// Returns the expected number of decoded rows when availableByteCount out of byteCount were
+// given to the decoder, for an image of height rows, split into cells of cellHeight rows.
+uint32_t getMinDecodedRowCount(uint32_t height, uint32_t cellHeight, bool hasAlpha, size_t availableByteCount, size_t byteCount)
+{
+    // The whole image should be available when the full input is.
+    if (availableByteCount >= byteCount) {
+        return height;
+    }
+    // All but one cell should be decoded if at most 10 bytes are missing.
+    if ((availableByteCount + 10) >= byteCount) {
+        return height - cellHeight;
+    }
+
+    // Subtract the header because decoding it does not output any pixel.
+    // Most AVIF headers are below 500 bytes.
+    if (availableByteCount <= 500) {
+        return 0;
+    }
+    availableByteCount -= 500;
+    byteCount -= 500;
+    // Alpha, if any, is assumed to be located before the other planes and to
+    // represent at most 50% of the payload.
+    if (hasAlpha) {
+        if (availableByteCount <= (byteCount / 2)) {
+            return 0;
+        }
+        availableByteCount -= byteCount / 2;
+        byteCount -= byteCount / 2;
+    }
+    // Linearly map the input availability ratio to the decoded row ratio.
+    const uint32_t minDecodedCellRowCount = (height / cellHeight) * availableByteCount / byteCount;
+    const uint32_t minDecodedPxRowCount = minDecodedCellRowCount * cellHeight;
+    // One cell is the incremental decoding granularity.
+    // It is unlikely that bytes are evenly distributed among cells. Offset two of them.
+    if (minDecodedPxRowCount <= (2 * cellHeight)) {
+        return 0;
+    }
+    return minDecodedPxRowCount - 2 * cellHeight;
+}
+
+//------------------------------------------------------------------------------
+
+struct avifROPartialData
+{
+    avifROData available;
+    size_t fullSize;
+};
+
+// Implementation of avifIOReadFunc simulating a stream from an array. See avifIOReadFunc documentation.
+// io->data is expected to point to avifROPartialData.
+avifResult avifIOPartialRead(struct avifIO * io, uint32_t readFlags, uint64_t offset, size_t size, avifROData * out)
+{
+    const avifROPartialData * data = (avifROPartialData *)io->data;
+    if ((readFlags != 0) || !data || (data->fullSize < offset)) {
+        return AVIF_RESULT_IO_ERROR;
+    }
+    if (data->fullSize < (offset + size)) {
+        size = data->fullSize - offset;
+    }
+    if (data->available.size < (offset + size)) {
+        return AVIF_RESULT_WAITING_ON_IO;
+    }
+    out->data = data->available.data + offset;
+    out->size = size;
+    return AVIF_RESULT_OK;
+}
+
+//------------------------------------------------------------------------------
+
+// Encodes the image as a grid of at most gridCols*gridRows cells.
+// The cell count is reduced to fit libavif or AVIF format constraints. If impossible, the encoded output is returned empty.
+// The final cellWidth and cellHeight are output.
+void encodeAsGrid(const avifImage & image, uint32_t gridCols, uint32_t gridRows, avifRWData * output, uint32_t * cellWidth, uint32_t * cellHeight)
+{
+    // Chroma subsampling requires even dimensions. See ISO 23000-22 - 7.3.11.4.2
+    const bool needEvenWidths = ((image.yuvFormat == AVIF_PIXEL_FORMAT_YUV420) || (image.yuvFormat == AVIF_PIXEL_FORMAT_YUV422));
+    const bool needEvenHeights = (image.yuvFormat == AVIF_PIXEL_FORMAT_YUV420);
+
+    ASSERT_GT(gridCols * gridRows, 0u);
+    *cellWidth = image.width / gridCols;
+    *cellHeight = image.height / gridRows;
+
+    // avifEncoderAddImageGrid() only accepts grids that evenly split the image into cells at least 64 pixels wide and tall.
+    while ((gridCols > 1) &&
+           (((*cellWidth * gridCols) != image.width) || (*cellWidth < 64) || (needEvenWidths && ((*cellWidth & 1) != 0)))) {
+        --gridCols;
+        *cellWidth = image.width / gridCols;
+    }
+    while ((gridRows > 1) &&
+           (((*cellHeight * gridRows) != image.height) || (*cellHeight < 64) || (needEvenHeights && ((*cellHeight & 1) != 0)))) {
+        --gridRows;
+        *cellHeight = image.height / gridRows;
+    }
+
+    std::vector<testutil::avifImagePtr> cellImages;
+    cellImages.reserve(gridCols * gridRows);
+    for (uint32_t row = 0, iCell = 0; row < gridRows; ++row) {
+        for (uint32_t col = 0; col < gridCols; ++col, ++iCell) {
+            avifCropRect cell;
+            cell.x = col * *cellWidth;
+            cell.y = row * *cellHeight;
+            cell.width = ((cell.x + *cellWidth) <= image.width) ? *cellWidth : (image.width - cell.x);
+            cell.height = ((cell.y + *cellHeight) <= image.height) ? *cellHeight : (image.height - cell.y);
+            cellImages.emplace_back(avifImageCreateEmpty(), avifImageDestroy);
+            ASSERT_NE(cellImages.back(), nullptr);
+            ASSERT_EQ(avifImageSetViewRect(cellImages.back().get(), &image, &cell), AVIF_RESULT_OK);
+        }
+    }
+
+    testutil::avifEncoderPtr encoder(avifEncoderCreate(), avifEncoderDestroy);
+    ASSERT_NE(encoder, nullptr);
+    encoder->speed = AVIF_SPEED_FASTEST;
+    std::vector<avifImage *> cellImagePtrs(cellImages.size()); // Just here to match libavif API.
+    for (size_t i = 0; i < cellImages.size(); ++i) {
+        cellImagePtrs[i] = cellImages[i].get();
+    }
+    ASSERT_EQ(avifEncoderAddImageGrid(encoder.get(), gridCols, gridRows, cellImagePtrs.data(), AVIF_ADD_IMAGE_FLAG_SINGLE), AVIF_RESULT_OK);
+    ASSERT_EQ(avifEncoderFinish(encoder.get(), output), AVIF_RESULT_OK);
+}
+
+// Encodes the image to be decoded incrementally.
+void encodeAsIncremental(const avifImage & image, bool flatCells, avifRWData * output, uint32_t * cellWidth, uint32_t * cellHeight)
+{
+    const uint32_t gridCols = image.width / 64; // 64px is the min cell width.
+    const uint32_t gridRows = flatCells ? 1 : (image.height / 64);
+    encodeAsGrid(image, (gridCols > 1) ? gridCols : 1, (gridRows > 1) ? gridRows : 1, output, cellWidth, cellHeight);
+}
+
+} // namespace
+
+void encodeRectAsIncremental(const avifImage & image,
+                             uint32_t width,
+                             uint32_t height,
+                             bool createAlphaIfNone,
+                             bool flatCells,
+                             avifRWData * output,
+                             uint32_t * cellWidth,
+                             uint32_t * cellHeight)
+{
+    avifImagePtr subImage(avifImageCreateEmpty(), avifImageDestroy);
+    ASSERT_NE(subImage, nullptr);
+    ASSERT_LE(width, image.width);
+    ASSERT_LE(height, image.height);
+    avifPixelFormatInfo info;
+    avifGetPixelFormatInfo(image.yuvFormat, &info);
+    const avifCropRect rect {
+        /*x=*/((image.width - width) / 2) & ~info.chromaShiftX, /*y=*/((image.height - height) / 2) & ~info.chromaShiftX, width, height
+    };
+    ASSERT_EQ(avifImageSetViewRect(subImage.get(), &image, &rect), AVIF_RESULT_OK);
+    if (createAlphaIfNone && !subImage->alphaPlane) {
+        ASSERT_NE(image.yuvPlanes[AVIF_CHAN_Y], nullptr) << "No luma plane to simulate an alpha plane";
+        subImage->alphaPlane = image.yuvPlanes[AVIF_CHAN_Y];
+        subImage->alphaRowBytes = image.yuvRowBytes[AVIF_CHAN_Y];
+        subImage->alphaPremultiplied = AVIF_FALSE;
+        subImage->imageOwnsAlphaPlane = AVIF_FALSE;
+    }
+    encodeAsIncremental(*subImage, flatCells, output, cellWidth, cellHeight);
+}
+
+//------------------------------------------------------------------------------
+
+void decodeIncrementally(const avifRWData & encodedAvif,
+                         bool isPersistent,
+                         bool giveSizeHint,
+                         bool useNthImageApi,
+                         const avifImage & reference,
+                         uint32_t cellHeight)
+{
+    // AVIF cells are at least 64 pixels tall.
+    if (cellHeight != reference.height) {
+        ASSERT_GE(cellHeight, 64u);
+    }
+
+    // Emulate a byte-by-byte stream.
+    avifROPartialData data = { /*available=*/ { encodedAvif.data, 0 }, /*fullSize=*/encodedAvif.size };
+    avifIO io = { /*destroy=*/nullptr, avifIOPartialRead,
+                  /*write=*/nullptr,   giveSizeHint ? encodedAvif.size : 0,
+                  isPersistent,        &data };
+
+    testutil::avifDecoderPtr decoder(avifDecoderCreate(), avifDecoderDestroy);
+    ASSERT_NE(decoder, nullptr);
+    avifDecoderSetIO(decoder.get(), &io);
+    decoder->allowIncremental = AVIF_TRUE;
+
+    // Parsing is not incremental.
+    avifResult parseResult = avifDecoderParse(decoder.get());
+    while (parseResult == AVIF_RESULT_WAITING_ON_IO) {
+        ASSERT_LT(data.available.size, data.fullSize) << "avifDecoderParse() returned WAITING_ON_IO instead of OK";
+        data.available.size = data.available.size + 1;
+        parseResult = avifDecoderParse(decoder.get());
+    }
+    ASSERT_EQ(parseResult, AVIF_RESULT_OK);
+
+    // Decoding is incremental.
+    uint32_t previouslyDecodedRowCount = 0;
+    avifResult nextImageResult = useNthImageApi ? avifDecoderNthImage(decoder.get(), 0) : avifDecoderNextImage(decoder.get());
+    while (nextImageResult == AVIF_RESULT_WAITING_ON_IO) {
+        ASSERT_LT(data.available.size, data.fullSize)
+            << (useNthImageApi ? "avifDecoderNthImage(0)" : "avifDecoderNextImage()") << " returned WAITING_ON_IO instead of OK";
+        const uint32_t decodedRowCount = avifDecoderDecodedRowCount(decoder.get());
+        ASSERT_GE(decodedRowCount, previouslyDecodedRowCount);
+        const uint32_t minDecodedRowCount =
+            getMinDecodedRowCount(reference.height, cellHeight, reference.alphaPlane != nullptr, data.available.size, data.fullSize);
+        ASSERT_GE(decodedRowCount, minDecodedRowCount);
+        comparePartialYUVA(reference, *decoder->image, decodedRowCount);
+
+        previouslyDecodedRowCount = decodedRowCount;
+        data.available.size = data.available.size + 1;
+        nextImageResult = useNthImageApi ? avifDecoderNthImage(decoder.get(), 0) : avifDecoderNextImage(decoder.get());
+    }
+    ASSERT_EQ(nextImageResult, AVIF_RESULT_OK);
+    ASSERT_EQ(data.available.size, data.fullSize);
+    ASSERT_EQ(avifDecoderDecodedRowCount(decoder.get()), decoder->image->height);
+
+    comparePartialYUVA(reference, *decoder->image, reference.height);
+}
+
+void decodeNonIncrementallyAndIncrementally(const avifRWData & encodedAvif, bool isPersistent, bool giveSizeHint, bool useNthImageApi, uint32_t cellHeight)
+{
+    avifImagePtr reference(avifImageCreateEmpty(), avifImageDestroy);
+    ASSERT_NE(reference, nullptr);
+    testutil::avifDecoderPtr decoder(avifDecoderCreate(), avifDecoderDestroy);
+    ASSERT_NE(decoder, nullptr);
+    ASSERT_EQ(avifDecoderReadMemory(decoder.get(), reference.get(), encodedAvif.data, encodedAvif.size), AVIF_RESULT_OK);
+
+    decodeIncrementally(encodedAvif, isPersistent, giveSizeHint, useNthImageApi, *reference, cellHeight);
+}
+
+//------------------------------------------------------------------------------
+
+} // namespace testutil
+} // namespace libavif
diff --git a/tests/gtest/avifincrtest_helpers.h b/tests/gtest/avifincrtest_helpers.h
index 82e4061..e0f9986 100644
--- a/tests/gtest/avifincrtest_helpers.h
+++ b/tests/gtest/avifincrtest_helpers.h
@@ -6,44 +6,41 @@
 
 #include "avif/avif.h"
 
-#ifdef __cplusplus
-extern "C" {
-#endif
+namespace libavif
+{
+namespace testutil
+{
 
 // Encodes a portion of the image to be decoded incrementally.
-avifBool encodeRectAsIncremental(const avifImage * image,
-                                 uint32_t width,
-                                 uint32_t height,
-                                 avifBool createAlphaIfNone,
-                                 avifBool flatCells,
-                                 avifRWData * output,
-                                 uint32_t * cellWidth,
-                                 uint32_t * cellHeight);
-
-// Decodes the data into an image.
-avifBool decodeNonIncrementally(const avifRWData * encodedAvif, avifImage * image);
+void encodeRectAsIncremental(const avifImage & image,
+                             uint32_t width,
+                             uint32_t height,
+                             bool createAlphaIfNone,
+                             bool flatCells,
+                             avifRWData * output,
+                             uint32_t * cellWidth,
+                             uint32_t * cellHeight);
 
 // Decodes incrementally the encodedAvif and compares the pixels with the given reference.
 // If isPersistent is true, the input encodedAvif is considered as accessible during the whole decoding.
 // If giveSizeHint is true, the whole encodedAvif size is given as a hint to the decoder.
 // useNthImageApi describes whether the NthImage or NextImage decoder API will be used.
 // The cellHeight of all planes of the encodedAvif is given to estimate the incremental granularity.
-avifBool decodeIncrementally(const avifRWData * encodedAvif,
-                             avifBool isPersistent,
-                             avifBool giveSizeHint,
-                             avifBool useNthImageApi,
-                             const avifImage * reference,
-                             uint32_t cellHeight);
+void decodeIncrementally(const avifRWData & encodedAvif,
+                         bool isPersistent,
+                         bool giveSizeHint,
+                         bool useNthImageApi,
+                         const avifImage & reference,
+                         uint32_t cellHeight);
 
-// Calls decodeIncrementally() with the output of decodeNonIncrementally() as reference.
-avifBool decodeNonIncrementallyAndIncrementally(const avifRWData * encodedAvif,
-                                                avifBool isPersistent,
-                                                avifBool giveSizeHint,
-                                                avifBool useNthImageApi,
-                                                uint32_t cellHeight);
+// Calls decodeIncrementally() with the reference being a regular decoding of encodedAvif.
+void decodeNonIncrementallyAndIncrementally(const avifRWData & encodedAvif,
+                                            bool isPersistent,
+                                            bool giveSizeHint,
+                                            bool useNthImageApi,
+                                            uint32_t cellHeight);
 
-#ifdef __cplusplus
-} // extern "C"
-#endif
+} // namespace testutil
+} // namespace libavif
 
 #endif // LIBAVIF_TESTS_AVIFINCRTEST_HELPERS_H_