Eine aufbereitete Darstellung der Quelle

 
     
 
 
Anforderungen  |   Konzepte  |   Entwurf  |   Entwicklung  |   Qualitätssicherung  |   Lebenszyklus  |   Steuerung
 
 
 
 
Benutzer

products/Sources/formale Sprachen/C/Firefox/mfbt/tests/   (Firefox Browser Version 153.0.1©)  Datei vom 27.6.2026 mit Größe 9 kB image not shown  

Quelle  TestHashTable.cpp

  Sprache: C 		 

/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this file,
 * You can obtain one at http://mozilla.org/MPL/2.0/. */

#include "mozilla/CompactPair.h"
#include "mozilla/HashTable.h"
#include "mozilla/PairHash.h"

#include <utility>

void TestMoveConstructor() {
  using namespace mozilla;

  HashMap<int, int> map;
  MOZ_RELEASE_ASSERT(map.putNew(3, 32));
  MOZ_RELEASE_ASSERT(map.putNew(4, 42));
  MOZ_RELEASE_ASSERT(map.count() == 2);
  MOZ_RELEASE_ASSERT(!map.empty());
  MOZ_RELEASE_ASSERT(!map.lookup(2));
  MOZ_RELEASE_ASSERT(map.lookup(3)->value() == 32);
  MOZ_RELEASE_ASSERT(map.lookup(4)->value() == 42);

  HashMap<int, int> moved = std::move(map);
  MOZ_RELEASE_ASSERT(moved.count() == 2);
  MOZ_RELEASE_ASSERT(!moved.empty());
  MOZ_RELEASE_ASSERT(!moved.lookup(2));
  MOZ_RELEASE_ASSERT(moved.lookup(3)->value() == 32);
  MOZ_RELEASE_ASSERT(moved.lookup(4)->value() == 42);

  MOZ_RELEASE_ASSERT(map.empty());
  MOZ_RELEASE_ASSERT(!map.count());
}

void CheckSwapMap1(const mozilla::HashMap<int, int>& map1) {
  MOZ_RELEASE_ASSERT(map1.count() == 2);
  MOZ_RELEASE_ASSERT(!map1.empty());
  MOZ_RELEASE_ASSERT(!map1.lookup(3));
  MOZ_RELEASE_ASSERT(!map1.lookup(4));
  MOZ_RELEASE_ASSERT(map1.lookup(1)->value() == 10);
  MOZ_RELEASE_ASSERT(map1.lookup(2)->value() == 20);
}

void CheckSwapMap2(const mozilla::HashMap<int, int>& map2) {
  MOZ_RELEASE_ASSERT(map2.count() == 2);
  MOZ_RELEASE_ASSERT(!map2.empty());
  MOZ_RELEASE_ASSERT(!map2.lookup(1));
  MOZ_RELEASE_ASSERT(!map2.lookup(2));
  MOZ_RELEASE_ASSERT(map2.lookup(3)->value() == 30);
  MOZ_RELEASE_ASSERT(map2.lookup(4)->value() == 40);
}

void TestSwap() {
  using namespace mozilla;

  HashMap<int, int> map1;
  MOZ_RELEASE_ASSERT(map1.putNew(1, 10));
  MOZ_RELEASE_ASSERT(map1.putNew(2, 20));
  CheckSwapMap1(map1);

  HashMap<int, int> map2;
  MOZ_RELEASE_ASSERT(map2.putNew(3, 30));
  MOZ_RELEASE_ASSERT(map2.putNew(4, 40));
  CheckSwapMap2(map2);

  map1.swap(map2);
  CheckSwapMap2(map1);
  CheckSwapMap1(map2);
}

enum SimpleEnum { SIMPLE_1, SIMPLE_2 };

enum class ClassEnum : int {
  CLASS_ENUM_1,
  CLASS_ENUM_2,
};

