chromium/v8/test/cctest/test-orderedhashtable.cc

// Copyright 2017 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include <utility>

#include "src/objects/objects-inl.h"
#include "src/objects/ordered-hash-table-inl.h"
#include "test/cctest/cctest.h"

namespace v8 {
namespace internal {
namespace test_orderedhashtable {

static Isolate* GetIsolateFrom(LocalContext* context) { … }

void CopyHashCode(DirectHandle<JSReceiver> from, DirectHandle<JSReceiver> to) { … }

void Verify(Isolate* isolate, DirectHandle<HeapObject> obj) { … }

// Helpers to abstract over differences in interfaces of the different ordered
// datastructures

template <typename T>
Handle<T> Add(Isolate* isolate, Handle<T> table, Handle<String> key1,
              Handle<String> value1, PropertyDetails details);

template <>
Handle<OrderedHashMap> Add(Isolate* isolate, Handle<OrderedHashMap> table,
                           Handle<String> key, Handle<String> value,
                           PropertyDetails details) { … }

template <>
Handle<OrderedHashSet> Add(Isolate* isolate, Handle<OrderedHashSet> table,
                           Handle<String> key, Handle<String> value,
                           PropertyDetails details) { … }

template <>
Handle<OrderedNameDictionary> Add(Isolate* isolate,
                                  Handle<OrderedNameDictionary> table,
                                  Handle<String> key, Handle<String> value,
                                  PropertyDetails details) { … }

// version for
// OrderedHashMap, OrderedHashSet
template <typename T>
bool HasKey(Isolate* isolate, Handle<T> table, Tagged<Object> key) { … }

template <>
bool HasKey(Isolate* isolate, Handle<OrderedNameDictionary> table,
            Tagged<Object> key) { … }

// version for
// OrderedHashTable, OrderedHashSet
template <typename T>
Handle<T> Delete(Isolate* isolate, Handle<T> table, Tagged<Object> key) { … }

template <>
Handle<OrderedNameDictionary> Delete(Isolate* isolate,
                                     Handle<OrderedNameDictionary> table,
                                     Tagged<Object> key) { … }

TEST(SmallOrderedHashSetInsertion) { … }

TEST(SmallOrderedHashMapInsertion) { … }

TEST(SmallOrderedHashSetDuplicateHashCode) { … }

TEST(SmallOrderedHashMapDuplicateHashCode) { … }

TEST(SmallOrderedHashSetGrow) { … }

TEST(SmallOrderedHashMapGrow) { … }

TEST(OrderedHashTableInsertion) { … }

TEST(OrderedHashMapDuplicateHashCode) { … }

TEST(OrderedHashMapDeletion) { … }

TEST(SmallOrderedHashMapDeletion) { … }

TEST(OrderedHashMapDuplicateHashCodeDeletion) { … }

TEST(SmallOrderedHashMapDuplicateHashCodeDeletion) { … }

TEST(OrderedHashSetDeletion) { … }

TEST(SmallOrderedHashSetDeletion) { … }

TEST(OrderedHashSetDuplicateHashCodeDeletion) { … }

TEST(SmallOrderedHashSetDuplicateHashCodeDeletion) { … }

TEST(OrderedHashSetHandlerInsertion) { … }

TEST(OrderedHashMapHandlerInsertion) { … }

TEST(OrderedHashSetHandlerDeletion) { … }

TEST(OrderedHashMapHandlerDeletion) { … }

TEST(OrderedNameDictionaryInsertion) { … }

TEST(OrderedNameDictionaryFindEntry) { … }

TEST(OrderedNameDictionaryValueAtAndValueAtPut) { … }

TEST(OrderedNameDictionaryDetailsAtAndDetailsAtPut) { … }

TEST(SmallOrderedNameDictionaryInsertion) { … }

TEST(SmallOrderedNameDictionaryInsertionMax) { … }

TEST(SmallOrderedNameDictionaryFindEntry) { … }

TEST(SmallOrderedNameDictionaryValueAtAndValueAtPut) { … }

TEST(SmallOrderedNameDictionaryDetailsAtAndDetailsAtPut) { … }

TEST(SmallOrderedNameDictionarySetAndMigrateHash) { … }

TEST(OrderedNameDictionarySetAndMigrateHash) { … }

TEST(OrderedNameDictionaryHandlerInsertion) { … }

TEST(OrderedNameDictionaryHandlerDeletion) { … }

TEST(OrderedNameDictionarySetEntry) { … }

TEST(SmallOrderedNameDictionarySetEntry) { … }

TEST(OrderedNameDictionaryDeleteEntry) { … }

TEST(SmallOrderedNameDictionaryDeleteEntry) { … }

template <typename T>
void TestEmptyOrderedHashTable(Isolate* isolate, Factory* factory,
                               Handle<T> table) { … }

TEST(ZeroSizeOrderedHashMap) { … }

TEST(ZeroSizeOrderedHashSet) { … }

TEST(ZeroSizeOrderedNameDictionary) { … }

}  // namespace test_orderedhashtable
}  // namespace internal
}  // namespace v8