/*
 * Copyright (C) 2016-2019 Apple Inc. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
 * THE POSSIBILITY OF SUCH DAMAGE.
 */

#include "config.h"
#include "TypedArrayCTest.h"

#include "JavaScript.h"
#include <limits.h>
#include <math.h>
#include <stdio.h>
#include <wtf/Assertions.h>

WTF_ALLOW_UNSAFE_BUFFER_USAGE_BEGIN

extern "C" void JSSynchronousGarbageCollectForDebugging(JSContextRef);

static void id(void*, void*) { }
static void freePtr(void* ptr, void*)
{
    free(ptr);
}

static constexpr unsigned numLengths = 3;

static const unsigned lengths[numLengths] =
{
    0,
    1,
    10,
};

static const unsigned byteSizes[] =
{
    1, // kJSTypedArrayTypeInt8Array
    2, // kJSTypedArrayTypeInt16Array
    4, // kJSTypedArrayTypeInt32Array
    1, // kJSTypedArrayTypeUint8Array
    1, // kJSTypedArrayTypeUint8ClampedArray
    2, // kJSTypedArrayTypeUint16Array
    4, // kJSTypedArrayTypeUint32Array
    4, // kJSTypedArrayTypeFloat32Array
    8, // kJSTypedArrayTypeFloat64Array
    0, // kJSTypedArrayTypeArrayBuffer
    0, // kJSTypedArrayTypeNone
    8, // kJSTypedArrayTypeBigInt64Array
    8, // kJSTypedArrayTypeBigUint64Array
};

static const char* typeToString[] =
{
    "kJSTypedArrayTypeInt8Array",
    "kJSTypedArrayTypeInt16Array",
    "kJSTypedArrayTypeInt32Array",
    "kJSTypedArrayTypeUint8Array",
    "kJSTypedArrayTypeUint8ClampedArray",
    "kJSTypedArrayTypeUint16Array",
    "kJSTypedArrayTypeUint32Array",
    "kJSTypedArrayTypeFloat32Array",
    "kJSTypedArrayTypeFloat64Array",
    "kJSTypedArrayTypeArrayBuffer",
    "kJSTypedArrayTypeNone",
    "kJSTypedArrayTypeBigInt64Array",
    "kJSTypedArrayTypeBigUint64Array",
};

inline int unexpectedException(const char* name)
{
    fprintf(stderr, "%s FAILED: unexpected exception\n", name);
    return 1;
}

static int assertEqualsAsNumber(JSGlobalContextRef context, JSValueRef value, double expectedValue)
{
    double number = JSValueToNumber(context, value, nullptr);
    if (number != expectedValue && !(isnan(number) && isnan(expectedValue))) {
        fprintf(stderr, "assertEqualsAsNumber FAILED: %p, %lf\n", value, expectedValue);
        return 1;
    }
    return 0;
}

