blender-archive/source/blender/blenlib/tests/BLI_string_utf8_test.cc

/* SPDX-License-Identifier: Apache-2.0 */

#include "testing/testing.h"

#include "BLI_rand.h"
#include "BLI_string.h"
#include "BLI_string_cursor_utf8.h"
#include "BLI_string_utf8.h"
#include "BLI_utildefines.h"

/* Note that 'common' utf-8 variants of string functions (like copy, etc.) are tested in
 * BLI_string_test.cc However, tests below are specific utf-8 conformance ones, and since they eat
 * quite their share of lines, they deserved their own file. */

/* -------------------------------------------------------------------- */
/** \name Test #BLI_str_utf8_invalid_strip
 * \{ */

/* Breaking strings is confusing here, prefer over-long lines. */
/* clang-format off */

/* Each test is made of a 79 bytes (80 with NULL char) string to test, expected string result after
 * stripping invalid utf8 bytes, and a single-byte string encoded with expected number of errors.
 *
 * Based on utf-8 decoder stress-test (https://www.cl.cam.ac.uk/~mgk25/ucs/examples/UTF-8-test.txt)
 *     by Markus Kuhn <http://www.cl.cam.ac.uk/~mgk25/> - 2015-08-28 - CC BY 4.0
 */
static const char *utf8_invalid_tests[][3] = {
/*    1  Some correct UTF-8 text. */
    {"You should see the Greek word 'kosme':       \"\xce\xba\xe1\xbd\xb9\xcf\x83\xce\xbc\xce\xb5\"                    |",
     "You should see the Greek word 'kosme':       \"\xce\xba\xe1\xbd\xb9\xcf\x83\xce\xbc\xce\xb5\"                    |", "\x00"},

/*    2  Boundary condition test cases
 *    Note that those will pass for us, those are not erronéous unicode code points
 *    (aside from \x00, which is only valid as string terminator).
 *    2.1  First possible sequence of a certain length */
    {"2.1.1  1 byte  (U-00000000):        \"\x00\"                                       |",
     "2.1.1  1 byte  (U-00000000):        \"\"                                       |", "\x01"},
    {"2.1.2  2 bytes (U-00000080):        \"\xc2\x80\"                                      |",
     "2.1.2  2 bytes (U-00000080):        \"\xc2\x80\"                                      |", "\x00"},
    {"2.1.3  3 bytes (U-00000800):        \"\xe0\xa0\x80\"                                     |",
     "2.1.3  3 bytes (U-00000800):        \"\xe0\xa0\x80\"                                     |", "\x00"},
    {"2.1.4  4 bytes (U-00010000):        \"\xf0\x90\x80\x80\"                                    |",
     "2.1.4  4 bytes (U-00010000):        \"\xf0\x90\x80\x80\"                                    |", "\x00"},
    {"2.1.5  5 bytes (U-00200000):        \"\xf8\x88\x80\x80\x80\"                                   |",
     "2.1.5  5 bytes (U-00200000):        \"\xf8\x88\x80\x80\x80\"                                   |", "\x00"},
    {"2.1.6  6 bytes (U-04000000):        \"\xfc\x84\x80\x80\x80\x80\"                                  |",
     "2.1.6  6 bytes (U-04000000):        \"\xfc\x84\x80\x80\x80\x80\"                                  |", "\x00"},
/*    2.2  Last possible sequence of a certain length */
    {"2.2.1  1 byte  (U-0000007F):        \"\x7f\"                                       |",
     "2.2.1  1 byte  (U-0000007F):        \"\x7f\"                                       |", "\x00"},
    {"2.2.2  2 bytes (U-000007FF):        \"\xdf\xbf\"                                      |",
     "2.2.2  2 bytes (U-000007FF):        \"\xdf\xbf\"                                      |", "\x00"},
    {"2.2.3  3 bytes (U-0000FFFF):        \"\xef\xbf\xbf\"                                     |",
     "2.2.3  3 bytes (U-0000FFFF):        \"\"                                     |", "\x03"},  /* matches one of 5.3 sequences... */
    {"2.2.4  4 bytes (U-001FFFFF):        \"\xf7\xbf\xbf\xbf\"                                    |",
     "2.2.4  4 bytes (U-001FFFFF):        \"\xf7\xbf\xbf\xbf\"                                    |", "\x00"},
    {"2.2.5  5 bytes (U-03FFFFFF):        \"\xfb\xbf\xbf\xbf\xbf\"                                   |",
     "2.2.5  5 bytes (U-03FFFFFF):        \"\xfb\xbf\xbf\xbf\xbf\"                                   |", "\x00"},
    {"2.2.6  6 bytes (U-7FFFFFFF):        \"\xfd\xbf\xbf\xbf\xbf\xbf\"                                  |",
     "2.2.6  6 bytes (U-7FFFFFFF):        \"\xfd\xbf\xbf\xbf\xbf\xbf\"                                  |", "\x00"},
/*    2.3  Other boundary conditions */
    {"2.3.1  U-0000D7FF = ed 9f bf = \"\xed\x9f\xbf\"                                          |",
     "2.3.1  U-0000D7FF = ed 9f bf = \"\xed\x9f\xbf\"                                          |", "\x00"},
    {"2.3.2  U-0000E000 = ee 80 80 = \"\xee\x80\x80\"                                          |",
     "2.3.2  U-0000E000 = ee 80 80 = \"\xee\x80\x80\"                                          |", "\x00"},
    {"2.3.3  U-0000FFFD = ef bf bd = \"\xef\xbf\xbd\"                                          |",
     "2.3.3  U-0000FFFD = ef bf bd = \"\xef\xbf\xbd\"                                          |", "\x00"},
    {"2.3.4  U-0010FFFF = f4 8f bf bf = \"\xf4\x8f\xbf\xbf\"                                      |",
     "2.3.4  U-0010FFFF = f4 8f bf bf = \"\xf4\x8f\xbf\xbf\"                                      |", "\x00"},
    {"2.3.5  U-00110000 = f4 90 80 80 = \"\xf4\x90\x80\x80\"                                      |",
     "2.3.5  U-00110000 = f4 90 80 80 = \"\xf4\x90\x80\x80\"                                      |", "\x00"},

/*    3  Malformed sequences
 *    3.1  Unexpected continuation bytes
 *         Each unexpected continuation byte should be separately signaled as a malformed sequence of its own. */
    {"3.1.1  First continuation byte 0x80: \"\x80\"                                      |",
     "3.1.1  First continuation byte 0x80: \"\"                                      |", "\x01"},
    {"3.1.2  Last  continuation byte 0xbf: \"\xbf\"                                      |",
     "3.1.2  Last  continuation byte 0xbf: \"\"                                      |", "\x01"},
    {"3.1.3  2 continuation bytes: \"\x80\xbf\"                                             |",
     "3.1.3  2 continuation bytes: \"\"                                             |", "\x02"},
    {"3.1.4  3 continuation bytes: \"\x80\xbf\x80\"                                            |",
     "3.1.4  3 continuation bytes: \"\"                                            |", "\x03"},
    {"3.1.5  4 continuation bytes: \"\x80\xbf\x80\xbf\"                                           |",
     "3.1.5  4 continuation bytes: \"\"                                           |", "\x04"},
    {"3.1.6  5 continuation bytes: \"\x80\xbf\x80\xbf\x80\"                                          |",
     "3.1.6  5 continuation bytes: \"\"                                          |", "\x05"},
    {"3.1.7  6 continuation bytes: \"\x80\xbf\x80\xbf\x80\xbf\"                                         |",
     "3.1.7  6 continuation bytes: \"\"                                         |", "\x06"},
    {"3.1.8  7 continuation bytes: \"\x80\xbf\x80\xbf\x80\xbf\x80\"                                        |",
     "3.1.8  7 continuation bytes: \"\"                                        |", "\x07"},
/*    3.1.9  Sequence of all 64 possible continuation bytes (0x80-0xbf):            | */
    {"3.1.9      \"\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f"
                  "\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9a\x9b\x9c\x9d\x9e\x9f"
                  "\xa0\xa1\xa2\xa3\xa4\xa5\xa6\xa7\xa8\xa9\xaa\xab\xac\xad\xae\xaf"
                  "\xb0\xb1\xb2\xb3\xb4\xb5\xb6\xb7\xb8\xb9\xba\xbb\xbc\xbd\xbe\xbf\" |",
     "3.1.9      \"\" |", "\x40"}, /* NOLINT: modernize-raw-string-literal. */
/*    3.2  Lonely start characters
 *    3.2.1  All 32 first bytes of 2-byte sequences (0xc0-0xdf), each followed by a space character: */
    {"3.2.1      \"\xc0 \xc1 \xc2 \xc3 \xc4 \xc5 \xc6 \xc7 \xc8 \xc9 \xca \xcb \xcc \xcd \xce \xcf "
                  "\xd0 \xd1 \xd2 \xd3 \xd4 \xd5 \xd6 \xd7 \xd8 \xd9 \xda \xdb \xdc \xdd \xde \xdf \" |",
     "3.2.1      \"                                \" |", "\x20"}, /* NOLINT: modernize-raw-string-literal. */
/*    3.2.2  All 16 first bytes of 3-byte sequences (0xe0-0xef), each followed by a space character: */
    {"3.2.2      \"\xe0 \xe1 \xe2 \xe3 \xe4 \xe5 \xe6 \xe7 \xe8 \xe9 \xea \xeb \xec \xed \xee \xef \"                                 |",
     "3.2.2      \"                \"                                 |", "\x10"},
/*    3.2.3  All 8 first bytes of 4-byte sequences (0xf0-0xf7), each followed by a space character: */
    {"3.2.3      \"\xf0 \xf1 \xf2 \xf3 \xf4 \xf5 \xf6 \xf7 \"                                                 |",
     "3.2.3      \"        \"                                                 |", "\x08"},
/*    3.2.4  All 4 first bytes of 5-byte sequences (0xf8-0xfb), each followed by a space character: */
    {"3.2.4      \"\xf8 \xf9 \xfa \xfb \"                                                         |",
     "3.2.4      \"    \"                                                         |", "\x04"},
/*    3.2.5  All 2 first bytes of 6-byte sequences (0xfc-0xfd), each followed by a space character: */
    {"3.2.4      \"\xfc \xfd \"                                                             |",
     "3.2.4      \"  \"                                                             |", "\x02"},
/*    3.3  Sequences with last continuation byte missing
 *         All bytes of an incomplete sequence should be signaled as a single malformed sequence,
 *         i.e., you should see only a single replacement character in each of the next 10 tests.
 *         (Characters as in section 2) */
    {"3.3.1  2-byte sequence with last byte missing (U+0000):     \"\xc0\"               |",
     "3.3.1  2-byte sequence with last byte missing (U+0000):     \"\"               |", "\x01"},
    {"3.3.2  3-byte sequence with last byte missing (U+0000):     \"\xe0\x80\"              |",
     "3.3.2  3-byte sequence with last byte missing (U+0000):     \"\"              |", "\x02"},
    {"3.3.3  4-byte sequence with last byte missing (U+0000):     \"\xf0\x80\x80\"             |",
     "3.3.3  4-byte sequence with last byte missing (U+0000):     \"\"             |", "\x03"},
    {"3.3.4  5-byte sequence with last byte missing (U+0000):     \"\xf8\x80\x80\x80\"            |",
     "3.3.4  5-byte sequence with last byte missing (U+0000):     \"\"            |", "\x04"},
    {"3.3.5  6-byte sequence with last byte missing (U+0000):     \"\xfc\x80\x80\x80\x80\"           |",
     "3.3.5  6-byte sequence with last byte missing (U+0000):     \"\"           |", "\x05"},
    {"3.3.6  2-byte sequence with last byte missing (U-000007FF): \"\xdf\"               |",
     "3.3.6  2-byte sequence with last byte missing (U-000007FF): \"\"               |", "\x01"},
    {"3.3.7  3-byte sequence with last byte missing (U-0000FFFF): \"\xef\xbf\"              |",
     "3.3.7  3-byte sequence with last byte missing (U-0000FFFF): \"\"              |", "\x02"},
    {"3.3.8  4-byte sequence with last byte missing (U-001FFFFF): \"\xf7\xbf\xbf\"             |",
     "3.3.8  4-byte sequence with last byte missing (U-001FFFFF): \"\"             |", "\x03"},
    {"3.3.9  5-byte sequence with last byte missing (U-03FFFFFF): \"\xfb\xbf\xbf\xbf\"            |",
     "3.3.9  5-byte sequence with last byte missing (U-03FFFFFF): \"\"            |", "\x04"},
    {"3.3.10 6-byte sequence with last byte missing (U-7FFFFFFF): \"\xfd\xbf\xbf\xbf\xbf\"           |",
     "3.3.10 6-byte sequence with last byte missing (U-7FFFFFFF): \"\"           |", "\x05"},
/*    3.4  Concatenation of incomplete sequences
 *         All the 10 sequences of 3.3 concatenated, you should see 10 malformed sequences being signaled: */
    {"3.4      \"\xc0\xe0\x80\xf0\x80\x80\xf8\x80\x80\x80\xfc\x80\x80\x80\x80"
                "\xdf\xef\xbf\xf7\xbf\xbf\xfb\xbf\xbf\xbf\xfd\xbf\xbf\xbf\xbf\""
                "                                     |",
     "3.4      \"\"                                     |", "\x1e"},
/*    3.5  Impossible bytes
 *         The following two bytes cannot appear in a correct UTF-8 string */
    {"3.5.1  fe = \"\xfe\"                                                               |",
     "3.5.1  fe = \"\"                                                               |", "\x01"},
    {"3.5.2  ff = \"\xff\"                                                               |",
     "3.5.2  ff = \"\"                                                               |", "\x01"},
    {"3.5.3  fe fe ff ff = \"\xfe\xfe\xff\xff\"                                                   |",
     "3.5.3  fe fe ff ff = \"\"                                                   |", "\x04"},

/*    4  Overlong sequences
 *       The following sequences are not malformed according to the letter of the Unicode 2.0 standard.
 *       However, they are longer then necessary and a correct UTF-8 encoder is not allowed to produce them.
 *       A "safe UTF-8 decoder" should reject them just like malformed sequences for two reasons:
 *       (1) It helps to debug applications if overlong sequences are not treated as valid representations
 *       of characters, because this helps to spot problems more quickly. (2) Overlong sequences provide
 *       alternative representations of characters, that could maliciously be used to bypass filters that check
 *       only for ASCII characters. For instance, a 2-byte encoded line feed (LF) would not be caught by a
 *       line counter that counts only 0x0a bytes, but it would still be processed as a line feed by an unsafe
 *       UTF-8 decoder later in the pipeline. From a security point of view, ASCII compatibility of UTF-8
 *       sequences means also, that ASCII characters are *only* allowed to be represented by ASCII bytes
 *       in the range 0x00-0x7f. To ensure this aspect of ASCII compatibility, use only "safe UTF-8 decoders"
 *       that reject overlong UTF-8 sequences for which a shorter encoding exists.
 *
 *    4.1  Examples of an overlong ASCII character
 *         With a safe UTF-8 decoder, all of the following five overlong representations of the ASCII character
 *         slash ("/") should be rejected like a malformed UTF-8 sequence, for instance by substituting it with
 *         a replacement character. If you see a slash below, you do not have a safe UTF-8 decoder! */
    {"4.1.1  U+002F     = c0 af             = \"\xc0\xaf\"                                  |",
     "4.1.1  U+002F     = c0 af             = \"\"                                  |", "\x02"},
    {"4.1.2  U+002F     = e0 80 af          = \"\xe0\x80\xaf\"                                 |",
     "4.1.2  U+002F     = e0 80 af          = \"\"                                 |", "\x03"},
    {"4.1.3  U+002F     = f0 80 80 af       = \"\xf0\x80\x80\xaf\"                                |",
     "4.1.3  U+002F     = f0 80 80 af       = \"\"                                |", "\x04"},
    {"4.1.4  U+002F     = f8 80 80 80 af    = \"\xf8\x80\x80\x80\xaf\"                               |",
     "4.1.4  U+002F     = f8 80 80 80 af    = \"\"                               |", "\x05"},
    {"4.1.5  U+002F     = fc 80 80 80 80 af = \"\xfc\x80\x80\x80\x80\xaf\"                              |",
     "4.1.5  U+002F     = fc 80 80 80 80 af = \"\"                              |", "\x06"},
/*    4.2  Maximum overlong sequences
 *         Below you see the highest Unicode value that is still resulting in an overlong sequence if represented
 *         with the given number of bytes. This is a boundary test for safe UTF-8 decoders. All five characters
 *         should be rejected like malformed UTF-8 sequences. */
    {"4.2.1  U-0000007F = c1 bf             = \"\xc1\xbf\"                                  |",
     "4.2.1  U-0000007F = c1 bf             = \"\"                                  |", "\x02"},
    {"4.2.2  U-000007FF = e0 9f bf          = \"\xe0\x9f\xbf\"                                 |",
     "4.2.2  U-000007FF = e0 9f bf          = \"\"                                 |", "\x03"},
    {"4.2.3  U-0000FFFF = f0 8f bf bf       = \"\xf0\x8f\xbf\xbf\"                                |",
     "4.2.3  U-0000FFFF = f0 8f bf bf       = \"\"                                |", "\x04"},
    {"4.2.4  U-001FFFFF = f8 87 bf bf bf    = \"\xf8\x87\xbf\xbf\xbf\"                               |",
     "4.2.4  U-001FFFFF = f8 87 bf bf bf    = \"\"                               |", "\x05"},
    {"4.2.5  U+0000     = fc 83 bf bf bf bf = \"\xfc\x83\xbf\xbf\xbf\xbf\"                              |",
     "4.2.5  U+0000     = fc 83 bf bf bf bf = \"\"                              |", "\x06"},
/*    4.3  Overlong representation of the NUL character
 *         The following five sequences should also be rejected like malformed UTF-8 sequences and should not be
 *         treated like the ASCII NUL character. */
    {"4.3.1  U+0000     = c0 80             = \"\xc0\x80\"                                  |",
     "4.3.1  U+0000     = c0 80             = \"\"                                  |", "\x02"},
    {"4.3.2  U+0000     = e0 80 80          = \"\xe0\x80\x80\"                                 |",
     "4.3.2  U+0000     = e0 80 80          = \"\"                                 |", "\x03"},
    {"4.3.3  U+0000     = f0 80 80 80       = \"\xf0\x80\x80\x80\"                                |",
     "4.3.3  U+0000     = f0 80 80 80       = \"\"                                |", "\x04"},
    {"4.3.4  U+0000     = f8 80 80 80 80    = \"\xf8\x80\x80\x80\x80\"                               |",
     "4.3.4  U+0000     = f8 80 80 80 80    = \"\"                               |", "\x05"},
    {"4.3.5  U+0000     = fc 80 80 80 80 80 = \"\xfc\x80\x80\x80\x80\x80\"                              |",
     "4.3.5  U+0000     = fc 80 80 80 80 80 = \"\"                              |", "\x06"},

/*    5  Illegal code positions
 *       The following UTF-8 sequences should be rejected like malformed sequences, because they never represent
 *       valid ISO 10646 characters and a UTF-8 decoder that accepts them might introduce security problems
 *       comparable to overlong UTF-8 sequences.
 *    5.1 Single UTF-16 surrogates */
    {"5.1.1  U+D800 = ed a0 80 = \"\xed\xa0\x80\"                                              |",
     "5.1.1  U+D800 = ed a0 80 = \"\"                                              |", "\x03"},
    {"5.1.2  U+DB7F = ed ad bf = \"\xed\xad\xbf\"                                              |",
     "5.1.2  U+DB7F = ed ad bf = \"\"                                              |", "\x03"},
    {"5.1.3  U+DB80 = ed ae 80 = \"\xed\xae\x80\"                                              |",
     "5.1.3  U+DB80 = ed ae 80 = \"\"                                              |", "\x03"},
    {"5.1.4  U+DBFF = ed af bf = \"\xed\xaf\xbf\"                                              |",
     "5.1.4  U+DBFF = ed af bf = \"\"                                              |", "\x03"},
    {"5.1.5  U+DC00 = ed b0 80 = \"\xed\xb0\x80\"                                              |",
     "5.1.5  U+DC00 = ed b0 80 = \"\"                                              |", "\x03"},
    {"5.1.6  U+DF80 = ed be 80 = \"\xed\xbe\x80\"                                              |",
     "5.1.6  U+DF80 = ed be 80 = \"\"                                              |", "\x03"},
    {"5.1.7  U+DFFF = ed bf bf = \"\xed\xbf\xbf\"                                              |",
     "5.1.7  U+DFFF = ed bf bf = \"\"                                              |", "\x03"},
/*    5.2 Paired UTF-16 surrogates */
    {"5.2.1  U+D800 U+DC00 = ed a0 80 ed b0 80 = \"\xed\xa0\x80\xed\xb0\x80\"                           |",
     "5.2.1  U+D800 U+DC00 = ed a0 80 ed b0 80 = \"\"                           |", "\x06"},
    {"5.2.2  U+D800 U+DFFF = ed a0 80 ed bf bf = \"\xed\xa0\x80\xed\xbf\xbf\"                           |",
     "5.2.2  U+D800 U+DFFF = ed a0 80 ed bf bf = \"\"                           |", "\x06"},
    {"5.2.3  U+DB7F U+DC00 = ed ad bf ed b0 80 = \"\xed\xad\xbf\xed\xb0\x80\"                           |",
     "5.2.3  U+DB7F U+DC00 = ed ad bf ed b0 80 = \"\"                           |", "\x06"},
    {"5.2.4  U+DB7F U+DFFF = ed ad bf ed bf bf = \"\xed\xad\xbf\xed\xbf\xbf\"                           |",
     "5.2.4  U+DB7F U+DFFF = ed ad bf ed bf bf = \"\"                           |", "\x06"},
    {"5.2.5  U+DB80 U+DC00 = ed ae 80 ed b0 80 = \"\xed\xae\x80\xed\xb0\x80\"                           |",
     "5.2.5  U+DB80 U+DC00 = ed ae 80 ed b0 80 = \"\"                           |", "\x06"},
    {"5.2.6  U+DB80 U+DFFF = ed ae 80 ed bf bf = \"\xed\xae\x80\xed\xbf\xbf\"                           |",
     "5.2.6  U+DB80 U+DFFF = ed ae 80 ed bf bf = \"\"                           |", "\x06"},
    {"5.2.7  U+DBFF U+DC00 = ed af bf ed b0 80 = \"\xed\xaf\xbf\xed\xb0\x80\"                           |",
     "5.2.7  U+DBFF U+DC00 = ed af bf ed b0 80 = \"\"                           |", "\x06"},
    {"5.2.8  U+DBFF U+DFFF = ed af bf ed bf bf = \"\xed\xaf\xbf\xed\xbf\xbf\"                           |",
     "5.2.8  U+DBFF U+DFFF = ed af bf ed bf bf = \"\"                           |", "\x06"},
/*    5.3 Non-character code positions
 *        The following "non-characters" are "reserved for internal use" by applications, and according to older versions
 *        of the Unicode Standard "should never be interchanged". Unicode Corrigendum #9 dropped the latter restriction.
 *        Nevertheless, their presence in incoming UTF-8 data can remain a potential security risk, depending
 *        on what use is made of these codes subsequently. Examples of such internal use:
 *          - Some file APIs with 16-bit characters may use the integer value -1 = U+FFFF to signal
 *            an end-of-file (EOF) or error condition.
 *          - In some UTF-16 receivers, code point U+FFFE might trigger a byte-swap operation
 *            (to convert between UTF-16LE and UTF-16BE).
 *        With such internal use of non-characters, it may be desirable and safer to block those code points in
 *        UTF-8 decoders, as they should never occur legitimately in incoming UTF-8 data, and could trigger
 *        unsafe behavior in subsequent processing.
 *
 *        Particularly problematic non-characters in 16-bit applications: */
    {"5.3.1  U+FFFE = ef bf be = \"\xef\xbf\xbe\"                                              |",
     "5.3.1  U+FFFE = ef bf be = \"\"                                              |", "\x03"},
    {"5.3.2  U+FFFF = ef bf bf = \"\xef\xbf\xbf\"                                              |",
     "5.3.2  U+FFFF = ef bf bf = \"\"                                              |", "\x03"},
    /* For now, we ignore those, they do not seem to be crucial anyway... */
/*    5.3.3  U+FDD0 .. U+FDEF
 *    5.3.4  U+nFFFE U+nFFFF (for n = 1..10) */
    {nullptr, nullptr, nullptr},
};
/* clang-format on */

