/*
 * Copyright (c) 2015, 2025, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */

#include "classfile/symbolTable.hpp"
#include "nmt/nmtCommon.hpp"
#include "memory/allocation.hpp"
#include "memory/resourceArea.hpp"
#include "oops/symbolHandle.hpp"
#include "unittest.hpp"
#include "utilities/debug.hpp"
#include "utilities/globalDefinitions.hpp"
#include "utilities/hashTable.hpp"

class CommonHashTableTest : public ::testing::Test {
 protected:
  typedef void* K;
  typedef uintx V;
  const static MemTag MEM_TAG = mtInternal;

  static unsigned identity_hash(const K& k) {
    return (unsigned) (uintptr_t) k;
  }

  static unsigned bad_hash(const K& k) {
    return 1;
  }

  static void* as_K(uintptr_t val) {
    return (void*) val;
  }

  class EqualityTestIter {
   public:

    bool do_entry(K const& k, V const& v) {
      if ((uintptr_t) k != (uintptr_t) v) {
        EXPECT_EQ((uintptr_t) k, (uintptr_t) v);
        return false;
      } else {
        return true; // continue iteration
      }
    }
  };

  class DeleterTestIter {
    int _val;
   public:
    DeleterTestIter(int i) : _val(i) {}

    bool do_entry(K const& k, V const& v) {
      if ((uintptr_t) k == (uintptr_t) _val) {
        // Delete me!
        return true;
      } else {
        return false; // continue iteration
      }
    }
  };

};

class SmallHashTableTest : public CommonHashTableTest {
 protected:

  template<
  unsigned (*HASH) (K const&) = primitive_hash<K>,
  bool (*EQUALS)(K const&, K const&) = primitive_equals<K>,
  unsigned SIZE = 256,
  AnyObj::allocation_type ALLOC_TYPE = AnyObj::RESOURCE_AREA
  >
  class Runner : public AllStatic {
   public:

    static void test(V step) {
      EqualityTestIter et;
      HashTable<K, V, SIZE, ALLOC_TYPE, MEM_TAG, HASH, EQUALS> rh;

      ASSERT_FALSE(rh.contains(as_K(step)));

      ASSERT_TRUE(rh.put(as_K(step), step));
      ASSERT_TRUE(rh.contains(as_K(step)));

      ASSERT_FALSE(rh.put(as_K(step), step));

      ASSERT_TRUE(rh.put(as_K(2 * step), 2 * step));
      ASSERT_TRUE(rh.put(as_K(3 * step), 3 * step));
      ASSERT_TRUE(rh.put(as_K(4 * step), 4 * step));
      ASSERT_TRUE(rh.put(as_K(5 * step), 5 * step));

      ASSERT_FALSE(rh.remove(as_K(0x0)));

      rh.iterate(&et);
      if (::testing::Test::HasFailure()) {
        return;
      }

      ASSERT_TRUE(rh.remove(as_K(step)));
      ASSERT_FALSE(rh.contains(as_K(step)));
      rh.iterate(&et);


      // Test put_if_absent(key) (creating a default-created value)
      bool created = false;
      V* v = rh.put_if_absent(as_K(step), &created);
      ASSERT_TRUE(rh.contains(as_K(step)));
      ASSERT_TRUE(created);
      *v = (V)step;

      // Calling this function a second time should yield the same value pointer
      V* v2 = rh.put_if_absent(as_K(step), &created);
      ASSERT_EQ(v, v2);
      ASSERT_EQ(*v2, *v);
      ASSERT_FALSE(created);

      ASSERT_TRUE(rh.remove(as_K(step)));
      ASSERT_FALSE(rh.contains(as_K(step)));
      rh.iterate(&et);

      // Test put_if_absent(key, value)
      v = rh.put_if_absent(as_K(step), step, &created);
      ASSERT_EQ(*v, step);
      ASSERT_TRUE(rh.contains(as_K(step)));
      ASSERT_TRUE(created);

      v2 = rh.put_if_absent(as_K(step), step, &created);
      // Calling this function a second time should yield the same value pointer
      ASSERT_EQ(v, v2);
      ASSERT_EQ(*v2, (V)step);
      ASSERT_FALSE(created);

      ASSERT_TRUE(rh.remove(as_K(step)));
      ASSERT_FALSE(rh.contains(as_K(step)));
      rh.iterate(&et);


    }
  };
};

