/*
 * Copyright 2020 The libgav1 Authors
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#ifndef LIBGAV1_TESTS_UTILS_H_
#define LIBGAV1_TESTS_UTILS_H_

#include <cstddef>
#include <new>
#include <string>

#include "absl/base/config.h"
#include "absl/time/time.h"
#include "src/gav1/decoder_buffer.h"
#include "src/utils/memory.h"
#include "tests/third_party/libvpx/acm_random.h"

#ifdef ABSL_HAVE_EXCEPTIONS
#include <exception>
#endif

namespace libgav1 {
namespace test_utils {

enum { kAlternateDeterministicSeed = 0x9571 };
static_assert(kAlternateDeterministicSeed !=
                  libvpx_test::ACMRandom::DeterministicSeed(),
              "");

// Similar to libgav1::MaxAlignedAllocable, but retains the throwing versions
// of new to support googletest allocations.
struct MaxAlignedAllocable {
  // Class-specific allocation functions.
  static void* operator new(size_t size) {
    void* const p =
        libgav1::MaxAlignedAllocable::operator new(size, std::nothrow);
#ifdef ABSL_HAVE_EXCEPTIONS
    if (p == nullptr) throw std::bad_alloc();
#endif
    return p;
  }
  static void* operator new[](size_t size) {
    void* const p =
        libgav1::MaxAlignedAllocable::operator new[](size, std::nothrow);
#ifdef ABSL_HAVE_EXCEPTIONS
    if (p == nullptr) throw std::bad_alloc();
#endif
    return p;
  }

  // Class-specific non-throwing allocation functions
  static void* operator new(size_t size, const std::nothrow_t& tag) noexcept {
    return libgav1::MaxAlignedAllocable::operator new(size, tag);
  }
  static void* operator new[](size_t size, const std::nothrow_t& tag) noexcept {
    return libgav1::MaxAlignedAllocable::operator new[](size, tag);
  }

  // Class-specific deallocation functions.
  static void operator delete(void* ptr) noexcept {
    libgav1::MaxAlignedAllocable::operator delete(ptr);
  }
  static void operator delete[](void* ptr) noexcept {
    libgav1::MaxAlignedAllocable::operator delete[](ptr);
  }

  // Only called if new (std::nothrow) is used and the constructor throws an
  // exception.
  static void operator delete(void* ptr, const std::nothrow_t& tag) noexcept {
    libgav1::MaxAlignedAllocable::operator delete(ptr, tag);
  }
  // Only called if new[] (std::nothrow) is used and the constructor throws an
  // exception.
  static void operator delete[](void* ptr, const std::nothrow_t& tag) noexcept {
    libgav1::MaxAlignedAllocable::operator delete[](ptr, tag);
  }
};

// Clears dsp table entries for |bitdepth|. This function is not thread safe.
void ResetDspTable(int bitdepth);

//------------------------------------------------------------------------------
// Gets human readable hexadecimal encoded MD5 sum from given data, block, or
// frame buffer.

std::string GetMd5Sum(const void* bytes, size_t size);
template <typename Pixel>
std::string GetMd5Sum(const Pixel* block, int width, int height, int stride);
std::string GetMd5Sum(const DecoderBuffer& buffer);

//------------------------------------------------------------------------------
// Compares the md5 digest of |size| bytes of |data| with |expected_digest|.
// Prints a log message with |name|, |function_name|, md5 digest and
// |elapsed_time|. |name| and |function_name| are merely tags used for logging
// and can be any meaningful string depending on the caller's context.

void CheckMd5Digest(const char name[], const char function_name[],
                    const char expected_digest[], const void* data, size_t size,
                    absl::Duration elapsed_time);

//------------------------------------------------------------------------------
// Compares the md5 digest of |block| with |expected_digest|. The width, height,
// and stride of |block| are |width|, |height|, and |stride|, respectively.
// Prints a log message with |name|, |function_name|, md5 digest and
// |elapsed_time|. |name| and |function_name| are merely tags used for logging
// and can be any meaningful string depending on the caller's context.

template <typename Pixel>
void CheckMd5Digest(const char name[], const char function_name[],
                    const char expected_digest[], const Pixel* block, int width,
                    int height, int stride, absl::Duration elapsed_time);

//------------------------------------------------------------------------------
// Compares |actual_digest| with |expected_digest|. Prints a log message with
// |name|, |function_name|, md5 digest and |elapsed_time|. |name| and
// |function_name| are merely tags used for logging and can be any meaningful
// string depending on the caller's context.

void CheckMd5Digest(const char name[], const char function_name[],
                    const char expected_digest[], const char actual_digest[],
                    absl::Duration elapsed_time);

}  // namespace test_utils
}  // namespace libgav1

#endif  // LIBGAV1_TESTS_UTILS_H_