/* BLI_str_utf8_invalid_strip (and indirectly, BLI_str_utf8_invalid_byte). */
TEST(string, Utf8InvalidBytes)
{
  for (int i = 0; utf8_invalid_tests[i][0] != nullptr; i++) {
    const char *tst = utf8_invalid_tests[i][0];
    const char *tst_stripped = utf8_invalid_tests[i][1];
    const int errors_num = int(utf8_invalid_tests[i][2][0]);

    char buff[80];
    memcpy(buff, tst, sizeof(buff));

    const int errors_found_num = BLI_str_utf8_invalid_strip(buff, sizeof(buff) - 1);

    printf("[%02d] -> [%02d] \"%s\"  ->  \"%s\"\n", errors_num, errors_found_num, tst, buff);
    EXPECT_EQ(errors_found_num, errors_num);
    EXPECT_STREQ(buff, tst_stripped);
  }
}

/** \} */

/* -------------------------------------------------------------------- */
/** \name Test #BLI_str_utf8_as_unicode_step
 * \{ */

static size_t utf8_as_char32(const char *str, const char str_len, char32_t *r_result)
{
  size_t i = 0, result_len = 0;
  while ((i < str_len) && (str[i] != '\0')) {
    char32_t c = BLI_str_utf8_as_unicode_step(str, str_len, &i);
    if (c != BLI_UTF8_ERR) {
      r_result[result_len++] = c;
    }
  }
  return i;
}