void TestEnumHash() {
  using namespace mozilla;

  HashMap<SimpleEnum, int> map;
  MOZ_RELEASE_ASSERT(map.put(SIMPLE_1, 1));
  MOZ_RELEASE_ASSERT(map.put(SIMPLE_2, 2));

  MOZ_RELEASE_ASSERT(map.lookup(SIMPLE_1)->value() == 1);
  MOZ_RELEASE_ASSERT(map.lookup(SIMPLE_2)->value() == 2);

  HashMap<ClassEnum, int> map2;
  MOZ_RELEASE_ASSERT(map2.put(ClassEnum::CLASS_ENUM_1, 1));
  MOZ_RELEASE_ASSERT(map2.put(ClassEnum::CLASS_ENUM_2, 2));

  MOZ_RELEASE_ASSERT(map2.lookup(ClassEnum::CLASS_ENUM_1)->value() == 1);
  MOZ_RELEASE_ASSERT(map2.lookup(ClassEnum::CLASS_ENUM_2)->value() == 2);
}

void TestHashPair() {
  using namespace mozilla;

  // Test with std::pair
  {
    HashMap<std::pair<int, bool>, int, PairHasher<int, bool>> map;
    std::pair<int, bool> key1 = std::make_pair(1, true);
    MOZ_RELEASE_ASSERT(map.putNew(key1, 1));
    MOZ_RELEASE_ASSERT(map.has(key1));
    std::pair<int, bool> key2 = std::make_pair(1, false);
    MOZ_RELEASE_ASSERT(map.putNew(key2, 1));
    std::pair<int, bool> key3 = std::make_pair(2, false);
    MOZ_RELEASE_ASSERT(map.putNew(key3, 2));
    MOZ_RELEASE_ASSERT(map.has(key3));

    MOZ_RELEASE_ASSERT(map.lookup(key1)->value() == 1);
    MOZ_RELEASE_ASSERT(map.lookup(key2)->value() == 1);
    MOZ_RELEASE_ASSERT(map.lookup(key3)->value() == 2);
  }
  // Test wtih compact pair
  {
    HashMap<mozilla::CompactPair<int, bool>, int, CompactPairHasher<int, bool>>
        map;
    mozilla::CompactPair<int, bool> key1 = mozilla::MakeCompactPair(1, true);
    MOZ_RELEASE_ASSERT(map.putNew(key1, 1));
    MOZ_RELEASE_ASSERT(map.has(key1));
    mozilla::CompactPair<int, bool> key2 = mozilla::MakeCompactPair(1, false);
    MOZ_RELEASE_ASSERT(map.putNew(key2, 1));
    mozilla::CompactPair<int, bool> key3 = mozilla::MakeCompactPair(2, false);
    MOZ_RELEASE_ASSERT(map.putNew(key3, 2));
    MOZ_RELEASE_ASSERT(map.has(key3));

    MOZ_RELEASE_ASSERT(map.lookup(key1)->value() == 1);
    MOZ_RELEASE_ASSERT(map.lookup(key2)->value() == 1);
    MOZ_RELEASE_ASSERT(map.lookup(key3)->value() == 2);
  }
}

void TestRekey() {
  using namespace mozilla;

  HashMap<int, int> map;
  MOZ_RELEASE_ASSERT(map.putNew(1, 10));
  MOZ_RELEASE_ASSERT(map.putNew(2, 20));
  MOZ_RELEASE_ASSERT(map.putNew(3, 30));

  // rekeyIfMoved: same key is a no-op.
  map.rekeyIfMoved(1, 1);
  MOZ_RELEASE_ASSERT(map.count() == 3);
  MOZ_RELEASE_ASSERT(map.lookup(1)->value() == 10);

  // rekeyIfMoved: replace an existing key.
  map.rekeyIfMoved(1, 11);
  MOZ_RELEASE_ASSERT(map.count() == 3);
  MOZ_RELEASE_ASSERT(!map.lookup(1));
  MOZ_RELEASE_ASSERT(map.lookup(11)->value() == 10);

  // rekeyIfMoved on a missing key is a no-op.
  map.rekeyIfMoved(99, 100);
  MOZ_RELEASE_ASSERT(map.count() == 3);
  MOZ_RELEASE_ASSERT(!map.lookup(99));
  MOZ_RELEASE_ASSERT(!map.lookup(100));

  // rekeyAs: returns true and replaces key when present.
  MOZ_RELEASE_ASSERT(map.rekeyAs(2, 22, 22));
  MOZ_RELEASE_ASSERT(map.count() == 3);
  MOZ_RELEASE_ASSERT(!map.lookup(2));
  MOZ_RELEASE_ASSERT(map.lookup(22)->value() == 20);

  // rekeyAs: returns false when the old key is absent.
  MOZ_RELEASE_ASSERT(!map.rekeyAs(2, 23, 23));
  MOZ_RELEASE_ASSERT(map.count() == 3);
  MOZ_RELEASE_ASSERT(!map.lookup(23));

  // Other entries are unaffected.
  MOZ_RELEASE_ASSERT(map.lookup(3)->value() == 30);
}

