public void KeyIn54BitCheckAddEachSync()
{
KeyIn54BitCASHashTable hashTable = null;
try
{
hashTable = new KeyIn54BitCASHashTable(arrayLength, contentLength);
}
catch (Exception ex)
{
if (log.IsFatalEnabled)
{
log.Fatal(ex.Message + "\t" + ex.StackTrace);
}
}
var result = Utility.GetData().Result;
int SBPCounter = 0;
var SBPHashTable = new ConcurrentDictionary <string, int>();
int SBPId = 0;
//var stopWatch = new Stopwatch();
foreach (var record in result.EmptyIfNull())
{
if (!SBPHashTable.ContainsKey(record.sbp))
{
SBPId = Interlocked.Increment(ref SBPCounter);
SBPHashTable.TryAdd(record.sbp, SBPId);
}
else
{
SBPId = SBPHashTable[record.sbp];
}
//stopWatch.Restart();
try
{
Assert.AreEqual(hashTable.TrySet(record.linkId, record.clcId, SBPId, record.url), 0);
}
catch (Exception ex)
{
if (log.IsFatalEnabled)
{
log.Fatal(ex.Message + "\t" + ex.StackTrace);
}
}
//stopWatch.Stop();
//Console.WriteLine("Add one records" + "\t" + stopWatch.Elapsed.ToString());
}
}
public void KeyIn54BitCheckDeleteNotFound()
{
try
{
var hashTable = new KeyIn54BitCASHashTable(arrayLength, contentLength);
Assert.AreEqual(hashTable.TryDelete(2097151, 262143, 16383), -2);
}
catch (Exception ex)
{
if (log.IsFatalEnabled)
{
log.Fatal(ex.Message + "\t" + ex.StackTrace);
}
}
}
public void KeyIn54BitCheckGetNotFound()
{
try
{
var hashTable = new KeyIn54BitCASHashTable(arrayLength, contentLength);
byte[] output;
Assert.AreEqual(hashTable.TryGet(2097151, 262143, 16383, out output), -2);
Assert.IsNull(output);
}
catch (Exception ex)
{
if (log.IsFatalEnabled)
{
log.Fatal(ex.Message + "\t" + ex.StackTrace);
}
}
}
public void KeyIn54BitInitialize()
{
var stopWatch = new Stopwatch();
stopWatch.Start();
try
{
var hashTable = new KeyIn54BitCASHashTable(arrayLength, contentLength);
}
catch (Exception ex)
{
if (log.IsFatalEnabled)
{
log.Fatal(ex.Message + "\t" + ex.StackTrace);
}
}
stopWatch.Stop();
var ts = stopWatch.Elapsed;
Console.WriteLine("Create hash table" + "\t" + ts.ToString());
}
public void KeyIn54BitPerfTestingOneRecordVerifyResult()
{
var stopWatch = new Stopwatch();
KeyIn54BitCASHashTable hashTable = null;
try
{
hashTable = new KeyIn54BitCASHashTable(arrayLength, contentLength);
}
catch (Exception ex)
{
if (log.IsFatalEnabled)
{
log.Fatal(ex.Message + "\t" + ex.StackTrace);
}
}
var ts = stopWatch.Elapsed;
Console.WriteLine("Create hash table" + "\t" + ts.ToString());
stopWatch.Restart();
var result = Utility.GetData().Result;
stopWatch.Stop();
Console.WriteLine("Get " + result.Count + " data from database" + "\t" + stopWatch.Elapsed.ToString());
int SBPCounter = 0;
var SBPHashTable = new ConcurrentDictionary <string, int>();
int SBPId = 0;
stopWatch.Restart();
foreach (var record in result.EmptyIfNull())
{
if (!SBPHashTable.ContainsKey(record.sbp))
{
SBPId = Interlocked.Increment(ref SBPCounter);
SBPHashTable.TryAdd(record.sbp, SBPId);
}
else
{
SBPId = SBPHashTable[record.sbp];
}
try
{
hashTable.TrySet(record.linkId, record.clcId, SBPId, record.url);
}
catch (Exception ex)
{
if (log.IsFatalEnabled)
{
log.Fatal(ex.Message + "\t" + ex.StackTrace);
}
}
}
stopWatch.Stop();
Console.WriteLine("Add all records" + "\t" + stopWatch.Elapsed.ToString());
var mre = new ManualResetEvent(false);
bool getEnabled = true;
bool deleteEnabled = false;
bool updateEnabled = false;
Task tGet1 = null, tGet2 = null, tGet3 = null, tGet4 = null, tGet5 = null, tGet6 = null, tGet7 = null, tGet8 = null, tGet9 = null, tGet10 = null;
Task tDelete1 = null, tDelete2 = null, tDelete3 = null, tDelete4 = null, tDelete5 = null, tDelete6 = null, tDelete7 = null, tDelete8 = null, tDelete9 = null, tDelete10 = null;
Task tUpdate1 = null, tUpdate2 = null, tUpdate3 = null, tUpdate4 = null, tUpdate5 = null, tUpdate6 = null, tUpdate7 = null, tUpdate8 = null, tUpdate9 = null, tUpdate10 = null;
int totoalRecord = result.Count;
var rndTemp = new Random();
int seed = rndTemp.Next(totoalRecord);
var rnd = new Random(seed);
var index = rnd.Next(totoalRecord);
if (getEnabled)
{
tGet1 = Task.Run(() => { perfGetOneRecordVerifyResult(mre, hashTable, SBPHashTable, result, index); });
}
if (updateEnabled)
{
tUpdate1 = Task.Run(() => { perfUpdateOneRecordVerifyResult(mre, hashTable, SBPHashTable, result, index); });
}
if (deleteEnabled)
{
tDelete1 = Task.Run(() => { perfDeleteOneRecordVerifyResult(mre, hashTable, SBPHashTable, result, index); });
}
if (getEnabled)
{
tGet2 = Task.Run(() => { perfGetOneRecordVerifyResult(mre, hashTable, SBPHashTable, result, index); });
}
if (updateEnabled)
{
tUpdate2 = Task.Run(() => { perfUpdateOneRecordVerifyResult(mre, hashTable, SBPHashTable, result, index); });
}
if (deleteEnabled)
{
tDelete2 = Task.Run(() => { perfDeleteOneRecordVerifyResult(mre, hashTable, SBPHashTable, result, index); });
}
if (getEnabled)
{
tGet3 = Task.Run(() => { perfGetOneRecordVerifyResult(mre, hashTable, SBPHashTable, result, index); });
}
if (updateEnabled)
{
tUpdate3 = Task.Run(() => { perfUpdateOneRecordVerifyResult(mre, hashTable, SBPHashTable, result, index); });
}
if (deleteEnabled)
{
tDelete3 = Task.Run(() => { perfDeleteOneRecordVerifyResult(mre, hashTable, SBPHashTable, result, index); });
}
if (getEnabled)
{
tGet4 = Task.Run(() => { perfGetOneRecordVerifyResult(mre, hashTable, SBPHashTable, result, index); });
}
if (updateEnabled)
{
tUpdate4 = Task.Run(() => { perfUpdateOneRecordVerifyResult(mre, hashTable, SBPHashTable, result, index); });
}
if (deleteEnabled)
{
tDelete4 = Task.Run(() => { perfDeleteOneRecordVerifyResult(mre, hashTable, SBPHashTable, result, index); });
}
if (getEnabled)
{
tGet5 = Task.Run(() => { perfGetOneRecordVerifyResult(mre, hashTable, SBPHashTable, result, index); });
}
if (updateEnabled)
{
tUpdate5 = Task.Run(() => { perfUpdateOneRecordVerifyResult(mre, hashTable, SBPHashTable, result, index); });
}
if (deleteEnabled)
{
tDelete5 = Task.Run(() => { perfDeleteOneRecordVerifyResult(mre, hashTable, SBPHashTable, result, index); });
}
if (getEnabled)
{
tGet6 = Task.Run(() => { perfGetOneRecordVerifyResult(mre, hashTable, SBPHashTable, result, index); });
}
if (updateEnabled)
{
tUpdate6 = Task.Run(() => { perfUpdateOneRecordVerifyResult(mre, hashTable, SBPHashTable, result, index); });
}
if (deleteEnabled)
{
tDelete6 = Task.Run(() => { perfDeleteOneRecordVerifyResult(mre, hashTable, SBPHashTable, result, index); });
}
if (getEnabled)
{
tGet7 = Task.Run(() => { perfGetOneRecordVerifyResult(mre, hashTable, SBPHashTable, result, index); });
}
if (updateEnabled)
{
tUpdate7 = Task.Run(() => { perfUpdateOneRecordVerifyResult(mre, hashTable, SBPHashTable, result, index); });
}
if (deleteEnabled)
{
tDelete7 = Task.Run(() => { perfDeleteOneRecordVerifyResult(mre, hashTable, SBPHashTable, result, index); });
}
if (getEnabled)
{
tGet8 = Task.Run(() => { perfGetOneRecordVerifyResult(mre, hashTable, SBPHashTable, result, index); });
}
if (updateEnabled)
{
tUpdate8 = Task.Run(() => { perfUpdateOneRecordVerifyResult(mre, hashTable, SBPHashTable, result, index); });
}
if (deleteEnabled)
{
tDelete8 = Task.Run(() => { perfDeleteOneRecordVerifyResult(mre, hashTable, SBPHashTable, result, index); });
}
if (getEnabled)
{
tGet9 = Task.Run(() => { perfGetOneRecordVerifyResult(mre, hashTable, SBPHashTable, result, index); });
}
if (updateEnabled)
{
tUpdate9 = Task.Run(() => { perfUpdateOneRecordVerifyResult(mre, hashTable, SBPHashTable, result, index); });
}
if (deleteEnabled)
{
tDelete9 = Task.Run(() => { perfDeleteOneRecordVerifyResult(mre, hashTable, SBPHashTable, result, index); });
}
if (getEnabled)
{
tGet10 = Task.Run(() => { perfGetOneRecordVerifyResult(mre, hashTable, SBPHashTable, result, index); });
}
if (updateEnabled)
{
tUpdate10 = Task.Run(() => { perfUpdateOneRecordVerifyResult(mre, hashTable, SBPHashTable, result, index); });
}
if (deleteEnabled)
{
tDelete10 = Task.Run(() => { perfDeleteOneRecordVerifyResult(mre, hashTable, SBPHashTable, result, index); });
}
mre.Set();
stopWatch.Restart();
Task.WaitAll(
tGet1, tGet2, tGet3, tGet4, tGet5, tGet6, tGet7, tGet8, tGet9, tGet10
, tDelete1, tDelete2, tDelete3, tDelete4, tDelete5, tDelete6, tDelete7, tDelete8, tDelete9, tDelete10
, tUpdate1, tUpdate2, tUpdate3, tUpdate4, tUpdate5, tUpdate6, tUpdate7, tUpdate8, tUpdate9, tUpdate10
);
stopWatch.Stop();
ts = stopWatch.Elapsed;
Console.WriteLine("Finish all tast in" + "\t" + ts.ToString());
}
public void KeyIn54BitCheckUpdateBringDeletedBack()
{
KeyIn54BitCASHashTable hashTable = null;
try
{
hashTable = new KeyIn54BitCASHashTable(arrayLength, contentLength);
}
catch (Exception ex)
{
if (log.IsFatalEnabled)
{
log.Fatal(ex.Message + "\t" + ex.StackTrace);
}
}
var result = Utility.GetData().Result;
int SBPCounter = 0;
var SBPHashTable = new ConcurrentDictionary <string, int>();
int SBPId = 0;
foreach (var record in result.EmptyIfNull())
{
if (!SBPHashTable.ContainsKey(record.sbp))
{
SBPId = Interlocked.Increment(ref SBPCounter);
SBPHashTable.TryAdd(record.sbp, SBPId);
}
else
{
SBPId = SBPHashTable[record.sbp];
}
try
{
Assert.AreEqual(hashTable.TrySet(record.linkId, record.clcId, SBPId, record.url), 0);
}
catch (Exception ex)
{
if (log.IsFatalEnabled)
{
log.Fatal(ex.Message + "\t" + ex.StackTrace);
}
}
}
string message = string.Empty;
byte[] output;
foreach (var record in result.EmptyIfNull())
{
SBPId = SBPHashTable[record.sbp];
try
{
Assert.AreEqual(hashTable.TryDelete(record.linkId, record.clcId, SBPId), 0);
}
catch (Exception ex)
{
if (log.IsFatalEnabled)
{
log.Fatal(ex.Message + "\t" + ex.StackTrace);
}
}
output = null;
try
{
Assert.AreEqual(hashTable.TryGet(record.linkId, record.clcId, SBPId, out output), -3);
}
catch (Exception ex)
{
if (log.IsFatalEnabled)
{
log.Fatal(ex.Message + "\t" + ex.StackTrace);
}
}
Assert.IsNull(output);
}
var u8 = Encoding.UTF8;
//Update all the records again.
foreach (var record in result.EmptyIfNull())
{
SBPId = SBPHashTable[record.sbp];
try
{
Assert.AreEqual(hashTable.TrySet(record.linkId, record.clcId, SBPId, record.url), 1);
}
catch (Exception ex)
{
if (log.IsFatalEnabled)
{
log.Fatal(ex.Message + "\t" + ex.StackTrace);
}
}
}
//We should get all the URL again.
output = null;
foreach (var record in result.EmptyIfNull())
{
SBPId = SBPHashTable[record.sbp];
try
{
Assert.AreEqual(hashTable.TryGet(record.linkId, record.clcId, SBPId, out output), 0);
}
catch (Exception ex)
{
if (log.IsFatalEnabled)
{
log.Fatal(ex.Message + "\t" + ex.StackTrace);
}
}
Assert.AreEqual(u8.GetString(record.url), u8.GetString(output));
}
}
public void KeyIn54BitCheckUpdate()
{
KeyIn54BitCASHashTable hashTable = null;
try
{
hashTable = new KeyIn54BitCASHashTable(arrayLength, contentLength);
}
catch (Exception ex)
{
if (log.IsFatalEnabled)
{
log.Fatal(ex.Message + "\t" + ex.StackTrace);
}
}
var result = Utility.GetDataArrayList().Result;
int SBPCounter = 0;
var SBPHashTable = new ConcurrentDictionary <string, int>();
int SBPId = 0;
for (var i = 0; i < result.Count; i++)
{
if (!SBPHashTable.ContainsKey(((Record)result[i]).sbp))
{
SBPId = Interlocked.Increment(ref SBPCounter);
SBPHashTable.TryAdd(((Record)result[i]).sbp, SBPId);
}
else
{
SBPId = SBPHashTable[((Record)result[i]).sbp];
}
try
{
Assert.AreEqual(hashTable.TrySet(((Record)result[i]).linkId, ((Record)result[i]).clcId, SBPId, ((Record)result[i]).url), 0);
}
catch (Exception ex)
{
if (log.IsFatalEnabled)
{
log.Fatal(ex.Message + "\t" + ex.StackTrace);
}
}
}
var temp = new byte[hashTable.ContentLength];
for (int i = 0; i < hashTable.ContentLength; i++)
{
temp[i] = 0;
}
for (var i = 0; i < result.Count; i++)
{
for (var j = 0; j < ((Record)result[i]).url.Length; j++)
{
((Record)result[i]).url[j] = 0xFF;
}
}
var u8 = Encoding.UTF8;
byte[] output = null;
for (var i = 0; i < result.Count; i++)
{
SBPId = SBPHashTable[((Record)result[i]).sbp];
try
{
Assert.AreEqual(hashTable.TryGet(((Record)result[i]).linkId, ((Record)result[i]).clcId, SBPId, out output), 0);
}
catch (Exception ex)
{
if (log.IsFatalEnabled)
{
log.Fatal(ex.Message + "\t" + ex.StackTrace);
}
}
if (((Record)result[i]).url.Length == 0)
{
Assert.AreNotEqual("haha", u8.GetString(output));
}
else
{
Assert.AreNotEqual(u8.GetString(((Record)result[i]).url), u8.GetString(output));
}
output = null;
}
for (var i = 0; i < result.Count; i++)
{
SBPId = SBPHashTable[((Record)result[i]).sbp];
try
{
Assert.AreEqual(hashTable.TrySet(((Record)result[i]).linkId, ((Record)result[i]).clcId, SBPId, ((Record)result[i]).url), 1);
}
catch (Exception ex)
{
if (log.IsFatalEnabled)
{
log.Fatal(ex.Message + "\t" + ex.StackTrace);
}
}
}
for (var i = 0; i < result.Count; i++)
{
SBPId = SBPHashTable[((Record)result[i]).sbp];
try
{
Assert.AreEqual(hashTable.TryGet(((Record)result[i]).linkId, ((Record)result[i]).clcId, SBPId, out output), 0);
}
catch (Exception ex)
{
if (log.IsFatalEnabled)
{
log.Fatal(ex.Message + "\t" + ex.StackTrace);
}
}
Assert.AreEqual(u8.GetString(((Record)result[i]).url), u8.GetString(output));
output = null;
}
}
public void KeyIn54BitCheckDeleteAgain()
{
var stopWatch = new Stopwatch();
KeyIn54BitCASHashTable hashTable = null;
try
{
hashTable = new KeyIn54BitCASHashTable(arrayLength, contentLength);
}
catch (Exception ex)
{
if (log.IsFatalEnabled)
{
log.Fatal(ex.Message + "\t" + ex.StackTrace);
}
}
var result = Utility.GetData().Result;
int SBPCounter = 0;
var SBPHashTable = new ConcurrentDictionary <string, int>();
int SBPId = 0;
foreach (var record in result.EmptyIfNull())
{
if (!SBPHashTable.ContainsKey(record.sbp))
{
SBPId = Interlocked.Increment(ref SBPCounter);
SBPHashTable.TryAdd(record.sbp, SBPId);
}
else
{
SBPId = SBPHashTable[record.sbp];
}
try
{
Assert.AreEqual(hashTable.TrySet(record.linkId, record.clcId, SBPId, record.url), 0);
}
catch (Exception ex)
{
if (log.IsFatalEnabled)
{
log.Fatal(ex.Message + "\t" + ex.StackTrace);
}
}
}
byte[] output;
foreach (var record in result.EmptyIfNull())
{
SBPId = SBPHashTable[record.sbp];
try
{
Assert.AreEqual(hashTable.TryDelete(record.linkId, record.clcId, SBPId), 0);
}
catch (Exception ex)
{
if (log.IsFatalEnabled)
{
log.Fatal(ex.Message + "\t" + ex.StackTrace);
}
}
output = null;
try
{
Assert.AreEqual(hashTable.TryGet(record.linkId, record.clcId, SBPId, out output), -3);
}
catch (Exception ex)
{
if (log.IsFatalEnabled)
{
log.Fatal(ex.Message + "\t" + ex.StackTrace);
}
}
Assert.IsNull(output);
}
output = null;
//Delete all the records again and nothing should happens.
foreach (var record in result.EmptyIfNull())
{
SBPId = SBPHashTable[record.sbp];
try
{
Assert.AreEqual(hashTable.TryDelete(record.linkId, record.clcId, SBPId), -3);
}
catch (Exception ex)
{
if (log.IsFatalEnabled)
{
log.Fatal(ex.Message + "\t" + ex.StackTrace);
}
}
output = null;
try
{
Assert.AreEqual(hashTable.TryGet(record.linkId, record.clcId, SBPId, out output), -3);
}
catch (Exception ex)
{
if (log.IsFatalEnabled)
{
log.Fatal(ex.Message + "\t" + ex.StackTrace);
}
}
Assert.IsNull(output);
}
}
public void KeyIn54BitCheckDeleteInvildInput()
{
KeyIn54BitCASHashTable hashTable = null;
try
{
hashTable = new KeyIn54BitCASHashTable(arrayLength, contentLength);
}
catch (Exception ex)
{
if (log.IsFatalEnabled)
{
log.Fatal(ex.Message + "\t" + ex.StackTrace);
}
}
try
{
string message = null;
try { hashTable.TryDelete(0, 1, 1); }
catch (ArgumentOutOfRangeException e)
{ message = e.Message; }
Assert.IsTrue(message.Contains("linkId"));
message = null;
try { hashTable.TryDelete(4194304, 1, 1); }
catch (ArgumentOutOfRangeException e)
{ message = e.Message; }
Assert.IsTrue(message.Contains("linkId"));
message = null;
try { hashTable.TryDelete(1, 0, 1); }
catch (ArgumentOutOfRangeException e)
{ message = e.Message; }
Assert.IsTrue(message.Contains("clcId"));
message = null;
try { hashTable.TryDelete(1, 262144, 1); }
catch (ArgumentOutOfRangeException e)
{ message = e.Message; }
Assert.IsTrue(message.Contains("clcId"));
message = null;
try { hashTable.TryDelete(1, 1, 0); }
catch (ArgumentOutOfRangeException e)
{ message = e.Message; }
Assert.IsTrue(message.Contains("sbp"));
message = null;
try { hashTable.TryDelete(1, 1, 16384); }
catch (ArgumentOutOfRangeException e)
{ message = e.Message; }
Assert.IsTrue(message.Contains("sbp"));
}
catch (Exception ex)
{
if (log.IsFatalEnabled)
{
log.Fatal(ex.Message + "\t" + ex.StackTrace);
}
}
}
public void KeyIn54BitCheckAddTotalSync()
{
var stopWatch = new Stopwatch();
KeyIn54BitCASHashTable hashTable = null;
try
{
hashTable = new KeyIn54BitCASHashTable(arrayLength, contentLength);
}
catch (Exception ex)
{
if (log.IsFatalEnabled)
{
log.Fatal(ex.Message + "\t" + ex.StackTrace);
}
}
var ts = stopWatch.Elapsed;
Console.WriteLine("Create hash table" + "\t" + ts.ToString());
stopWatch.Restart();
var result = Utility.GetData().Result;
stopWatch.Stop();
Console.WriteLine("Get " + result.Count + " data from database" + "\t" + stopWatch.Elapsed.ToString());
int SBPCounter = 0;
var SBPHashTable = new ConcurrentDictionary <string, int>();
int SBPId = 0;
stopWatch.Restart();
foreach (var record in result.EmptyIfNull())
{
if (!SBPHashTable.ContainsKey(record.sbp))
{
SBPId = Interlocked.Increment(ref SBPCounter);
SBPHashTable.TryAdd(record.sbp, SBPId);
}
else
{
SBPId = SBPHashTable[record.sbp];
}
try
{
Assert.AreEqual(hashTable.TrySet(record.linkId, record.clcId, SBPId, record.url), 0);
}
catch (Exception ex)
{
if (log.IsFatalEnabled)
{
log.Fatal(ex.Message + "\t" + ex.StackTrace);
}
}
}
stopWatch.Stop();
Console.WriteLine("Add all records" + "\t" + stopWatch.Elapsed.ToString());
var u8 = Encoding.UTF8;
byte[] output = null;
foreach (var record in result)
{
SBPId = SBPHashTable[record.sbp];
try
{
Assert.AreEqual(hashTable.TryGet(record.linkId, record.clcId, SBPId, out output), 0);
}
catch (Exception ex)
{
if (log.IsFatalEnabled)
{
log.Fatal(ex.Message + "\t" + ex.StackTrace);
}
}
Assert.AreEqual(u8.GetString(record.url), u8.GetString(output));
output = null;
}
}
public void KeyIn54BitCheckGetDeleted()
{
KeyIn54BitCASHashTable hashTable = null;
try
{
hashTable = new KeyIn54BitCASHashTable(arrayLength, contentLength);
}
catch (Exception ex)
{
if (log.IsFatalEnabled)
{
log.Fatal(ex.Message + "\t" + ex.StackTrace);
}
}
var result = Utility.GetData().Result;
int SBPCounter = 0;
var SBPHashTable = new ConcurrentDictionary <string, int>();
int SBPId = 0;
int i = 0;
long linkIdTemp = 0;
long clcIdTemp = 0;
long SBPIdTemp = 0;
foreach (var record in result.EmptyIfNull())
{
if (!SBPHashTable.ContainsKey(record.sbp))
{
SBPId = Interlocked.Increment(ref SBPCounter);
SBPHashTable.TryAdd(record.sbp, SBPId);
}
else
{
SBPId = SBPHashTable[record.sbp];
}
try
{
Assert.AreEqual(hashTable.TrySet(record.linkId, record.clcId, SBPId, record.url), 0);
}
catch (Exception ex)
{
if (log.IsFatalEnabled)
{
log.Fatal(ex.Message + "\t" + ex.StackTrace);
}
}
if (i++ == 1)
{
linkIdTemp = record.linkId;
clcIdTemp = record.clcId;
SBPIdTemp = SBPId;
}
}
try
{
Assert.AreEqual(hashTable.TryDelete(linkIdTemp, clcIdTemp, SBPIdTemp), 0);
byte[] output = null;
Assert.AreEqual(hashTable.TryGet(linkIdTemp, clcIdTemp, SBPIdTemp, out output), -3);
Assert.IsNull(output);
}
catch (Exception ex)
{
if (log.IsFatalEnabled)
{
log.Fatal(ex.Message + "\t" + ex.StackTrace);
}
}
}
public void KeyIn54BitCheckAddInvildInput()
{
KeyIn54BitCASHashTable hashTable = null;
try
{
hashTable = new KeyIn54BitCASHashTable(arrayLength, contentLength);
}
catch (Exception ex)
{
if (log.IsFatalEnabled)
{
log.Fatal(ex.Message + "\t" + ex.StackTrace);
}
}
try
{
var temp0 = new byte[hashTable.ContentLength];
for (int i = 0; i < hashTable.ContentLength; i++)
{
temp0[i] = 0;
}
var temp = new byte[hashTable.ContentLength + 1];
for (int i = 0; i < hashTable.ContentLength + 1; i++)
{
temp[i] = 0;
}
string message = null;
try { hashTable.TrySet(0, 1, 1, temp0); }
catch (ArgumentOutOfRangeException e)
{ message = e.Message; }
Assert.IsTrue(message.Contains("linkId"));
message = null;
try { hashTable.TrySet(4194304, 1, 1, temp0); }
catch (ArgumentOutOfRangeException e)
{ message = e.Message; }
Assert.IsTrue(message.Contains("linkId"));
message = null;
try { hashTable.TrySet(1, 0, 1, temp0); }
catch (ArgumentOutOfRangeException e)
{ message = e.Message; }
Assert.IsTrue(message.Contains("clcId"));
message = null;
try { hashTable.TrySet(1, 262144, 1, temp0); }
catch (ArgumentOutOfRangeException e)
{ message = e.Message; }
Assert.IsTrue(message.Contains("clcId"));
message = null;
try { hashTable.TrySet(1, 1, 0, temp0); }
catch (ArgumentOutOfRangeException e)
{ message = e.Message; }
Assert.IsTrue(message.Contains("sbp"));
message = null;
try { hashTable.TrySet(1, 1, 16384, temp0); }
catch (ArgumentOutOfRangeException e)
{ message = e.Message; }
Assert.IsTrue(message.Contains("sbp"));
message = null;
try { hashTable.TrySet(4194303, 262143, 16383, null); }
catch (ArgumentNullException e)
{ message = e.Message; }
Assert.IsTrue(message.Contains("contentLength"));
message = null;
try { hashTable.TrySet(4194303, 262143, 16383, temp); }
catch (ArgumentOutOfRangeException e)
{ message = e.Message; }
Assert.IsTrue(message.Contains("contentLength"));
}
catch (Exception ex)
{
if (log.IsFatalEnabled)
{
log.Fatal(ex.Message + "\t" + ex.StackTrace);
}
}
}