static int testAccess(JSGlobalContextRef context, JSObjectRef typedArray, JSTypedArrayType type, unsigned elementLength, void* expectedPtr = nullptr, JSObjectRef expectedBuffer = nullptr, unsigned expectedOffset = 0)
{
    JSValueRef exception = nullptr;
    // Test typedArray basic functions.
    JSTypedArrayType actualType = JSValueGetTypedArrayType(context, typedArray, &exception);
    if (type != actualType || exception) {
        fprintf(stderr, "TypedArray type FAILED: %p, got: %s, expected: %s\n", typedArray, typeToString[actualType], typeToString[type]);
        return 1;
    }

    unsigned length = JSObjectGetTypedArrayLength(context, typedArray, &exception);
    if (elementLength != length || exception) {
        fprintf(stderr, "TypedArray length FAILED: %p (%s), got: %d, expected: %d\n", typedArray, typeToString[type], length, elementLength);
        return 1;
    }

    unsigned byteLength = JSObjectGetTypedArrayByteLength(context, typedArray, &exception);
    unsigned expectedLength = byteSizes[type] * elementLength;
    if (byteLength != expectedLength || exception) {
        fprintf(stderr, "TypedArray byteLength FAILED: %p (%s), got: %d, expected: %d\n", typedArray, typeToString[type], byteLength, expectedLength);
        return 1;
    }

    unsigned offset = JSObjectGetTypedArrayByteOffset(context, typedArray, &exception);
    if (expectedOffset != offset || exception) {
        fprintf(stderr, "TypedArray byteOffset FAILED: %p (%s), got: %d, expected: %d\n", typedArray, typeToString[type], offset, expectedOffset);
        return 1;
    }

    void* ptr = JSObjectGetTypedArrayBytesPtr(context, typedArray, &exception);
    if (exception)
        return unexpectedException("TypedArray get bytes ptr");

    JSObjectRef buffer = JSObjectGetTypedArrayBuffer(context, typedArray, &exception);
    if (exception)
        return unexpectedException("TypedArray get buffer");

    void* bufferPtr = JSObjectGetArrayBufferBytesPtr(context, buffer, &exception);
    if (exception)
        return unexpectedException("ArrayBuffer get bytes ptr");

    if (bufferPtr != ptr) {
        fprintf(stderr, "FAIL: TypedArray bytes ptr and ArrayBuffer byte ptr were not the same: %p (%s) TypedArray: %p, ArrayBuffer: %p\n", typedArray, typeToString[type], ptr, bufferPtr);
        return 1;
    }

    if (expectedPtr && ptr != expectedPtr) {
        fprintf(stderr, "FAIL: TypedArray bytes ptr and the ptr used to construct the array were not the same: %p (%s) TypedArray: %p, bytes ptr: %p\n", typedArray, typeToString[type], ptr, expectedPtr);
        return 1;
    }

    if (expectedBuffer && expectedBuffer != buffer) {
        fprintf(stderr, "FAIL: TypedArray buffer and the ArrayBuffer buffer used to construct the array were not the same: %p (%s) TypedArray buffer: %p, data: %p\n", typedArray, typeToString[type], buffer, expectedBuffer);
        return 1;
    }

    return 0;
}

static int testConstructors(JSGlobalContextRef context, JSTypedArrayType type, unsigned length)
{
    int failed = 0;
    JSValueRef exception = nullptr;
    JSObjectRef typedArray;

    // Test create with length.
    typedArray = JSObjectMakeTypedArray(context, type, length, &exception);
    failed = failed || exception || testAccess(context, typedArray, type, length);

    void* ptr = calloc(length, byteSizes[type]); // This is to be freed by data
    JSObjectRef data = JSObjectMakeArrayBufferWithBytesNoCopy(context, ptr, length * byteSizes[type], freePtr, nullptr, &exception);
    failed = failed || exception;

    // Test create with existing ptr.
    typedArray = JSObjectMakeTypedArrayWithBytesNoCopy(context, type, ptr, length * byteSizes[type], id, nullptr, &exception);
    failed = failed || exception || testAccess(context, typedArray, type, length, ptr);

    // Test create with existing ArrayBuffer.
    typedArray = JSObjectMakeTypedArrayWithArrayBuffer(context, type, data, &exception);
    failed = failed || exception || testAccess(context, typedArray, type, length, ptr, data);

    // Test create with existing ArrayBuffer and offset.
    typedArray = JSObjectMakeTypedArrayWithArrayBufferAndOffset(context, type, data, 0, length, &exception);
    failed = failed || exception || testAccess(context, typedArray, type, length, ptr, data);

    typedArray = JSObjectMakeTypedArrayWithArrayBufferAndOffset(context, type, data, byteSizes[type], length-1, &exception);
    if (!length)
        failed = failed || !exception;
    else
        failed = failed || testAccess(context, typedArray, type, length-1, ptr, data, byteSizes[type]) || exception;

    exception = nullptr;
    typedArray = JSObjectMakeTypedArrayWithArrayBufferAndOffset(context, type, data, byteSizes[type], 3, &exception);
    if (length < 2)
        failed = failed || !exception;
    else
        failed = failed || testAccess(context, typedArray, type, 3, ptr, data, byteSizes[type]) || exception;

    if (byteSizes[type] > 1) {
        exception = nullptr;
        typedArray = JSObjectMakeTypedArrayWithArrayBufferAndOffset(context, type, data, 1, length-1, &exception);
        failed = failed || !exception;
    }

    typedArray = JSObjectMakeTypedArrayWithArrayBufferAndOffset(context, type, data, byteSizes[type], length, &exception);
    failed = failed || !exception;

    exception = nullptr;
    typedArray = JSObjectMakeTypedArrayWithArrayBufferAndOffset(context, type, data, byteSizes[type], 0, &exception);
    if (!length)
        failed = failed || !exception;
    else
        failed = failed || testAccess(context, typedArray, type, 0, ptr, data, byteSizes[type]) || exception;

    return failed;
}