TEST_VM_F(SmallHashTableTest, default) {
  ResourceMark rm;
  Runner<>::test(0x1);
}

TEST_VM_F(SmallHashTableTest, default_shifted) {
  ResourceMark rm;
  Runner<>::test(0x10);
}

TEST_VM_F(SmallHashTableTest, bad_hash) {
  ResourceMark rm;
  Runner<bad_hash>::test(0x1);
}

TEST_VM_F(SmallHashTableTest, bad_hash_shifted) {
  ResourceMark rm;
  Runner<bad_hash>::test(0x10);
}

TEST_VM_F(SmallHashTableTest, identity_hash) {
  ResourceMark rm;
  Runner<identity_hash>::test(0x1);
}

TEST_VM_F(SmallHashTableTest, identity_hash_shifted) {
  ResourceMark rm;
  Runner<identity_hash>::test(0x10);
}

TEST_VM_F(SmallHashTableTest, primitive_hash_no_rm) {
  Runner<primitive_hash<K>, primitive_equals<K>, 512, AnyObj::C_HEAP>::test(0x1);
}

TEST_VM_F(SmallHashTableTest, primitive_hash_no_rm_shifted) {
  Runner<primitive_hash<K>, primitive_equals<K>, 512, AnyObj::C_HEAP>::test(0x10);
}

TEST_VM_F(SmallHashTableTest, bad_hash_no_rm) {
  Runner<bad_hash, primitive_equals<K>, 512, AnyObj::C_HEAP>::test(0x1);
}

TEST_VM_F(SmallHashTableTest, bad_hash_no_rm_shifted) {
  Runner<bad_hash, primitive_equals<K>, 512, AnyObj::C_HEAP>::test(0x10);
}

TEST_VM_F(SmallHashTableTest, identity_hash_no_rm) {
  Runner<identity_hash, primitive_equals<K>, 1, AnyObj::C_HEAP>::test(0x1);
}

TEST_VM_F(SmallHashTableTest, identity_hash_no_rm_shifted) {
  Runner<identity_hash, primitive_equals<K>, 1, AnyObj::C_HEAP>::test(0x10);
}

class GenericHashTableTest : public CommonHashTableTest {
 protected:

  template<
  unsigned (*HASH) (K const&) = primitive_hash<K>,
  bool (*EQUALS)(K const&, K const&) = primitive_equals<K>,
  unsigned SIZE = 256,
  AnyObj::allocation_type ALLOC_TYPE = AnyObj::RESOURCE_AREA
  >
  class Runner : public AllStatic {
   public:

    static void test(unsigned num_elements = SIZE) {
      EqualityTestIter et;
      HashTable<K, V, SIZE, ALLOC_TYPE, MEM_TAG, HASH, EQUALS> rh;

      for (uintptr_t i = 0; i < num_elements; ++i) {
        ASSERT_TRUE(rh.put(as_K(i), i));
      }

      rh.iterate(&et);
      if (::testing::Test::HasFailure()) {
        return;
      }

      for (uintptr_t i = num_elements; i > 0; --i) {
        uintptr_t index = i - 1;
        ASSERT_TRUE((rh.remove(as_K(index))));
      }

      rh.iterate(&et);
      if (::testing::Test::HasFailure()) {
        return;
      }
      for (uintptr_t i = num_elements; i > 0; --i) {
        uintptr_t index = i - 1;
        ASSERT_FALSE(rh.remove(as_K(index)));
      }
      rh.iterate(&et);

      // Add more entries in and then delete one.
      for (uintptr_t i = 10; i > 0; --i) {
        uintptr_t index = i - 1;
        ASSERT_TRUE(rh.put(as_K(index), index));
      }
      DeleterTestIter dt(5);
      rh.unlink(&dt);
      ASSERT_FALSE(rh.get(as_K(5)));
    }
  };
};

TEST_VM_F(GenericHashTableTest, default) {
  ResourceMark rm;
  Runner<>::test();
}

