icu/icu4c/source/test/fuzzer/calendar_fuzzer.cpp

// © 2023 and later: Unicode, Inc. and others.
// License & terms of use: http://www.unicode.org/copyright.html

// Fuzzer for ICU Calendar.

#include <cstring>

#include "fuzzer_utils.h"

#include "unicode/calendar.h"
#include "unicode/localebuilder.h"
#include "unicode/locid.h"

icu::TimeZone* CreateRandomTimeZone(uint16_t rnd) {
    icu::Locale und("und");
    UErrorCode status = U_ZERO_ERROR;
    std::unique_ptr<icu::StringEnumeration> enumeration(
        icu::TimeZone::createEnumeration(status));
    if (U_SUCCESS(status)) {
        int32_t count = enumeration->count(status);
        if (U_SUCCESS(status)) {
            int32_t i = rnd % count;
            const icu::UnicodeString* id = nullptr;
            do {
              id = enumeration->snext(status);
            } while (U_SUCCESS(status) && --i > 0);
            if (U_SUCCESS(status)) {
                return icu::TimeZone::createTimeZone(*id);
            }
        }
    }
    return icu::TimeZone::getGMT()->clone();
}
const char* GetRandomCalendarType(uint8_t rnd) {
    icu::Locale und("und");
    UErrorCode status = U_ZERO_ERROR;
    std::unique_ptr<icu::StringEnumeration> enumeration(
        icu::Calendar::getKeywordValuesForLocale("calendar", und, false, status));
    const char* type = "";
    if (U_SUCCESS(status)) {
        int32_t count = enumeration->count(status);
        if (U_SUCCESS(status)) {
            int32_t i = rnd % count;
            do {
              type = enumeration->next(nullptr, status);
            } while (U_SUCCESS(status) && --i > 0);
        }
    }
    type = uloc_toUnicodeLocaleType("ca", type);
    return type;
}

extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
    uint16_t rnd;
    // Set the limit for the test data to 100 bytes to avoid timeout for a
    // very long list of operations.
    if (size > 100) { size = 100; }
    if (size < 2*sizeof(rnd) + 1) return 0;
    icu::StringPiece fuzzData(reinterpret_cast<const char *>(data), size);
    // Byte 0 and 1 randomly select a TimeZone
    std::memcpy(&rnd, fuzzData.data(), sizeof(rnd));
    fuzzData.remove_prefix(sizeof(rnd));
    std::unique_ptr<icu::TimeZone> timeZone(CreateRandomTimeZone(rnd));

    // Byte 1 and 2 randomly select a Locale
    std::memcpy(&rnd, fuzzData.data(), sizeof(rnd));
    fuzzData.remove_prefix(sizeof(rnd));
    icu::Locale locale = GetRandomLocale(rnd);

    // Byte 4 randomly select a Calendar type
    const char* type = GetRandomCalendarType(*fuzzData.data());
    fuzzData.remove_prefix(1);

    UErrorCode status = U_ZERO_ERROR;
    icu::LocaleBuilder bld;
    bld.setLocale(locale);
    bld.setUnicodeLocaleKeyword("ca", type);
    locale = bld.build(status);
    if (U_FAILURE(status)) return 0;
    std::unique_ptr<icu::Calendar> cal(
        icu::Calendar::createInstance(*timeZone, locale, status));
    printf("locale = %s\n", locale.getName());
    if (U_FAILURE(status)) return 0;
    cal->clear();

    int32_t amount;
    double time;
    while (fuzzData.length() > 2 + static_cast<int32_t>(sizeof(time))) {
        UCalendarDateFields field = static_cast<UCalendarDateFields>(
            (*fuzzData.data()) % UCAL_FIELD_COUNT);
        fuzzData.remove_prefix(1);

        uint8_t command = *fuzzData.data();
        fuzzData.remove_prefix(1);

        std::memcpy(&time, fuzzData.data(), sizeof(time));
        std::memcpy(&amount, fuzzData.data(), sizeof(amount));
        fuzzData.remove_prefix(sizeof(time));

        status = U_ZERO_ERROR;
        switch (command % 7) {
            case 0:
                printf("setTime(%f)\n", time);
                cal->setTime(time, status);
                break;
            case 1:
                printf("getTime()\n");
                cal->getTime(status);
                break;
            case 2:
                printf("set(%d, %d)\n", field, amount);
                cal->set(field, amount);
                break;
            case 3:
                printf("add(%d, %d)\n", field, amount);
                cal->add(field, amount, status);
                break;
            case 4:
                printf("roll(%d, %d)\n", field, amount);
                cal->roll(field, amount, status);
                break;
            case 5:
                printf("fieldDifference(%f, %d)\n", time, field);
                cal->fieldDifference(time, field, status);
                break;
            case 6:
                printf("get(%d)\n", field);
                cal->get(field, status);
                break;
            default:
                break;
        }
    }

    return EXIT_SUCCESS;
}