template<size_t Size, size_t SizeWithPadding>
void utf8_as_char32_test_compare_with_pad_bytes(const char utf8_src[Size])
{
  char utf8_src_with_pad[SizeWithPadding] = {0};

  memcpy(utf8_src_with_pad, utf8_src, Size);

  char32_t unicode_dst_a[Size], unicode_dst_b[Size];

  memset(unicode_dst_a, 0xff, sizeof(unicode_dst_a));
  const size_t index_a = utf8_as_char32(utf8_src, Size, unicode_dst_a);

  /* Test with padded and un-padded size,
   * to ensure that extra available space doesn't yield a different result. */
  for (int pass = 0; pass < 2; pass++) {
    memset(unicode_dst_b, 0xff, sizeof(unicode_dst_b));
    const size_t index_b = utf8_as_char32(
        utf8_src_with_pad, pass ? Size : SizeWithPadding, unicode_dst_b);

    /* Check the resulting content matches. */
    EXPECT_EQ_ARRAY(unicode_dst_a, unicode_dst_b, Size);
    /* Check the index of the source strings match. */
    EXPECT_EQ(index_a, index_b);
  }
}

template<size_t Size> void utf8_as_char32_test_compare(const char utf8_src[Size])
{
  /* Note that 7 is a little arbitrary,
   * chosen since it's the maximum length of multi-byte character + 1
   * to account for any errors that read past null bytes. */
  utf8_as_char32_test_compare_with_pad_bytes<Size, Size + 1>(utf8_src);
  utf8_as_char32_test_compare_with_pad_bytes<Size, Size + 7>(utf8_src);
}