// A structure that holds an int and supports move semantics but not copy
// semantics.
struct WrappedInt {
  int mValue;

  explicit WrappedInt(int v) : mValue(v) {}

  WrappedInt(const WrappedInt&) = delete;
  WrappedInt& operator=(const WrappedInt&) = delete;

  WrappedInt(WrappedInt&& aOther) : mValue(aOther.mValue) { aOther.mValue = 0; }
  WrappedInt& operator=(WrappedInt&& aOther) {
    mValue = aOther.mValue;
    aOther.mValue = 0;
    return *this;
  }

  struct HashPolicy {
    using Key = WrappedInt;
    using Lookup = int;

    static mozilla::HashNumber hash(Lookup aLookup) { return aLookup; }

    static bool match(const Key& aKey, Lookup aLookup) {
      return aKey.mValue == aLookup;
    }

    static void rekey(Key& aKey, Key&& aNewKey) { aKey = std::move(aNewKey); }
  };
};

void TestRekeyWithRValue() {
  using namespace mozilla;

  HashMap<WrappedInt, int, WrappedInt::HashPolicy> map;
  MOZ_RELEASE_ASSERT(map.putNew(1, 10));
  MOZ_RELEASE_ASSERT(map.putNew(2, 20));
  MOZ_RELEASE_ASSERT(map.putNew(3, 30));

  // rekeyAs: replace an existing key.
  map.rekeyAs(1, 11, WrappedInt(11));
  MOZ_RELEASE_ASSERT(map.count() == 3);
  MOZ_RELEASE_ASSERT(!map.lookup(1));
  MOZ_RELEASE_ASSERT(map.lookup(11)->value() == 10);

  // rekeyAs on a missing key is a no-op.
  MOZ_RELEASE_ASSERT(!map.rekeyAs(99, 100, WrappedInt(100)));
  MOZ_RELEASE_ASSERT(map.count() == 3);
  MOZ_RELEASE_ASSERT(!map.lookup(99));
  MOZ_RELEASE_ASSERT(!map.lookup(100));

  // rekeyAs: returns true and replaces key when present.
  MOZ_RELEASE_ASSERT(map.rekeyAs(2, 22, WrappedInt(22)));
  MOZ_RELEASE_ASSERT(map.count() == 3);
  MOZ_RELEASE_ASSERT(!map.lookup(2));
  MOZ_RELEASE_ASSERT(map.lookup(22)->value() == 20);

  // rekeyAs: returns false when the old key is absent.
  MOZ_RELEASE_ASSERT(!map.rekeyAs(2, 23, WrappedInt(23)));
  MOZ_RELEASE_ASSERT(map.count() == 3);
  MOZ_RELEASE_ASSERT(!map.lookup(23));

  // Other entries are unaffected.
  MOZ_RELEASE_ASSERT(map.lookup(3)->value() == 30);
}

