public void PQueueTest()
{
// initializing...
var list = DefaultRNG.I32.Take(777).ToList();
var pq = new PriorityQueue <int>(list);
// adding items...
1048576.Times(() => {
var x = DefaultRNG.Next();
pq.Add(x);
list.Add(x);
});
1025.Times(() => {
var x = DefaultRNG.I32.Take(1023).ToList();
pq.AddRange(x);
list.AddRange(x);
});
// check it.
list.Sort();
Assert.Equal(list, pq.ToList());
int len = 777 + 1048576 + 1025 * 1023;
Assert.Equal(len, pq.Count);
Assert.Equal((int)Ceil2((ulong)len), pq.Capacity);
// empty pq.
for (int i = 0; i < len; ++i)
{
Assert.Equal(list[i], pq.Peek());
Assert.Equal(list[i], pq.Pop());
}
Assert.Equal(0, pq.Count);
// it's empty now.
Assert.Throws <InvalidOperationException>(() => { pq.Peek(); });
Assert.Throws <InvalidOperationException>(() => { pq.Pop(); });
Assert.Empty(pq.ToArray());
Assert.Equal((int)Ceil2((ulong)len), pq.Capacity);
31.Times(() => {
var x = DefaultRNG.I32.Take(33).ToList();
pq.AddRange(x);
list.AddRange(x);
});
Assert.Equal((int)Ceil2((ulong)len), pq.Capacity);
Assert.Throws <ArgumentOutOfRangeException>(() => { pq.Capacity = PriorityQueue <int> .MinimumItemsLength; });
pq.Clear();
Assert.Equal(0, pq.Count);
Assert.Equal((int)Ceil2((ulong)len), pq.Capacity);
pq.Reset();
Assert.Equal(0, pq.Count);
Assert.Equal(PriorityQueue <int> .MinimumItemsLength, pq.Capacity);
}
public void DefaultRNGTests()
{
DefaultRNG.I32.Next();
DefaultRNG.U64.Next();
DefaultRNG.Coin.Next();
DefaultRNG.Next();
DefaultRNG.NextU64();
DefaultRNG.NextDouble();
}
public void OrderByWithLimitWithIndex()
{
var test = new MemoryStorage().CreateDatabase("db").CreateTable <TestStructClean>();
var typed = new Table <long, TestStructClean>(test);
var collisionCheck = new Set <int>();
for (var i = 0; i < 1000; i++)
{
var content = string.Empty;
while (content.Length == 0)
{
content = DefaultRNG.GetPassword(DefaultRNG.UInt8 % 16, ASCII.Strings.Letters);
}
var integer = content.GetHashCode();
while (collisionCheck.Contains(integer))
{
integer++;
}
collisionCheck.Add(integer);
typed.Replace(new TestStructClean()
{
ID = 1 + i % 100,
I = integer,
Text = content,
Date = DateTime.UtcNow + new TimeSpan(integer * TimeSpan.TicksPerSecond),
});
}
typed.Delete(1);
var array = typed.GetStructs();
CollectionAssert.AreEqual(array.OrderBy(a => a.I), typed.GetStructs(Search.None, ResultOption.SortAscending(nameof(TestStructClean.I))));
CollectionAssert.AreEqual(array.OrderBy(a => a.Date), typed.GetStructs(Search.None, ResultOption.SortAscending(nameof(TestStructClean.Date))));
CollectionAssert.AreEqual(array.OrderByDescending(a => a.I), typed.GetStructs(Search.None, ResultOption.SortDescending(nameof(TestStructClean.I))));
CollectionAssert.AreEqual(array.OrderByDescending(a => a.Date), typed.GetStructs(Search.None, ResultOption.SortDescending(nameof(TestStructClean.Date))));
CollectionAssert.AreEqual(
array.OrderBy(a => a.I).SubRange(0, 3),
typed.GetStructs(Search.None, ResultOption.SortAscending(nameof(TestStructClean.I)) + ResultOption.Limit(3)));
CollectionAssert.AreEqual(
array.OrderByDescending(a => a.I).SubRange(0, 3),
typed.GetStructs(Search.None, ResultOption.SortDescending(nameof(TestStructClean.I)) + ResultOption.Limit(3)));
CollectionAssert.AreEqual(
array.OrderBy(a => a.Date).SubRange(0, 3),
typed.GetStructs(Search.None, ResultOption.SortAscending(nameof(TestStructClean.Date)) + ResultOption.Limit(3)));
CollectionAssert.AreEqual(
array.OrderByDescending(a => a.Date).SubRange(0, 3),
typed.GetStructs(Search.None, ResultOption.SortDescending(nameof(TestStructClean.Date)) + ResultOption.Limit(3)));
}
public Credentials(long id, string p_Email, DomainDns domainDns)
{
DomainDns = domainDns;
Email = p_Email;
PlainPassword = DefaultRNG.GetPassword(25, ASCII.Strings.SafeUrlOptions);
var dom = new DynDnsDomain()
{
ID = id,
Username = domainDns.Name,
};
dom.CreatePasswordHash(PlainPassword);
DynDnsDomain = dom;
}
public Mt19937X64() : this(DefaultRNG.NextU64())
{
}
public Mt19937() : this(unchecked ((uint)DefaultRNG.Next()))
{
}
public LCG64() : this(DefaultRNG.NextU64())
{
}
public LCG() : this(unchecked ((uint)DefaultRNG.Next()))
{
}
void ReadClient(object state)
{
var e = (TcpServerClientEventArgs <TcpAsyncClient>)state;
e.Client.Stream.ReadTimeout = Timeout;
e.Client.Stream.WriteTimeout = Timeout;
StreamReader reader = new StreamReader(e.Client.Stream, Encoding.ASCII);
StreamWriter writer = new StreamWriter(e.Client.Stream, Encoding.ASCII);
string serverSalt = Base64.NoPadding.Encode(DefaultRNG.Get(128));
writer.WriteLine("* Cave.DnsDns.Server ready");
writer.Flush();
DynDnsDomain dynDnsDomain = default(DynDnsDomain);
bool loggedIn = false;
while (e.Client.IsConnected)
{
string[] parts;
try { parts = reader.ReadLine().Split(' '); }
catch { break; }
switch (parts[0])
{
default:
{
this.LogWarning(e.Client + " Invalid command received!");
writer.WriteLine("ERR Invalid or unknown command!");
writer.Flush();
}
break;
case "LOGIN":
{
dynDnsDomain = m_DnsDB.GetUser(parts[1]);
if (dynDnsDomain.ID <= 0)
{
writer.WriteLine("ERR LOGIN Invalid or unknown user!");
this.LogWarning(e.Client + " Invalid login received!");
}
else
{
this.LogDebug(e.Client + " login user " + dynDnsDomain);
writer.WriteLine("USERSALT " + dynDnsDomain.Salt);
writer.WriteLine("SERVERSALT " + serverSalt);
}
writer.Flush();
}
break;
case "PASSWORD":
{
loggedIn = dynDnsDomain.CheckPassword(serverSalt, parts[1]);
if (loggedIn)
{
this.LogInfo("<green>{0}<default> Login {1}", e.Client, dynDnsDomain.Username);
writer.WriteLine("OK LOGIN");
writer.Flush();
}
else
{
writer.WriteLine("ERR LOGIN Invalid password!");
writer.Flush();
this.LogInfo("<red>{0}<default> Invalid password received!", e.Client);
break;
}
}
break;
#region UPDATE [<IPADDRESS>]
case "UPDATE":
{
if (!loggedIn)
{
writer.WriteLine("NO UPDATE Please log in first!");
writer.Flush();
break;
}
IPAddress address;
if (parts.Length > 1)
{
if (!IPAddress.TryParse(parts[1], out address))
{
writer.WriteLine("NO UPDATE ipaddress '" + parts[2] + "' is not valid!");
writer.Flush();
break;
}
}
else
{
string s = e.Client.RemoteEndPoint.Address.ToString();
if (s.StartsWith("::ffff:"))
{
address = IPAddress.Parse(s.Substring(s.LastIndexOf(':') + 1));
}
else
{
address = e.Client.RemoteEndPoint.Address;
}
}
string result = m_DnsDB.UpdateDomainEntryAddress(dynDnsDomain, address).ToString();
// check for same Type
if (result == null)
{
writer.WriteLine($"NO UPDATE no domains found matching {dynDnsDomain.Username}.");
writer.Flush();
break;
}
writer.WriteLine("OK UPDATE " + result);
writer.Flush();
this.LogNotice(e.Client + " Update " + dynDnsDomain.Username + " " + result);
}
break;
#endregion
}
}
}
public static void NextRangedTest()
{
const int length = 16384;
for (int i = 0; i < length; ++i)
{
var ma = DefaultRNG.Next();
var mi = DefaultRNG.Next();
if (ma <= mi)
{
Assert.Throws <ArgumentOutOfRangeException>(() => DefaultRNG.I32.Next(mi, ma));
}
else
{
Assert.InRange(DefaultRNG.I32.Next(mi, ma), mi, ma - 1);
}
}
for (int i = 0; i < length; ++i)
{
var ma = DefaultRNG.Next();
if (ma <= 0)
{
Assert.Throws <ArgumentOutOfRangeException>(() => DefaultRNG.I32.Next(0, ma));
}
else
{
Assert.InRange(DefaultRNG.I32.Next(0, ma), 0, ma - 1);
}
}
for (int i = 0; i < length; ++i)
{
var ma = DefaultRNG.NextU32();
var mi = DefaultRNG.NextU32();
if (ma <= mi)
{
Assert.Throws <ArgumentOutOfRangeException>(() => DefaultRNG.I32.Next(mi, ma));
}
else
{
Assert.InRange(DefaultRNG.I32.Next(mi, ma), mi, ma - 1);
}
}
for (int i = 0; i < length; ++i)
{
var ma = DefaultRNG.NextU32();
if (ma <= 0)
{
Assert.Throws <ArgumentOutOfRangeException>(() => DefaultRNG.I32.Next(0u, ma));
}
else
{
Assert.InRange(DefaultRNG.I32.Next(0u, ma), 0u, ma - 1);
}
}
for (int i = 0; i < length; ++i)
{
var ma = DefaultRNG.NextU64();
var mi = DefaultRNG.NextU64();
if (ma <= mi)
{
Assert.Throws <ArgumentOutOfRangeException>(() => DefaultRNG.U64.Next(mi, ma));
}
else
{
Assert.InRange(DefaultRNG.U64.Next(mi, ma), mi, ma - 1);
}
}
for (int i = 0; i < length; ++i)
{
var ma = DefaultRNG.NextU64();
if (ma <= 0)
{
Assert.Throws <ArgumentOutOfRangeException>(() => DefaultRNG.U64.Next(0u, ma));
}
else
{
Assert.InRange(DefaultRNG.U64.Next(0u, ma), 0u, ma - 1);
}
}
}
/// <summary>Creates the password hash.</summary>
/// <param name="plainTextPassword">The p plain text password.</param>
public void CreatePasswordHash(string plainTextPassword)
{
Salt = Base64.NoPadding.Encode(DefaultRNG.Get(128));
Password = Base64.NoPadding.Encode(Hash.FromString(Hash.Type.SHA256, plainTextPassword + Salt));
}
public PCG() : this(DefaultRNG.NextU64(), DefaultRNG.NextU64())
{
}