template<size_t Size> void utf8_as_char32_test_at_buffer_size()
{
  char utf8_src[Size];

  /* Test uniform bytes, also with offsets ascending & descending. */
  for (int i = 0; i <= 0xff; i++) {
    memset(utf8_src, i, sizeof(utf8_src));
    utf8_as_char32_test_compare<Size>(utf8_src);

    /* Offset trailing bytes up and down in steps of 1, 2, 4 .. etc. */
    if (Size > 1) {
      for (int mul = 1; mul < 256; mul *= 2) {
        for (int ofs = 1; ofs < int(Size); ofs++) {
          utf8_src[ofs] = char(i + (ofs * mul));
        }
        utf8_as_char32_test_compare<Size>(utf8_src);

        for (int ofs = 1; ofs < int(Size); ofs++) {
          utf8_src[ofs] = char(i - (ofs * mul));
        }
        utf8_as_char32_test_compare<Size>(utf8_src);
      }
    }
  }

  /* Random bytes. */
  RNG *rng = BLI_rng_new(1);
  for (int i = 0; i < 256; i++) {
    BLI_rng_get_char_n(rng, utf8_src, sizeof(utf8_src));
    utf8_as_char32_test_compare<Size>(utf8_src);
  }
  BLI_rng_free(rng);
}

