// Copyright(c) 2017-2018, Intel Corporation
//
// Redistribution  and  use  in source  and  binary  forms,  with  or  without
// modification, are permitted provided that the following conditions are met:
//
// * Redistributions of  source code  must retain the  above copyright notice,
//   this list of conditions and the following disclaimer.
// * 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.
// * Neither the name  of Intel Corporation  nor the names of its contributors
//   may be used to  endorse or promote  products derived  from this  software
//   without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND 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 THE COPYRIGHT OWNER  OR 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.

#ifdef __cplusplus

extern "C" {
#endif
#include <opae/utils.h>
#include "wsid_list_int.h"

#ifdef __cplusplus
}
#endif
#include <random>
#include <chrono>
#include <thread>
#include "gtest/gtest.h"

#ifndef BUILD_ASE
 /*
 * On hardware, the mmio map is a hash table.
 */
static bool mmio_map_is_empty(struct wsid_tracker *root) {
  if (!root || (root->n_hash_buckets == 0))
    { return true; }
  else{
    uint64_t i;
    for (i = 0; i < root->n_hash_buckets; ++i) {
      if (root->table[i])
        { return false; }
    }
  }
   return true;
}
#else
 /*
 * In ASE, the mmio map is a list.
 */
static bool mmio_map_is_empty(struct wsid_map *root) {
  return !root;
}
#endif

// define some operators to alter index consistently
constexpr uint64_t index_to_wsid(uint64_t i) { return i * 6; }
constexpr uint64_t index_to_addr(uint64_t i) { return i * 5; }
constexpr uint64_t index_to_phys(uint64_t i) { return i * 4; }
constexpr uint64_t index_to_len(uint64_t i) { return i * 3; }
constexpr uint64_t index_to_offset(uint64_t i) { return i * 2; }
constexpr uint64_t index_to_index(uint64_t i) { return i * 1; }
constexpr uint64_t index_to_flags(uint64_t i) { return i * i; }

static uint64_t stress_count = 0;

void cleanup_cb(wsid_map *ws) { (void) ws; stress_count--; }
   
class wsid_list_f : public ::testing::Test {
 protected:
  wsid_list_f() 
       : wsid_root_(nullptr) {}

  virtual void SetUp() override {
    wsid_root_ = wsid_tracker_init(1000);
    count_ = 100;
    distribution_ = std::uniform_int_distribution<int>(0, count_);
    uint64_t i;
    for (i = 0; i < count_; ++i) {
      EXPECT_TRUE(wsid_add(wsid_root_, index_to_wsid(i), index_to_addr(i),
                           index_to_phys(i), index_to_len(i),
                           index_to_offset(i), index_to_index(i),
                           index_to_flags(i)));
    }
  }

  virtual void TearDown() override {
      auto cleanup = [](struct wsid_map *w) -> void {
           EXPECT_EQ(w->wsid, index_to_wsid(w->index));};
 
      bool empty = mmio_map_is_empty(wsid_root_);
      if ( !empty ) {
        wsid_tracker_cleanup(wsid_root_, cleanup);
        wsid_root_ = nullptr;
      }
  }

  struct wsid_tracker *wsid_root_;
  uint64_t count_;
  std::default_random_engine generator_;
  std::uniform_int_distribution<int> distribution_;
};

/*
 * @test    wsid_init_neg
 *
 * @details When wsid_tracker_init()'s n_hash_buckets parameter
 *          is greater then the max, the function returns NULL.
 */
TEST_F(wsid_list_f, wsid_init_neg) {
  EXPECT_EQ(wsid_tracker_init(123456789), nullptr);
}

TEST_F(wsid_list_f, wsid_add) {
  // the setup adds, now we just confirm that it added the right data
  wsid_map *it = nullptr;
  int i = count_;
  while (i-- >= 0) {
    it = wsid_find_by_index(wsid_root_, i);
    if (it) {
      EXPECT_EQ(it->wsid, index_to_wsid(i));
      EXPECT_EQ(it->addr, index_to_addr(i));
      EXPECT_EQ(it->phys, index_to_phys(i));
      EXPECT_EQ(it->len, index_to_len(i));
      EXPECT_EQ(it->offset, index_to_offset(i));
      EXPECT_EQ(it->index, index_to_index(i));
      ASSERT_EQ(it->flags, index_to_flags(i));
      it = nullptr;
    }
  }
  it = nullptr;
}

TEST_F(wsid_list_f, wsid_del) {
  uint32_t wsid = index_to_wsid(distribution_(generator_));
  EXPECT_TRUE(wsid_del(wsid_root_, wsid));
  wsid_map *it = wsid_find(wsid_root_, wsid);
  // now look for the wsid in the list
  while (it != nullptr) {
    if (it->wsid == wsid) {
      break;
    }
    it = it->next;
  }
  // it is null when we've looked at whole list without finding wsid
  EXPECT_EQ(it, nullptr);
  // it isn't there so we shouldn't be able to delete it again
  EXPECT_FALSE(wsid_del(wsid_root_, wsid));
}

TEST_F(wsid_list_f, wsid_find) {
  uint32_t index = distribution_(generator_);
  wsid_map *ws = wsid_find_by_index(wsid_root_, index);
  ASSERT_NE(ws, nullptr);
  EXPECT_EQ(ws->wsid, index_to_wsid(index));
}

TEST_F(wsid_list_f, wsid_find_by_index) {
  uint64_t index = distribution_(generator_);
  wsid_map *ws = wsid_find(wsid_root_, index_to_wsid(index));
  ASSERT_NE(ws, nullptr);
  EXPECT_EQ(ws->index, index);
}

TEST_F(wsid_list_f, stress) {
  uint64_t count = count_;
  // FIXME: wsid_add can result in process being killed (out of memory) if it's
  // called too many times.
  uint64_t count_max = 1024;
  for (count = count_; count < count_max; ++count) {
    EXPECT_TRUE(wsid_add(wsid_root_, index_to_wsid(count),
                         index_to_addr(count), index_to_phys(count),
                         index_to_len(count), index_to_offset(count),
                         index_to_index(count), index_to_flags(count)));
  }
  stress_count = count;
  wsid_tracker_cleanup(wsid_root_, cleanup_cb);
  EXPECT_EQ(stress_count, 0);
  wsid_root_ = nullptr;
}