TEST_VM_F(GenericHashTableTest, bad_hash) {
  ResourceMark rm;
  Runner<bad_hash>::test();
}

TEST_VM_F(GenericHashTableTest, identity_hash) {
  ResourceMark rm;
  Runner<identity_hash>::test();
}

TEST_VM_F(GenericHashTableTest, primitive_hash_no_rm) {
  Runner<primitive_hash<K>, primitive_equals<K>, 512, AnyObj::C_HEAP>::test();
}

TEST_VM_F(GenericHashTableTest, bad_hash_no_rm) {
  Runner<bad_hash, primitive_equals<K>, 512, AnyObj::C_HEAP>::test();
}

TEST_VM_F(GenericHashTableTest, identity_hash_no_rm) {
  Runner<identity_hash, primitive_equals<K>, 1, AnyObj::C_HEAP>::test(512);
}

// Simple HashTable whose key is a SymbolHandle and value is an int
// This test is to show that the SymbolHandle will correctly handle the refcounting
// in the table.
class SimpleHashTableDeleteTest : public ::testing::Test {
 public:
    HashTable<SymbolHandle, int, 107, AnyObj::C_HEAP, mtTest, SymbolHandle::compute_hash> _simple_test_table;

    class SimpleDeleter : public StackObj {
      public:
        bool do_entry(SymbolHandle& key, int value) {
          return true;
        }
    };
};

TEST_VM_F(SimpleHashTableDeleteTest, simple_remove) {
  TempNewSymbol t = SymbolTable::new_symbol("abcdefg_simple");
  Symbol* s = t;
  int s_orig_count = s->refcount();
  _simple_test_table.put(s, 55);
  ASSERT_EQ(s->refcount(), s_orig_count + 1) << "refcount should be incremented in table";

  // Deleting this value from a hashtable
  _simple_test_table.remove(s);
  ASSERT_EQ(s->refcount(), s_orig_count) << "refcount should be same as start";
}

TEST_VM_F(SimpleHashTableDeleteTest, simple_delete) {
  TempNewSymbol t = SymbolTable::new_symbol("abcdefg_simple");
  Symbol* s = t;
  int s_orig_count = s->refcount();
  _simple_test_table.put(s, 66);
  ASSERT_EQ(s->refcount(), s_orig_count + 1) << "refcount should be incremented in table";

  // Use unlink to remove the matching (or all) values from the table.
  SimpleDeleter deleter;
  _simple_test_table.unlink(&deleter);
  ASSERT_EQ(s->refcount(), s_orig_count) << "refcount should be same as start";
}

// More complicated HashTable with SymbolHandle in the key. Since the *same* Symbol is part
// of the value, it's not necessary to manipulate the refcount of the key, but you must in the value.
// Luckily SymbolHandle does this.
class HashTableDeleteTest : public ::testing::Test {
 public:
    class TestValue : public CHeapObj<mtTest> {
        SymbolHandle _s;
      public:
        // Never have ctors and dtors fix refcounts without copy ctors and assignment operators!
        // Unless it's declared and used as a CHeapObj with
        // NONCOPYABLE(TestValue)

        // Using SymbolHandle deals with refcount manipulation so this class doesn't have to
        // have dtors, copy ctors and assignment operators to do so.
        TestValue(Symbol* name) : _s(name) { }
        // Symbol* s() const { return _s; }  // needed for conversion from TempNewSymbol to SymbolHandle member
    };

    // HashTable whose value is a *copy* of TestValue.
    HashTable<Symbol*, TestValue, 107, AnyObj::C_HEAP, mtTest> _test_table;

    class Deleter : public StackObj {
      public:
        bool do_entry(Symbol*& key, TestValue& value) {
          // Since we didn't increment the key, we shouldn't decrement it.
          // Calling delete on the hashtable Node which contains value will
          // decrement the refcount.  That's actually best since the whole
          // entry will be gone at once.
          return true;
        }
    };

    // HashTable whose value is a pointer to TestValue.
    HashTable<Symbol*, TestValue*, 107, AnyObj::C_HEAP, mtTest> _ptr_test_table;