TEST(string, Utf8AsUnicodeStep)
{

  /* Run tests at different buffer sizes. */
  utf8_as_char32_test_at_buffer_size<1>();
  utf8_as_char32_test_at_buffer_size<2>();
  utf8_as_char32_test_at_buffer_size<3>();
  utf8_as_char32_test_at_buffer_size<4>();
  utf8_as_char32_test_at_buffer_size<5>();
  utf8_as_char32_test_at_buffer_size<6>();
  utf8_as_char32_test_at_buffer_size<7>();
  utf8_as_char32_test_at_buffer_size<8>();
  utf8_as_char32_test_at_buffer_size<9>();
  utf8_as_char32_test_at_buffer_size<10>();
  utf8_as_char32_test_at_buffer_size<11>();
  utf8_as_char32_test_at_buffer_size<12>();
}

/** \} */

/* -------------------------------------------------------------------- */
/** \name Test #BLI_str_cursor_step_next_utf32_empty
 * \{ */

TEST(string, StrCursorStepNextUtf32Empty)
{
  const char32_t empty[] = U"";
  const size_t len = 0;
  int pos = 0;
  EXPECT_FALSE(BLI_str_cursor_step_next_utf32(empty, len, &pos));
  pos = 1;
  EXPECT_FALSE(BLI_str_cursor_step_next_utf32(empty, len, &pos));
}

/* -------------------------------------------------------------------- */
/** \name Test #BLI_str_cursor_step_next_utf32_single
 * \{ */

TEST(string, StrCursorStepNextUtf32Single)

{
  const char32_t single[] = U"0";
  const size_t len = 1;
  int pos = 0;
  EXPECT_TRUE(BLI_str_cursor_step_next_utf32(single, len, &pos) && pos == 1);
  EXPECT_FALSE(BLI_str_cursor_step_next_utf32(single, len, &pos));
}

/* -------------------------------------------------------------------- */
/** \name Test #BLI_str_cursor_step_next_utf32_simple
 * \{ */

TEST(string, StrCursorStepNextUtf32Simple)
{
  const char32_t simple[] = U"012";
  const size_t len = 3;
  int pos = 0;
  EXPECT_TRUE(BLI_str_cursor_step_next_utf32(simple, len, &pos) && pos == 1);
  EXPECT_TRUE(BLI_str_cursor_step_next_utf32(simple, len, &pos) && pos == 2);
  EXPECT_FALSE(BLI_str_cursor_step_next_utf32(simple, len - 1, &pos));
  EXPECT_TRUE(BLI_str_cursor_step_next_utf32(simple, len, &pos) && pos == 3);
  EXPECT_FALSE(BLI_str_cursor_step_next_utf32(simple, len, &pos));
}

/* -------------------------------------------------------------------- */
/** \name Test #BLI_str_cursor_step_next_utf32_allcombining
 * \{ */

TEST(string, StrCursorStepNextUtf32AllCombining)
{
  const char32_t allcombining[] = U"\u0300\u0300\u0300";
  const size_t len = 3;
  int pos = 0;
  EXPECT_TRUE(BLI_str_cursor_step_next_utf32(allcombining, len, &pos) && pos == 3);
  pos = 1;
  EXPECT_TRUE(BLI_str_cursor_step_next_utf32(allcombining, len, &pos) && pos == 3);
  pos = 2;
  EXPECT_TRUE(BLI_str_cursor_step_next_utf32(allcombining, len, &pos) && pos == 3);
  pos = 3;
  EXPECT_FALSE(BLI_str_cursor_step_next_utf32(allcombining, len, &pos));
}

/* -------------------------------------------------------------------- */
/** \name Test #BLI_str_cursor_step_next_utf32_complex
 * \{ */

TEST(string, StrCursorStepNextUtf32Complex)
{
  /* Combining character, "A", two combining characters, "B". */
  const char32_t complex[] = U"\u0300\u0041\u0300\u0320\u0042";
  const size_t len = 5;
  int pos = 0;
  EXPECT_TRUE(BLI_str_cursor_step_next_utf32(complex, len, &pos) && pos == 1);
  pos = 1;
  EXPECT_TRUE(BLI_str_cursor_step_next_utf32(complex, len, &pos) && pos == 4);
  pos = 2;
  EXPECT_TRUE(BLI_str_cursor_step_next_utf32(complex, len, &pos) && pos == 4);
  pos = 3;
  EXPECT_TRUE(BLI_str_cursor_step_next_utf32(complex, len, &pos) && pos == 4);
  pos = 4;
  EXPECT_TRUE(BLI_str_cursor_step_next_utf32(complex, len, &pos) && pos == 5);
  pos = 5;
  EXPECT_FALSE(BLI_str_cursor_step_next_utf32(complex, len, &pos));
}

