int main()
{
HashMap map;
map.insert(1,10);
map.insert(20,200);
map.insert(3,30);
map.insert(99,990);
std::cout << "Expecting: 10" << std::endl;
std::cout << "Got: " << map.get(1) << std::endl;
std::cout << "Expecting: 200" << std::endl;
std::cout << "Got: " << map.get(20) << std::endl;
std::cout << "Expecting: 30" << std::endl;
std::cout << "Got: " << map.get(3) << std::endl;
std::cout << "Expecting: 990" << std::endl;
std::cout << "Got: " << map.get(99) << std::endl;
map.insert(99,888);
std::cout << "Expecting: 888" << std::endl;
std::cout << "Got: " << map.get(99) << std::endl;
return 0;
}
int main(int argc, const char * argv[]) {
// insert code here...
vector<vector<int> > numbers = { {2, 4, 3, 6, 8, 10},
{10, 2, 1, 2, 0, 1}, {8, 4, 9, 6, 0, 1},
{8, 4, 3, 6, 8, 4}, {0, 9, 8, 7, 5, 2},
{9, 4, 3, 6, 8, 10}, {1, 4, 3, 6, 8, 10},
{2, 4, 3, 6, 8, 10}, {7, 4, 3, 6, 5, 2}};
int length = int(numbers.size());
for (int i = 0; i < length; ++i) {
bool result = FindElement(numbers[i]);
cout << "result: " << result << endl;
}
/********************test two*************************/
HashMap sample;
vector<long> keys = {1, 2, 3, 4, 5, 6, 7, 8};
char a[16] = "test";
int length1 = int(keys.size());
for (int i = 0; i < length1; ++i) {
sample.insert(keys[i], a);
}
Node *res = sample.find(1);
cout << res->key << " " << res->value << endl;
for (int i = 0; i < 32; i++) {
int8_t a = static_cast<int8_t>(
static_cast<int>((rand() / static_cast<float>(RAND_MAX)) * 255));
cout << a << endl;
}
return 0;
}
int CountMaxContinusSequence(int a[], int n)
{
int maxLeng = 0;
for (int i = 0; i < n; ++i)
{
// ignore duplicated elements
if (hashMap.find(a[i]) != hashMap.end())
{
continue;
}
hashMap.insert(std::make_pair(a[i], 1));
if (hashMap.find(a[i] - 1) != hashMap.end())
{
maxLeng = Max(maxLeng, Merge(a[i] - 1, a[i]));
}
if (hashMap.find(a[i] + 1) != hashMap.end())
{
maxLeng = Max(maxLeng, Merge(a[i], a[i] + 1));
}
}
return maxLeng;
}
bool ConnectivityBase::isValid_(AtomContainer& ac)
{
static HashMap<Handle, PreciseTime> mod_times;
PreciseTime last_mod = ac.getModificationTime();
Handle mol_handle = ac.getHandle();
if (mod_times.has(mol_handle))
{
if (mod_times[mol_handle] == last_mod)
{
#ifdef BALL_QSAR_CONNECTIVITYBASE_DEBUG
cerr << ">> ConnectivityBase::isValid: molcule valid!" << endl;
#endif
return true;
}
else
{
mod_times[mol_handle] = last_mod;
#ifdef BALL_QSAR_CONNECTIVITYBASE_DEBUG
cerr << ">> ConnectivityBase::isValid: atom container not valid, modified!" << endl;
#endif
return false;
}
}
else
{
mod_times.insert(std::make_pair(mol_handle, last_mod));
#ifdef BALL_QSAR_CONNECTIVITYBASE_DEBUG
cerr << ">> ConnectivityBase::isValid: atom container not valid, first call!" << endl;
#endif
return false;
}
}
virtual void _Report_history(std::shared_ptr<library::XML> xml)
{
library::UniqueWriteLock uk(system_array_->getMutex());
//--------
// CONSTRUCT HISTORY
//--------
std::shared_ptr<PRInvokeHistory> history(new PRInvokeHistory());
history->construct(xml);
// IF THE HISTORY IS NOT EXIST IN PROGRESS, THEN TERMINATE REPORTING
auto progress_it = progress_list_.find(history->getUID());
if (progress_it == progress_list_.end())
return;
// ARCHIVE FIRST AND LAST INDEX
history->first_ = std::dynamic_pointer_cast<PRInvokeHistory>(progress_it->second.second)->getFirst();
history->last_ = std::dynamic_pointer_cast<PRInvokeHistory>(progress_it->second.second)->getLast();
// ERASE FROM ORDINARY PROGRESS AND MIGRATE TO THE HISTORY
progress_list_.erase(progress_it);
history_list_.insert({ history->getUID(), history });
// NOTIFY TO THE MANAGER, SYSTEM_ARRAY
((base::ParallelSystemArrayBase*)system_array_)->_Complete_history(history);
};
virtual void _Reply_data(std::shared_ptr<protocol::Invoke> invoke) override final
{
if (invoke->has("_History_uid") == true)
{
// REGISTER THIS PROCESS ON HISTORY LIST
std::shared_ptr<slave::InvokeHistory> history(new slave::InvokeHistory(invoke));
progress_list_.insert({ history->getUID(), history });
if (invoke->has("_Piece_first") == true)
{
// PARALLEL PROCESS
size_t first = invoke->get("_Piece_first")->getValue<size_t>();
size_t last = invoke->get("_Piece_last")->getValue<size_t>();
invoke->erase(invoke->end() - 2, invoke->end());
((base::ParallelSystemArrayBase*)system_array_)->sendPieceData(invoke, first, last);
}
else if (invoke->has("_Process_name") == true)
{
// DISTRIBUTED PROCESS
auto ds_system_array = (distributed::base::DistributedSystemArrayBase*)system_array_;
// FIND THE MATCHED ROLE
const std::string &process_name = invoke->get("_Process_name")->getValue<std::string>();
if (ds_system_array->hasProcess(process_name) == false)
return;
// SEND DATA VIA THE ROLE
auto process = ds_system_array->getProcess(process_name);
((distributed::base::DistributedProcessBase*)(process.get()))->sendData(invoke, 1.0);
}
}
else
replyData(invoke);
};
void
CirMgr::strash()
{
HashMap<myStrashKey, CirGate*> myHash;
for (size_t i = 0, dfsSize = _dfsOrder.size(); i < dfsSize; ++i)
{
CirGate* gate = _dfsOrder.at(i);
if (gate->getTypeStr() != "AIG") {
continue;
}
CirGate* existedGate = new Aig();
myStrashKey key(gate);
if (myHash.check(key, existedGate)) {
cout << "Strashing: " << existedGate->getId() << " merging " << gate->getId() << "..." << endl;
AigGateV newFanin(existedGate, 0);
gate->connectFaninToEachFanout(newFanin);
// clean up
deleteAndCleanUpGate(gate);
/* _dfsOrder.erase(_dfsOrder.begin() + i); */
/* --i, --dfsSize; */
} else {
myHash.insert(key, gate);
}
}
_dfsOrder.clear();
topoSort();
}
int main() {
HashMap<unsigned long, string> hmap;
hmap.insert(2, "Harsh");
string value;
hmap.find(2, value);
cout << value <<endl;
cout <<"Hash table size is "<<hmap.size()<<endl;
hmap.remove(2);
hmap.find(2, value);
cout <<"Hash table size is "<<hmap.size()<<endl;
}
void HashMap<K, T>::rehash(int i){
HashMap<K, T>* t = new HashMap<K, T>(i);
for(iterator it = this->begin(); it!=this->end(); ++it)
t->insert(it->key, it->value);
delete[] this->bucket;
this->bucket = t->bucket;
this->size = t->size;
this->deleted_counter = 0;
t->bucket=nullptr;
delete t;
}
int main()
{
//freopen("in.txt","r",stdin);
//freopen("out.txt","w",stdout);
int n,m;
long long val;
int len;
long long seed=13131313;
long long base=1;
bool ok;
myh.init();
scanf("%d %d",&n,&m);
while(n--)
{
scanf("%s",s);
myh.insert(myh.hash(s));
}
while(m--)
{
base=1;
ok=0;
scanf("%s",s);
val=myh.hash(s);
len=strlen(s);
for(int i=len-1;i>=0;--i)
{
for(int j=0;j<3;++j)
if(j!=s[i]-'a')
if(myh.match(((val+base*(j-(s[i]-'a'))%MOD+MOD)%MOD)))
{
ok=1;
break;
}
if(ok)
break;
base=(base*seed)%MOD;
}
if(ok)
puts("YES");
else
puts("NO");
}
return 0;
}
// Test string version.
TEST(HashTest, STRINGHash) {
using namespace eoaix;
HashMap<std::string, TestKey> htable;
TestKey t1(1, "1str");
TestKey t2(2, "2str");
TestKey t4(4, "4str");
htable.insert(std::string("2"), t2);
htable.insert(std::string("1"), t1);
TestKey* t3 = htable.find_val(std::string("1"));
EXPECT_EQ(t3->toString(), t1.toString());
EXPECT_EQ(htable.contains(std::string("1")), true);
EXPECT_EQ(htable.contains(std::string("4")), false) << "htable.contains(t4) != true\n";
}
int main()
{
ifstream cin("linkedmap.in");
ofstream cout("linkedmap.out");
string command, key;
while (cin >> command >> key)
if (command == "put")
{
string value;
cin >> value;
hashMap.insert(key, value);
}
void calculateResidueChi2Angles
(const Chain& fragment, HashMap<const Residue*,float>& residue_angles)
{
float angle = 0; //FLOAT_VALUE_NA;
// extract all residues: iterate over all composites and
// check whether they are Residues
ResidueConstIterator it = fragment.beginResidue();
for (; +it; ++it)
{
angle = calculateResidueChi2Angles(*it);
residue_angles.insert(std::pair<const Residue*, float>(&*it, angle));
}
}
int main(int argc, const char * argv[]) {
// insert code here...
HashMap sample;
vector<long> keys = {1, 2, 3, 4, 5, 6, 7, 8};
char a[16] = "test";
int length1 = int(keys.size());
for (int i = 0; i < length1; ++i) {
sample.insert(keys[i], a);
}
Node *res = sample.find(1);
cout << res->key << " " << res->value << endl;
return 0;
}
/* finds and inserts the full code in a hashmap */
HashMap::iterator find_code(Sym sym, HashMap& map) {
HashMap::iterator result = map.find(sym);
if (result == map.end()) { // new entry
const SymVec& args = sym.args();
vector<string> argstr(args.size());
for (unsigned i = 0; i < args.size(); ++i) {
argstr[i] = find_code(args[i], map)->second;
}
// write out the code
const FunDef& fun = get_element(sym.token());
string code = fun.c_print(argstr, vector<string>());
result = map.insert( make_pair(sym, code) ).first; // only want iterator
}
return result;
}
TEST(HashTest, ObjectHash) {
using namespace eoaix;
HashMap<TestKey, TestKey> htable;
TestKey t1(1, "1str");
TestKey t2(2, "2str");
TestKey t4(4, "4str");
htable.insert(t1, t2);
htable.insert(t2, t1);
TestKey* t3 = htable.find_val(t1);
// std::cout << t3->toString() << std::endl;
//std::cout << t2.toString() << std::endl;
EXPECT_EQ(t3->toString(), t2.toString());
EXPECT_EQ(htable.contains(t1), true);
EXPECT_EQ(htable.contains(t4), false) << "htable.contains(t4) != true\n";
}
HashMap::iterator find_entry(const Sym& sym, string& str, HashMap& map) {
HashMap::iterator result = map.find(sym);
if (result == map.end()) { // new entry
const SymVec& args = sym.args();
vector<string> argstr(args.size());
for (unsigned i = 0; i < args.size(); ++i) {
argstr[i] = find_entry(args[i], str, map)->second;
}
string var = make_var(map.size()); // map.size(): unique id
string code;
// write out the code
const FunDef& fun = get_element(sym.token());
code = fun.c_print(argstr, vector<string>() );
str += "double " + var + "=" + code + ";\n";
result = map.insert( make_pair(sym, var ) ).first; // only want iterator
}
return result;
}
//the functions for both procedures...
//--------------------1.get word-list---------------------------
HashMap *load_wordlist(const char *fname)
{
//lists of the vocabularies
cout << "---Opening vocab file '" << fname << "'" << endl;
ifstream ifs;
ifs.open(fname,ios::in);
CHECK_FILE(ifs,fname);
int num=0;
HashMap *res = new HashMap(CONS_vocab_map_size);
while (!ifs.eof()){
string buf;
ifs >> buf;
if (buf=="") continue; // HACK
string* tmp = new string(buf);
res->insert(pair<string*, int>(tmp, num++));
}
if(res->size() != num){
//sth wrong
Error("Something wrong with vocab file.");
}
cout << "---Done with loading vocab, all is " << num << endl;
return res;
}
void hashMap() {
HashMap<String, String> m;
//insert
assert("HashMap::insert()", m.insert("foo", "F00").second);
assert("HashMap::insert()", m.insert("bar", "B4R").second);
assert("HashMap::insert()", m.insert("baz", "B4Z").second);
assert("HashMap::size()", m.size() == 3);
//dupe insert
Pair<HashMap<String, String>::Iterator, bool> res = m.insert("foo", "whatev");
assert("HashMap::insert()", !res.second);
assert("HashMap::insert()", res.first != m.end());
assert("HashMap::insert()", res.first->first == "foo");
assert("HashMap::insert()", res.first->second == "F00");
//find
HashMap<String, String>::Iterator itr = m.find("bar");
assert("HashMap::find()", itr != m.end());
assert("HashMap::find()", itr->first == "bar");
assert("HashMap::find()", itr->second == "B4R");
//iterate
itr = m.begin();
assert("HashMap::begin()", itr != m.end());
++itr;
itr++;
++itr;
assert("HashMap::Iterator", itr == m.end());
//const iterator
HashMap<String, String>::ConstIterator citr = m.find("baz");
assert("cHashMap::find()", citr != m.end());
assert("cHashMap::find()", citr->first == "baz");
assert("cHashMap::find()", citr->second == "B4Z");
citr = m.begin();
assert("cHashMap::begin()", citr != m.end());
++citr;
citr++;
++citr;
assert("cHashMap::Iterator", citr == m.end());
//erase
assert("HashMap::erase()", m.erase("bar"));
assert("HashMap::erase()", m.size() == 2);
//copy constuctor
HashMap<String, String> copy(m);
assert("HashMap::HashMap(HashMap)", copy.size() == 2);
//erase by iterator
m.erase(m.find("baz"));
assert("HashMap::erase(Iterator)", m.size() == 1);
//clear
m.clear();
assert("HashMap::clear()", m.size() == 0);
itr = m.find("baz");
assert("HashMap::clear()", itr == m.end());
assert("HashMap::clear()", m.begin() == m.end());
//assignment operator
m = copy;
assert("HashMap::operator=", m.size() == 2);
//square bracket operator
m["norg"] = "N07G";
assert("HashMap::operator[]", m["foo"] == "F00");
}
void insertDfaOrigins(DfaVertex* dfaStatep) {
// Record the NFA states this dfa came from
uint32_t hash = hashDfaOrigins(dfaStatep);
m_hashMap.insert(make_pair(hash,dfaStatep));
}
bool SplitStrByIpay(const char *pcstr, UINT size, HashMap<UINT, std::string> & strList)
{
const char *pcend = pcstr + size;
if (strncmp(pcstr, TRANS_BEGIN, TRANS_COUNT) == 0)
{
pcstr += TRANS_COUNT;
}
while (pcstr < pcend)
{
while ((*pcstr == '"' || *pcstr == ',' || *pcstr=='{') && pcstr < pcend)
++pcstr;
//key;
string key, value;
const char *ps = pcstr;
while (ps < pcend)
{
if (*ps == '"')
break;
else
++ps;
}
if (*ps != '"')
break;
key.append(pcstr, ps - pcstr);
//value;
pcstr = ps + 2;
if (*pcstr == '"')
++pcstr;
if (pcstr >= pcend)
break;
ps = pcstr;
while (ps < pcend)
{
if (*ps == '"' || *ps == ',' || *ps == '}')
break;
else
++ps;
}
if (ps == pcend)
break;
value.append(pcstr, ps - pcstr);
//Log("Key:%s, Value:%s", key.c_str(), value.c_str());
for (UINT i = 0; i < key.size(); ++i)
((char*)key.c_str())[i] = ::tolower(key.c_str()[i]);
UINT crc = AECrc32(key.c_str(), key.size(), 0);
strList.insert(make_pair(crc, value));
pcstr = ps;
if (*pcstr == '}')
{
++pcstr;
break;
}
}
while (*pcstr == '}' || *pcstr == '&')
++pcstr;
if (pcstr < pcend && strncmp(pcstr, SIGN_STR, SIGN_COUNT) == 0)
{
pcstr += SIGN_COUNT;
if (pcstr >= pcend)
return false;
const char *ps = strchr(pcstr, '&');
if (ps < pcend)
{
string value;
value.append(pcstr, ps - pcstr);
//Log("Key:sign, Value:%s", value.c_str());
strList.insert(make_pair(SIGN_CRC, value));
}
}
return true;
}
int main(int argc, char **argv)
{
size_t nkeys = (1 << 16);
size_t nlookup = 100000;
double lf = 0.75;
if (argc >= 2)
{
int n;
if (sscanf(argv[1], "%d", &n) == 1)
{
std::cout << "Use " << n << " keys" << std::endl;
nkeys = size_t(n);
}
}
if (argc >= 3)
{
int l;
if (sscanf(argv[2], "%d", &l) == 1)
{
std::cout << "Do " << l << " lookups" << std::endl;
nlookup = size_t(l);
}
}
if (argc >= 4)
{
double d;
if (sscanf(argv[3], "%lf", &d) == 1)
{
std::cout << "Use max load factor: " << d << std::endl;
lf = d;
}
}
size_t ndups = 0;
std::cout << "Testing insertion and search with " << nkeys << " keys" << std::endl;
HashMap<std::string, std::string> hmap;
hmap.setMaxLoadFactor(lf);
std::vector<std::string> allKeys;
allKeys.resize(nkeys);
for (size_t i=0; i<nkeys; ++i)
{
std::string s = RandomString();
allKeys[i] = s;
if (!hmap.insert(s, s))
{
std::cout << "Duplicate key found: \"" << s << "\"" << std::endl;
++ndups;
}
}
std::cout << hmap.size() << " entries (" << ndups << " keys were duplicate)" << std::endl;
std::cout << "Load Factor of " << hmap.loadFactor() << std::endl;
for (size_t i=0; i<nkeys; ++i)
{
size_t ik = rand() % nkeys;
const std::string &k = allKeys[ik];
const std::string &v = hmap[k];
if (v != k)
{
throw std::runtime_error("key/value mistmatch");
}
}
HashMap<std::string, std::string>::KeyVector keys;
HashMap<std::string, std::string>::ValueVector vals;
hmap.keys(keys);
hmap.values(vals);
assert(hmap.size() == keys.size());
assert(hmap.size() == vals.size());
for (size_t i=0; i<hmap.size(); ++i)
{
if (keys[i] != vals[i])
{
throw std::runtime_error("key/value pair mismatch");
}
}
{
HashMap<std::string, std::string> hmap;
std::map<std::string, std::string> smap;
size_t numhits = 0;
hmap.setMaxLoadFactor(lf);
std::vector<std::string> allKeys, extraKeys;
std::string val;
allKeys.resize(nkeys);
extraKeys.resize(nkeys);
for (size_t i=0; i<nkeys; ++i)
{
allKeys[i] = RandomString();
extraKeys[i] = RandomString();
}
clock_t st, et;
std::cout << "Insert " << nkeys << " values in HashMap...";
st = clock();
for (size_t i=0; i<nkeys; ++i)
{
std::string &s = allKeys[i];
hmap.insert(s, s);
}
et = clock();
std::cout << double(et - st) / CLOCKS_PER_SEC << "(s)" << std::endl;
std::cout << "Do " << nlookup << " random access in HashMap ";
HashMap<std::string, std::string>::iterator hit;
st = clock();
numhits = 0;
for (size_t i=0; i<nlookup; ++i)
{
int keyi = RandomNumber(0, int(nkeys)-1);
std::string &k = (RandomNumber(0, 1) == 0 ? allKeys[keyi] : extraKeys[keyi]);
hit = hmap.find(k);
if (hit != hmap.end())
{
++numhits;
val = hit.value();
}
}
et = clock();
std::cout << double(et - st) / CLOCKS_PER_SEC << "(s) [" << numhits << " hit(s)]" << std::endl;
std::cout << "Insert " << nkeys << " values in std::map...";
st = clock();
for (size_t i=0; i<nkeys; ++i)
{
std::string &s = allKeys[i];
smap[s] = s;
}
et = clock();
std::cout << double(et - st) / CLOCKS_PER_SEC << "(s)" << std::endl;
std::cout << "Do " << nlookup << " random access in std::map ";
std::map<std::string, std::string>::iterator it;
st = clock();
numhits = 0;
for (size_t i=0; i<nlookup; ++i)
{
int keyi = RandomNumber(0, int(nkeys)-1);
std::string &k = (RandomNumber(0, 1) == 0 ? allKeys[keyi] : extraKeys[keyi]);
it = smap.find(k);
if (it != smap.end())
{
++numhits;
val = it->second;
}
}
et = clock();
std::cout << double(et - st) / CLOCKS_PER_SEC << "(s) [" << numhits << " hit(s)]" << std::endl;
std::cout << "Check HashMap consistency... ";
bool consistent = true;
for (size_t i=0; i<nkeys; ++i)
{
int keyi = RandomNumber(0, int(nkeys)-1);
std::string &k = (RandomNumber(0, 1) == 0 ? allKeys[keyi] : extraKeys[keyi]);
hit = hmap.find(k);
it = smap.find(k);
if (it == smap.end())
{
if (hit != hmap.end())
{
consistent = false;
break;
}
}
else
{
if (hit == hmap.end())
{
consistent = false;
break;
}
if (hit.value() != it->second)
{
consistent = false;
break;
}
}
}
std::cout << (consistent ? "Yes" : "No") << std::endl;
if (hmap.size() <= 100)
{
HashMap<std::string, std::string>::const_iterator cit = hmap.begin();
while (cit != hmap.end())
{
std::cout << cit.key() << " => " << cit.value() << std::endl;
++cit;
}
}
}
return 0;
}
void HaggleKernel::log_eventQueue(Metadata *m) {
HashMap<string, size_t> counts;
HashMap<string, size_t>::iterator cit;
Heap theHeap;
Metadata *dm = m->addMetadata("Events");
if (!dm) {
return;
}
List<Event *> list = getEventList();
for (List<Event *>::iterator it = list.begin(); it != list.end(); it++) {
Event *e = *it;
theHeap.insert(*it);
cit = counts.find(e->getName());
if (cit == counts.end()) {
counts.insert(make_pair(e->getName(), 1));
} else {
size_t count = (*cit).second;
counts.erase(cit);
counts.insert(make_pair(e->getName(), count+1));
}
}
for (size_t i = 0; i < list.size(); i++) {
Event *e = static_cast<Event *>(theHeap.extractFirst());
if (e) {
if (i < 200) {
Metadata *dmm = dm->addMetadata("Event");
dmm->setParameter("name", e->getName());
dmm->setParameter("time", e->getTimeout().getAsString());
dmm->setParameter("canceled", e->isCanceled() ? "true" : "false");
if (e->getDataObject()) {
dmm->setParameter("dObj", e->getDataObject()->getIdStr());
}
if (e->getNode()) {
dmm->setParameter("node", e->getNode()->getIdStr());
}
if (e->getInterface()) {
dmm->setParameter("iface", e->getInterface()->getIdentifierStr());
}
if (e->getNodeList().size() > 0) {
dmm->setParameter("nodeListSize", e->getNodeList().size());
}
if (e->getDataObjectList().size() > 0) {
dmm->setParameter("dataObjectListSize", e->getDataObjectList().size());
}
if (strcmp(e->getName(), "BFRemoveDelay") == 0) {
const DataObjectId_t *id = (DataObjectId_t *) e->getData();
if (id) {
dmm->setParameter("dObj", DataObject::idString(*id));
}
}
}
delete e;
}
}
dm = m->addMetadata("Counts");
if (!dm) {
return;
}
for (cit = counts.begin(); cit != counts.end(); cit++) {
Metadata *dmm = dm->addMetadata("Event");
if (dmm) {
dmm->setParameter("name", (*cit).first);
dmm->setParameter("count", (*cit).second);
}
}
}
void hashMapInt() {
HashMap<int, int> m;
//insert
assert("HashMap::insert()", m.insert(2, 5).second);
assert("HashMap::insert()", m.insert(3, 6).second);
assert("HashMap::insert()", m.insert(4, 7).second);
assert("HashMap::size()", m.size() == 3);
//dupe insert
Pair<HashMap<int, int>::Iterator, bool> res = m.insert(4, 8);
assert("HashMap::insert()", !res.second);
assert("HashMap::insert()", res.first != m.end());
assert("HashMap::insert()", res.first->first == 4);
assert("HashMap::insert()", res.first->second == 7);
//find
HashMap<int, int>::Iterator itr = m.find(3);
assert("HashMap::find()", itr != m.end());
assert("HashMap::find()", itr->first == 3);
assert("HashMap::find()", itr->second == 6);
//iterate
itr = m.begin();
assert("HashMap::begin()", itr != m.end());
++itr;
itr++;
++itr;
assert("HashMap::Iterator", itr == m.end());
//const iterator
HashMap<int, int>::ConstIterator citr = m.find(2);
assert("cHashMap::find()", citr != m.end());
assert("cHashMap::find()", citr->first == 2);
assert("cHashMap::find()", citr->second == 5);
citr = m.begin();
assert("cHashMap::begin()", citr != m.end());
++citr;
citr++;
++citr;
assert("cHashMap::Iterator", citr == m.end());
//erase
assert("HashMap::erase()", m.erase(3));
assert("HashMap::erase()", m.size() == 2);
//copy constuctor
HashMap<int, int> copy(m);
assert("HashMap::HashMap(HashMap)", copy.size() == 2);
//erase by iterator
m.erase(m.find(2));
assert("HashMap::erase(Iterator)", m.size() == 1);
//clear
m.clear();
assert("HashMap::clear()", m.size() == 0);
itr = m.find(4);
assert("HashMap::clear()", itr == m.end());
assert("HashMap::clear()", m.begin() == m.end());
//assignment operator
m = copy;
assert("HashMap::operator=", m.size() == 2);
//square bracket operator
m[9] = 10;
assert("HashMap::operator[]", m[2] == 5);
}
#include "catch.hpp"
#include "hashmap.hpp"
#include "bucketmap.hpp"
#include "hashmap_enhanced.cpp"
#include "bucketmap_enhanced.cpp"
#include "rbst.cpp"
TEST_CASE ( "Testing hashmap", "[HashMap]" ) {
HashMap map(5);
SECTION ( "Test insert method", "[insert]" ) {
map.insert( 1, 'a' );
map.insert( 6, 'f' );
map.insert( 11, 'k' );
map.insert( 2, 'b' );
map.insert( 45, 'd' );
bool failed = map.insert( 72, 'r' );
REQUIRE( failed == false );
char val;
map.print(std::cout);
REQUIRE( map.search(1, val) == true );
REQUIRE( val == 'a' );
REQUIRE( map.search(2, val) == true );
REQUIRE( val == 'b' );
std::cout << std::endl;
map.remove(6 , val);
REQUIRE( val == 'f' );
map.print(std::cout);
std::cout << std::endl;
REQUIRE( map.isEmpty() == false );
map.clear();
REQUIRE( map.isEmpty() == true );