    class PtrDeleter : public StackObj {
      public:
        bool do_entry(Symbol*& key, TestValue*& value) {
          // If the hashtable value is a pointer, need to delete it from here.
          // This will also potentially make the refcount of the Key = 0, but the
          // next thing that happens is that the hashtable node is deleted so this is ok.
          delete value;
          return true;
        }
    };
};


TEST_VM_F(HashTableDeleteTest, value_remove) {
  TempNewSymbol s = SymbolTable::new_symbol("abcdefg");
  int s_orig_count = s->refcount();
  {
    TestValue tv(s);
    // Since TestValue contains the pointer to the key, it will handle the
    // refcounting.
    _test_table.put(s, tv);
    ASSERT_EQ(s->refcount(), s_orig_count + 2) << "refcount incremented by copy";
  }
  ASSERT_EQ(s->refcount(), s_orig_count + 1) << "refcount incremented in table";

  // Deleting this value from a hashtable calls the destructor!
  _test_table.remove(s);
  // Removal should make the refcount be the original refcount.
  ASSERT_EQ(s->refcount(), s_orig_count) << "refcount should be as we started";
}

TEST_VM_F(HashTableDeleteTest, value_delete) {
  TempNewSymbol d = SymbolTable::new_symbol("defghijklmnop");
  int d_orig_count = d->refcount();
  {
    TestValue tv(d);
    // Same as above, but the do_entry does nothing because the value is deleted when the
    // hashtable node is deleted.
    _test_table.put(d, tv);
    ASSERT_EQ(d->refcount(), d_orig_count + 2) << "refcount incremented by copy";
  }
  ASSERT_EQ(d->refcount(), d_orig_count + 1) << "refcount incremented in table";
  Deleter deleter;
  _test_table.unlink(&deleter);
  ASSERT_EQ(d->refcount(), d_orig_count) << "refcount should be as we started";
}

TEST_VM_F(HashTableDeleteTest, check_delete_ptr) {
  TempNewSymbol s = SymbolTable::new_symbol("abcdefg_ptr");
  int s_orig_count = s->refcount();
  {
    TestValue* tv = new TestValue(s);
    // Again since TestValue contains the pointer to the key Symbol, it will
    // handle the refcounting.
    _ptr_test_table.put(s, tv);
    ASSERT_EQ(s->refcount(), s_orig_count + 1) << "refcount incremented by allocation";
  }
  ASSERT_EQ(s->refcount(), s_orig_count + 1) << "refcount incremented in table";

  // Deleting this pointer value from a hashtable must call the destructor in the
  // do_entry function.
  PtrDeleter deleter;
  _ptr_test_table.unlink(&deleter);
  // Removal should make the refcount be the original refcount.
  ASSERT_EQ(s->refcount(), s_orig_count) << "refcount should be as we started";
}

class HashTablePrintTest : public ::testing::Test {
 public:
    class TestValue {
      int _i;
      int _j;
      int _k;
     public:
      TestValue(int i) : _i(i), _j(i+1), _k(i+2) {}
    };
    HashTable<int, TestValue*, 30, AnyObj::C_HEAP, mtTest> _test_table;

    class TableDeleter {
     public:
      bool do_entry(int& key, TestValue*& val) {
        delete val;
        return true;
      }
    };
};

TEST_VM_F(HashTablePrintTest, print_test) {
  for (int i = 0; i < 300; i++) {
    TestValue* tv = new TestValue(i);
    _test_table.put(i, tv);  // all the entries can be the same.
  }
  auto printer = [&] (int& key, TestValue*& val) {
    return sizeof(*val);
  };
  TableStatistics ts = _test_table.statistics_calculate(printer);
  ResourceMark rm;
  stringStream st;
  ts.print(&st, "TestTable");
  // Verify output in string
  const char* strings[] = {
      "Number of buckets", "Number of entries", "300", "Number of literals", "Average bucket size", "Maximum bucket size" };
  for (const auto& str : strings) {
    ASSERT_THAT(st.base(), testing::HasSubstr(str));
  }
  // Cleanup: need to delete pointers in entries
  TableDeleter deleter;
  _test_table.unlink(&deleter);
}