/* -------------------------------------------------------------------- */
/** \name Test #BLI_str_cursor_step_next_utf32_invalid
 * \{ */

TEST(string, StrCursorStepNextUtf32Invalid)
{
  /* Latin1 "À", tab, carriage return, linefeed, separated by combining characters. */
  const char32_t invalid[] = U"\u00C0\u0300\u0009\u0300\u000D\u0300\u000A\u0300";
  const size_t len = 8;
  int pos = 0;
  EXPECT_TRUE(BLI_str_cursor_step_next_utf32(invalid, len, &pos) && pos == 2);
  pos = 1;
  EXPECT_TRUE(BLI_str_cursor_step_next_utf32(invalid, len, &pos) && pos == 2);
  pos = 2;
  EXPECT_TRUE(BLI_str_cursor_step_next_utf32(invalid, len, &pos) && pos == 4);
  pos = 3;
  EXPECT_TRUE(BLI_str_cursor_step_next_utf32(invalid, len, &pos) && pos == 4);
  pos = 4;
  EXPECT_TRUE(BLI_str_cursor_step_next_utf32(invalid, len, &pos) && pos == 6);
  pos = 5;
  EXPECT_TRUE(BLI_str_cursor_step_next_utf32(invalid, len, &pos) && pos == 6);
  pos = 6;
  EXPECT_TRUE(BLI_str_cursor_step_next_utf32(invalid, len, &pos) && pos == 8);
  pos = 7;
  EXPECT_TRUE(BLI_str_cursor_step_next_utf32(invalid, len, &pos) && pos == 8);
  pos = 8;
  EXPECT_FALSE(BLI_str_cursor_step_next_utf32(invalid, len, &pos));
}

/* -------------------------------------------------------------------- */
/** \name Test #BLI_str_cursor_step_prev_utf32_empty
 * \{ */

TEST(string, StrCursorStepPrevUtf32Empty)
{
  const char32_t emtpy[] = U"";
  const size_t len = 0;
  int pos = 0;
  EXPECT_FALSE(BLI_str_cursor_step_prev_utf32(emtpy, len, &pos));
}

/* -------------------------------------------------------------------- */
/** \name Test #BLI_str_cursor_step_prev_utf32_single
 * \{ */

TEST(string, StrCursorStepPrevUtf32Single)
{
  const char32_t single[] = U"0";
  const size_t len = 1;
  int pos = 1;
  EXPECT_TRUE(BLI_str_cursor_step_prev_utf32(single, len, &pos) && pos == 0);
  EXPECT_FALSE(BLI_str_cursor_step_prev_utf32(single, len, &pos));
}

/* -------------------------------------------------------------------- */
/** \name Test #BLI_str_cursor_step_prev_utf32_simple
 * \{ */

TEST(string, StrCursorStepPrevUtf32Simple)
{
  const char32_t simple[] = U"012";
  const size_t len = 3;
  int pos = 3;
  EXPECT_TRUE(BLI_str_cursor_step_prev_utf32(simple, len, &pos) && pos == 2);
  EXPECT_TRUE(BLI_str_cursor_step_prev_utf32(simple, len, &pos) && pos == 1);
  EXPECT_TRUE(BLI_str_cursor_step_prev_utf32(simple, len, &pos) && pos == 0);
  EXPECT_FALSE(BLI_str_cursor_step_prev_utf32(simple, len, &pos));
}

/* -------------------------------------------------------------------- */
/** \name Test #BLI_str_cursor_step_prev_utf32_allcombining
 * \{ */

TEST(string, StrCursorStepPrevUtf32AllCombining)
{
  const char32_t allcombining[] = U"\u0300\u0300\u0300";
  const size_t len = 3;
  int pos = 3;
  EXPECT_TRUE(BLI_str_cursor_step_prev_utf32(allcombining, len, &pos) && pos == 0);
  pos = 2;
  EXPECT_TRUE(BLI_str_cursor_step_prev_utf32(allcombining, len, &pos) && pos == 0);
  pos = 1;
  EXPECT_TRUE(BLI_str_cursor_step_prev_utf32(allcombining, len, &pos) && pos == 0);
  pos = 0;
  EXPECT_FALSE(BLI_str_cursor_step_prev_utf32(allcombining, len, &pos));
}

/* -------------------------------------------------------------------- */
/** \name Test #BLI_str_cursor_step_prev_utf32_complex
 * \{ */

TEST(string, StrCursorStepPrevUtf32Complex)
{
  /* Combining character, "A", two combining characters, "B". */
  const char32_t complex[] = U"\u0300\u0041\u0300\u0320\u0042";
  const size_t len = 5;
  int pos = 5;
  EXPECT_TRUE(BLI_str_cursor_step_prev_utf32(complex, len, &pos) && pos == 4);
  pos = 4;
  EXPECT_TRUE(BLI_str_cursor_step_prev_utf32(complex, len, &pos) && pos == 1);
  pos = 3;
  EXPECT_TRUE(BLI_str_cursor_step_prev_utf32(complex, len, &pos) && pos == 1);
  pos = 2;
  EXPECT_TRUE(BLI_str_cursor_step_prev_utf32(complex, len, &pos) && pos == 1);
  pos = 1;
  EXPECT_TRUE(BLI_str_cursor_step_prev_utf32(complex, len, &pos) && pos == 0);
  pos = 0;
  EXPECT_FALSE(BLI_str_cursor_step_prev_utf32(complex, len, &pos));
}

/* -------------------------------------------------------------------- */
/** \name Test #BLI_str_cursor_step_prev_utf32_invalid
 * \{ */

TEST(string, StrCursorStepPrevUtf32Invalid)
{
  /* Latin1 "À", tab, carriage return, linefeed, separated by combining characters. */
  const char32_t invalid[] = U"\u00C0\u0300\u0009\u0300\u000D\u0300\u000A\u0300";
  const size_t len = 8;
  int pos = 8;
  EXPECT_TRUE(BLI_str_cursor_step_prev_utf32(invalid, len, &pos) && pos == 6);
  pos = 7;
  EXPECT_TRUE(BLI_str_cursor_step_prev_utf32(invalid, len, &pos) && pos == 6);
  pos = 6;
  EXPECT_TRUE(BLI_str_cursor_step_prev_utf32(invalid, len, &pos) && pos == 4);
  pos = 5;
  EXPECT_TRUE(BLI_str_cursor_step_prev_utf32(invalid, len, &pos) && pos == 4);
  pos = 4;
  EXPECT_TRUE(BLI_str_cursor_step_prev_utf32(invalid, len, &pos) && pos == 2);
  pos = 3;
  EXPECT_TRUE(BLI_str_cursor_step_prev_utf32(invalid, len, &pos) && pos == 2);
  pos = 2;
  EXPECT_TRUE(BLI_str_cursor_step_prev_utf32(invalid, len, &pos) && pos == 0);
  pos = 1;
  EXPECT_TRUE(BLI_str_cursor_step_prev_utf32(invalid, len, &pos) && pos == 0);
  pos = 0;
  EXPECT_FALSE(BLI_str_cursor_step_prev_utf32(invalid, len, &pos));
}