void TestModIteratorRekey() {
  using namespace mozilla;

  // Rekey one entry found during iteration.
  {
    HashMap<int, int> map;
    MOZ_RELEASE_ASSERT(map.putNew(1, 10));
    MOZ_RELEASE_ASSERT(map.putNew(2, 20));
    MOZ_RELEASE_ASSERT(map.putNew(3, 30));

    for (auto iter = map.modIter(); !iter.done(); iter.next()) {
      if (iter.get().key() == 2) {
        iter.rekey(22);
      }
    }

    MOZ_RELEASE_ASSERT(map.count() == 3);
    MOZ_RELEASE_ASSERT(!map.lookup(2));
    MOZ_RELEASE_ASSERT(map.lookup(22)->value() == 20);
    MOZ_RELEASE_ASSERT(map.lookup(1)->value() == 10);
    MOZ_RELEASE_ASSERT(map.lookup(3)->value() == 30);
  }

  // Rekey multiple entries.
  {
    HashMap<int, int> map;
    MOZ_RELEASE_ASSERT(map.putNew(1, 10));
    MOZ_RELEASE_ASSERT(map.putNew(2, 20));
    MOZ_RELEASE_ASSERT(map.putNew(3, 30));

    for (auto iter = map.modIter(); !iter.done(); iter.next()) {
      int key = iter.get().key();
      if (key > 0) {
        iter.rekey(-key);
      }
    }

    MOZ_RELEASE_ASSERT(map.count() == 3);
    MOZ_RELEASE_ASSERT(!map.lookup(1));
    MOZ_RELEASE_ASSERT(!map.lookup(2));
    MOZ_RELEASE_ASSERT(!map.lookup(3));
    MOZ_RELEASE_ASSERT(map.lookup(-1)->value() == 10);
    MOZ_RELEASE_ASSERT(map.lookup(-2)->value() == 20);
    MOZ_RELEASE_ASSERT(map.lookup(-3)->value() == 30);
  }
}

void TestCapacityAfterRemove() {
  mozilla::HashMap<int, int> map;
  MOZ_RELEASE_ASSERT(map.count() == 0);
  MOZ_RELEASE_ASSERT(map.capacity() == 0);

  MOZ_RELEASE_ASSERT(map.putNew(1, 1));
  MOZ_RELEASE_ASSERT(map.count() == 1);
  MOZ_RELEASE_ASSERT(map.capacity() != 0);

  map.remove(1);
  MOZ_RELEASE_ASSERT(map.count() == 0);
  MOZ_RELEASE_ASSERT(map.capacity() != 0);

  map.compact();
  MOZ_RELEASE_ASSERT(map.count() == 0);
  MOZ_RELEASE_ASSERT(map.capacity() == 0);

  MOZ_RELEASE_ASSERT(map.putNew(1, 1));
  MOZ_RELEASE_ASSERT(map.count() == 1);
  MOZ_RELEASE_ASSERT(map.capacity() != 0);

  {
    auto iter = map.modIter();
    MOZ_RELEASE_ASSERT(!iter.done());
    iter.remove();
  }
  MOZ_RELEASE_ASSERT(map.count() == 0);
  MOZ_RELEASE_ASSERT(map.capacity() != 0);

  map.compact();
  MOZ_RELEASE_ASSERT(map.count() == 0);
  MOZ_RELEASE_ASSERT(map.capacity() == 0);
}

int main() {
  TestMoveConstructor();
  TestEnumHash();
  TestHashPair();
  TestRekey();
  TestRekeyWithRValue();
  TestModIteratorRekey();
  TestCapacityAfterRemove();
  return 0;
}

Messung V0.5 in Prozent
C=95 H=93 G=93

¤ Dauer der Verarbeitung: 0.5 Sekunden  ¤

*© Formatika GbR, Deutschland




Wurzel

Suchen

PVS Prover

Isabelle Prover

NIST Cobol Testsuite

Cephes Mathematical Library

Vienna Development Method

Haftungshinweis

Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.

Bemerkung:

Die farbliche Syntaxdarstellung und die Messung sind noch experimentell.





                                                                                                                                                                                                                                                                                                                                                                                                     

Neuigkeiten

     Aktuelles
     Motto des Tages

Open Source Software

     Quellcodebibliothek
     Eigene Quellcodes
     Fremde Quellcodes
     Suchen
Jenseits des Üblichen ....
    

Besucherstatistik

Besucherstatistik
Statistik
#Sources=277311
#Domains=752002