template <typename Functor>
static int forEachTypedArrayType(const Functor& functor)
{
    int failed = 0;
    for (unsigned i = 0; i < kJSTypedArrayTypeArrayBuffer; i++) {
        if (i != kJSTypedArrayTypeNone && i != kJSTypedArrayTypeArrayBuffer)
            failed = failed || functor(static_cast<JSTypedArrayType>(i));
    }
    return failed;
}

int testTypedArrayCAPI()
{
    int failed = 0;
    JSGlobalContextRef context = JSGlobalContextCreate(nullptr);

    failed = failed || forEachTypedArrayType([&](JSTypedArrayType type) {
        int failed = 0;
        for (unsigned i = 0; i < numLengths; i++)
            failed = failed || testConstructors(context, type, lengths[i]);
        return failed;
    });

    // Test making a typedArray from scratch length.
    volatile JSObjectRef typedArray = JSObjectMakeTypedArray(context, kJSTypedArrayTypeUint32Array, 10, nullptr);
    JSObjectRef data = JSObjectGetTypedArrayBuffer(context, typedArray, nullptr);
    unsigned* buffer = static_cast<unsigned*>(JSObjectGetArrayBufferBytesPtr(context, data, nullptr));

    ASSERT(JSObjectGetTypedArrayLength(context, typedArray, nullptr) == 10);

    // Test buffer is connected to typedArray.
    buffer[1] = 1;
    JSValueRef v = JSObjectGetPropertyAtIndex(context, typedArray, 1, nullptr);
    failed = failed || assertEqualsAsNumber(context, v, 1);

    // Test passing a buffer from a new array to an old array
    typedArray = JSObjectMakeTypedArrayWithBytesNoCopy(context, kJSTypedArrayTypeUint32Array, buffer, 40, id, nullptr, nullptr);
    buffer = static_cast<unsigned*>(JSObjectGetTypedArrayBytesPtr(context, typedArray, nullptr));
    ASSERT(buffer[1] == 1);
    buffer[1] = 20;
    ASSERT(((unsigned*)JSObjectGetArrayBufferBytesPtr(context, data, nullptr))[1] == 20);

    // Test constructing with data and the data returned are the same even with an offset.
    typedArray = JSObjectMakeTypedArrayWithArrayBufferAndOffset(context, kJSTypedArrayTypeUint32Array, data, 4, 9, nullptr);
    failed = failed || assertEqualsAsNumber(context, JSObjectGetPropertyAtIndex(context, typedArray, 0, nullptr), 20);
    ASSERT(data == JSObjectGetTypedArrayBuffer(context, typedArray, nullptr));

    // Test attempting to allocate an array too big for memory.
    forEachTypedArrayType([&](JSTypedArrayType type) {
        JSValueRef exception = nullptr;
        JSObjectMakeTypedArray(context, type, UINT_MAX, &exception);
        return !exception;
    });

    JSGlobalContextRelease(context);

    if (!failed)
        printf("PASS: Typed Array C API Tests.\n");
    else
        printf("FAIL: Some Typed Array C API Tests failed.\n");

    return failed;
}

WTF_ALLOW_UNSAFE_BUFFER_USAGE_END