/* -------------------------------------------------------------------- */
/** \name Test #BLI_str_cursor_step_next_utf8_empty
 * \{ */
TEST(string, StrCursorStepNextUtf8Empty)
{
  const char empty[] = "";
  const size_t len = 0;
  int pos = 0;
  EXPECT_FALSE(BLI_str_cursor_step_next_utf8(empty, len, &pos));
  pos = 1;
  EXPECT_FALSE(BLI_str_cursor_step_next_utf8(empty, len, &pos));
}

/* -------------------------------------------------------------------- */
/** \name Test #BLI_str_cursor_step_next_utf8_single
 * \{ */
TEST(string, StrCursorStepNextUtf8Single)
{
  const char single[] = "0";
  const size_t len = 1;
  int pos = 0;
  EXPECT_TRUE(BLI_str_cursor_step_next_utf8(single, len, &pos) && pos == 1);
  EXPECT_FALSE(BLI_str_cursor_step_next_utf8(single, len, &pos));
}

/* -------------------------------------------------------------------- */
/** \name Test #BLI_str_cursor_step_next_utf8_simple
 * \{ */

TEST(string, StrCursorStepNextUtf8Simple)
{
  const char simple[] = "012";
  const size_t len = 3;
  int pos = 0;
  EXPECT_TRUE(BLI_str_cursor_step_next_utf8(simple, len, &pos) && pos == 1);
  EXPECT_TRUE(BLI_str_cursor_step_next_utf8(simple, len, &pos) && pos == 2);
  EXPECT_FALSE(BLI_str_cursor_step_next_utf8(simple, len - 1, &pos));
  EXPECT_TRUE(BLI_str_cursor_step_next_utf8(simple, len, &pos) && pos == 3);
  EXPECT_FALSE(BLI_str_cursor_step_next_utf8(simple, len, &pos));
}

/* -------------------------------------------------------------------- */
/** \name Test #BLI_str_cursor_step_next_utf8_allcombining
 * \{ */

TEST(string, StrCursorStepNextUtf8AllCombining)
{
  const char allcombining[] = "\xCC\x80\xCC\x80\xCC\x80";
  const size_t len = 6;
  int pos = 0;
  EXPECT_TRUE(BLI_str_cursor_step_next_utf8(allcombining, len, &pos) && pos == 6);
  pos = 1;
  EXPECT_TRUE(BLI_str_cursor_step_next_utf8(allcombining, len, &pos) && pos == 6);
  pos = 2;
  EXPECT_TRUE(BLI_str_cursor_step_next_utf8(allcombining, len, &pos) && pos == 6);
  pos = 3;
  EXPECT_TRUE(BLI_str_cursor_step_next_utf8(allcombining, len, &pos) && pos == 6);
  pos = 4;
  EXPECT_TRUE(BLI_str_cursor_step_next_utf8(allcombining, len, &pos) && pos == 6);
  pos = 5;
  EXPECT_TRUE(BLI_str_cursor_step_next_utf8(allcombining, len, &pos) && pos == 6);
  pos = 6;
  EXPECT_FALSE(BLI_str_cursor_step_next_utf8(allcombining, len, &pos));
}

/* -------------------------------------------------------------------- */
/** \name Test #BLI_str_cursor_step_next_utf8_complex
 * \{ */

TEST(string, StrCursorStepNextUtf8AllComplex)
{
  /* Combining character, "A", "©", two combining characters, "B". */
  const char complex[] = "\xCC\x80\x41\xC2\xA9\xCC\x80\xCC\xA0\x42";
  const size_t len = 10;
  int pos = 0;
  EXPECT_TRUE(BLI_str_cursor_step_next_utf8(complex, len, &pos) && pos == 2);
  pos = 1;
  EXPECT_TRUE(BLI_str_cursor_step_next_utf8(complex, len, &pos) && pos == 2);
  pos = 2;
  EXPECT_TRUE(BLI_str_cursor_step_next_utf8(complex, len, &pos) && pos == 3);
  pos = 3;
  EXPECT_TRUE(BLI_str_cursor_step_next_utf8(complex, len, &pos) && pos == 9);
  pos = 4;
  EXPECT_TRUE(BLI_str_cursor_step_next_utf8(complex, len, &pos) && pos == 9);
  pos = 5;
  EXPECT_TRUE(BLI_str_cursor_step_next_utf8(complex, len, &pos) && pos == 9);
  pos = 6;
  EXPECT_TRUE(BLI_str_cursor_step_next_utf8(complex, len, &pos) && pos == 9);
  pos = 7;
  EXPECT_TRUE(BLI_str_cursor_step_next_utf8(complex, len, &pos) && pos == 9);
  pos = 8;
  EXPECT_TRUE(BLI_str_cursor_step_next_utf8(complex, len, &pos) && pos == 9);
  pos = 9;
  EXPECT_TRUE(BLI_str_cursor_step_next_utf8(complex, len, &pos) && pos == 10);
  pos = 10;
  EXPECT_FALSE(BLI_str_cursor_step_next_utf8(complex, len, &pos));
}

/* -------------------------------------------------------------------- */
/** \name Test #BLI_str_cursor_step_next_utf8_invalid
 * \{ */

TEST(string, StrCursorStepNextUtf8Invalid)
{
  /* Latin1 "À", combining, tab, carriage return, linefeed, combining. */
  const char invalid[] = "\xC0\xCC\x80\x09\x0D\x0A\xCC\x80";
  const size_t len = 8;
  int pos = 0;
  EXPECT_TRUE(BLI_str_cursor_step_next_utf8(invalid, len, &pos) && pos == 8);
  pos = 1;
  EXPECT_TRUE(BLI_str_cursor_step_next_utf8(invalid, len, &pos) && pos == 8);
  pos = 2;
  EXPECT_TRUE(BLI_str_cursor_step_next_utf8(invalid, len, &pos) && pos == 8);
  pos = 3;
  EXPECT_TRUE(BLI_str_cursor_step_next_utf8(invalid, len, &pos) && pos == 8);
  pos = 4;
  EXPECT_TRUE(BLI_str_cursor_step_next_utf8(invalid, len, &pos) && pos == 8);
  pos = 5;
  EXPECT_TRUE(BLI_str_cursor_step_next_utf8(invalid, len, &pos) && pos == 8);
  pos = 6;
  EXPECT_TRUE(BLI_str_cursor_step_next_utf8(invalid, len, &pos) && pos == 8);
  pos = 7;
  EXPECT_TRUE(BLI_str_cursor_step_next_utf8(invalid, len, &pos) && pos == 8);
  pos = 8;
  EXPECT_FALSE(BLI_str_cursor_step_next_utf8(invalid, len, &pos));
}

/* -------------------------------------------------------------------- */
/** \name Test #BLI_str_cursor_step_prev_utf8_empty
 * \{ */

TEST(string, StrCursorStepPrevUtf8Empty)
{
  const char empty[] = "";
  const size_t len = 0;
  int pos = 0;
  EXPECT_FALSE(BLI_str_cursor_step_prev_utf8(empty, len, &pos));
  pos = 1;
  EXPECT_FALSE(BLI_str_cursor_step_prev_utf8(empty, len, &pos));
}

/* -------------------------------------------------------------------- */
/** \name Test #BLI_str_cursor_step_prev_utf8_single
 * \{ */

TEST(string, StrCursorStepPrevUtf8Single)
{
  const char single[] = "0";
  const size_t len = 1;
  int pos = 1;
  EXPECT_TRUE(BLI_str_cursor_step_prev_utf8(single, len, &pos) && pos == 0);
  EXPECT_FALSE(BLI_str_cursor_step_prev_utf8(single, len, &pos));
}

/* -------------------------------------------------------------------- */
/** \name Test #BLI_str_cursor_step_prev_utf8_single
 * \{ */

TEST(string, StrCursorStepPrevUtf8Simple)
{
  const char simple[] = "012";
  const size_t len = 3;
  int pos = 3;
  EXPECT_TRUE(BLI_str_cursor_step_prev_utf8(simple, len, &pos) && pos == 2);
  EXPECT_TRUE(BLI_str_cursor_step_prev_utf8(simple, len, &pos) && pos == 1);
  EXPECT_TRUE(BLI_str_cursor_step_prev_utf8(simple, len, &pos) && pos == 0);
  EXPECT_FALSE(BLI_str_cursor_step_prev_utf8(simple, len, &pos));
}

/* -------------------------------------------------------------------- */
/** \name Test #BLI_str_cursor_step_prev_utf8_allcombining
 * \{ */

TEST(string, StrCursorStepPrevUtf8AllCombining)
{
  const char allcombining[] = "\xCC\x80\xCC\x80\xCC\x80";
  const size_t len = 6;
  int pos = 6;
  EXPECT_TRUE(BLI_str_cursor_step_prev_utf8(allcombining, len, &pos) && pos == 0);
  pos = 5;
  EXPECT_TRUE(BLI_str_cursor_step_prev_utf8(allcombining, len, &pos) && pos == 0);
  pos = 4;
  EXPECT_TRUE(BLI_str_cursor_step_prev_utf8(allcombining, len, &pos) && pos == 0);
  pos = 3;
  EXPECT_TRUE(BLI_str_cursor_step_prev_utf8(allcombining, len, &pos) && pos == 0);
  pos = 2;
  EXPECT_TRUE(BLI_str_cursor_step_prev_utf8(allcombining, len, &pos) && pos == 0);
  pos = 1;
  EXPECT_TRUE(BLI_str_cursor_step_prev_utf8(allcombining, len, &pos) && pos == 0);
  pos = 0;
  EXPECT_FALSE(BLI_str_cursor_step_prev_utf8(allcombining, len, &pos));
}

/* -------------------------------------------------------------------- */
/** \name Test #BLI_str_cursor_step_prev_utf8_complex
 * \{ */

TEST(string, StrCursorStepPrevUtf8Complex)
{
  /* Combining character, "A", "©", two combining characters, "B". */
  const char complex[] = "\xCC\x80\x41\xC2\xA9\xCC\x80\xCC\xA0\x42";
  const size_t len = 10;
  int pos = 10;
  EXPECT_TRUE(BLI_str_cursor_step_prev_utf8(complex, len, &pos) && pos == 9);
  pos = 9;
  EXPECT_TRUE(BLI_str_cursor_step_prev_utf8(complex, len, &pos) && pos == 3);
  pos = 8;
  EXPECT_TRUE(BLI_str_cursor_step_prev_utf8(complex, len, &pos) && pos == 3);
  pos = 7;
  EXPECT_TRUE(BLI_str_cursor_step_prev_utf8(complex, len, &pos) && pos == 3);
  pos = 6;
  EXPECT_TRUE(BLI_str_cursor_step_prev_utf8(complex, len, &pos) && pos == 3);
  pos = 5;
  EXPECT_TRUE(BLI_str_cursor_step_prev_utf8(complex, len, &pos) && pos == 3);
  pos = 4;
  EXPECT_TRUE(BLI_str_cursor_step_prev_utf8(complex, len, &pos) && pos == 3);
  pos = 3;
  EXPECT_TRUE(BLI_str_cursor_step_prev_utf8(complex, len, &pos) && pos == 2);
  pos = 2;
  EXPECT_TRUE(BLI_str_cursor_step_prev_utf8(complex, len, &pos) && pos == 0);
  pos = 1;
  EXPECT_TRUE(BLI_str_cursor_step_prev_utf8(complex, len, &pos) && pos == 0);
  pos = 0;
  EXPECT_FALSE(BLI_str_cursor_step_prev_utf8(complex, len, &pos));
}

/* -------------------------------------------------------------------- */
/** \name Test #BLI_str_cursor_step_prev_utf8_invalid
 * \{ */

TEST(string, StrCursorStepPrevUtf8Invalid)
{
  /* Latin1 "À", combining, tab, carriage return, linefeed, combining. */
  const char invalid[] = "\xC0\xCC\x80\x09\x0D\x0A\xCC\x80";
  const size_t len = 8;
  int pos = 8;
  EXPECT_TRUE(BLI_str_cursor_step_prev_utf8(invalid, len, &pos) && pos == 5);
  pos = 7;
  EXPECT_TRUE(BLI_str_cursor_step_prev_utf8(invalid, len, &pos) && pos == 5);
  pos = 6;
  EXPECT_TRUE(BLI_str_cursor_step_prev_utf8(invalid, len, &pos) && pos == 5);
  pos = 5;
  EXPECT_TRUE(BLI_str_cursor_step_prev_utf8(invalid, len, &pos) && pos == 4);
  pos = 4;
  EXPECT_TRUE(BLI_str_cursor_step_prev_utf8(invalid, len, &pos) && pos == 3);
  pos = 3;
  EXPECT_TRUE(BLI_str_cursor_step_prev_utf8(invalid, len, &pos) && pos == 0);
  pos = 2;
  EXPECT_TRUE(BLI_str_cursor_step_prev_utf8(invalid, len, &pos) && pos == 0);
  pos = 1;
  EXPECT_TRUE(BLI_str_cursor_step_prev_utf8(invalid, len, &pos) && pos == 0);
  pos = 0;
  EXPECT_FALSE(BLI_str_cursor_step_prev_utf8(invalid, len, &pos));
}

/** \} */