public void Guid_CanConvertTo_Ulid()
{
var g = Guid.NewGuid();
var u = new Ulid(g);
var t = new Ulid(Guid.Empty);
Assert.AreEqual(g, u.ToGuid());
Assert.AreEqual(Ulid.Empty, t);
Assert.AreEqual(Guid.Empty, t.ToGuid());
}
public async Task <IActionResult> GetChannel([FromRoute] string id)
{
// throws exception on error
Ulid?_id;
{ if (Ulid.TryParse(id, out var res))
{
_id = res;
}
else
{
_id = null;
} }
var name = id;
if (_id != null)
{
var res = await this._db.GetChannel(_id.Value);
if (res != null)
{
return(Ok(res));
}
else
{
return(NotFound());
}
}
else
{
var res = await this._db.GetChannelFromUsername(name);
if (res != null)
{
return(Ok(res));
}
else
{
return(NotFound());
}
}
}
public void Ulid_CompareTo_WorksCorrectly()
{
var a = Ulid.NewUlid(KNOWNTIMESTAMP_DTO, new FakeUlidRng());
var b = Ulid.NewUlid(KNOWNTIMESTAMP_DTO, new FakeUlidRng());
var c = Ulid.NewUlid(KNOWNTIMESTAMP_DTO.AddMilliseconds(-1), new FakeUlidRng());
var d = Ulid.NewUlid(KNOWNTIMESTAMP_DTO.AddMilliseconds(+1), new FakeUlidRng());
Assert.AreEqual(0, a.CompareTo(b));
Assert.AreEqual(1, a.CompareTo(c));
Assert.AreEqual(-1, a.CompareTo(d));
var rmin = a.ToByteArray(); rmin[15]--;
var rplus = a.ToByteArray(); rplus[15]++;
var e = new Ulid(rmin);
var f = new Ulid(rplus);
Assert.AreEqual(1, a.CompareTo(e));
Assert.AreEqual(-1, a.CompareTo(f));
}
public void Ulid_CompareTo_WorksCorrectly()
{
var a = Ulid.NewUlid(KNOWNTIMESTAMP_DTO, new FakeUlidRng());
var b = Ulid.NewUlid(KNOWNTIMESTAMP_DTO, new FakeUlidRng());
var c = Ulid.NewUlid(KNOWNTIMESTAMP_DTO.AddMilliseconds(-1), new FakeUlidRng());
var d = Ulid.NewUlid(KNOWNTIMESTAMP_DTO.AddMilliseconds(+1), new FakeUlidRng());
Assert.AreEqual(0, a.CompareTo(b));
Assert.AreEqual(1, a.CompareTo(c));
Assert.AreEqual(-1, a.CompareTo(d));
var rmin = a.ToByteArray(); rmin[15]--;
var rplus = a.ToByteArray(); rplus[15]++;
var e = new Ulid(rmin);
var f = new Ulid(rplus);
Assert.AreEqual(1, a.CompareTo(e));
Assert.AreEqual(-1, a.CompareTo(f));
}
public async Task <IActionResult> GetMe()
{
Ulid _id;
{
var id = HttpContext.User.Claims.Where(claim => claim.Type == "sub")
.Select(claim => claim.Value)
.Single();
if (Ulid.TryParse(id, out var res))
{
_id = res;
}
else
{
return(BadRequest());
}
}
var user = await this.db.GetUser(_id);
return(Ok(user));
}
private ImmutableList <Todo> _store = ImmutableList <Todo> .Empty; // It's always sorted by Id though
// Commands
#pragma warning disable 1998
public virtual async Task <Todo> AddOrUpdate(AddOrUpdateTodoCommand command, CancellationToken cancellationToken = default)
{
if (Computed.IsInvalidating())
{
return(null !);
}
var(session, todo) = command;
if (string.IsNullOrEmpty(todo.Id))
{
todo = todo with {
Id = Ulid.NewUlid().ToString()
}
}
;
_store = _store.RemoveAll(i => i.Id == todo.Id).Add(todo);
using var invalidating = Computed.Invalidate();
_ = Get(session, todo.Id, CancellationToken.None);
_ = PseudoGetAllItems(session);
return(todo);
}
public void Ulid_TryParse_WorksCorrectly()
{
Assert.IsFalse(Ulid.TryParse("X", out var r1));
Assert.AreEqual(Ulid.Empty, r1);
Assert.IsFalse(Ulid.TryParse(string.Empty, out var r2));
Assert.AreEqual(Ulid.Empty, r2);
Assert.IsFalse(Ulid.TryParse(null, out var r3));
Assert.AreEqual(Ulid.Empty, r3);
Assert.IsTrue(Ulid.TryParse(Ulid.MinValue.ToString(), out var r4));
Assert.IsTrue(Ulid.MinValue == r4);
Assert.IsTrue(Ulid.TryParse(Ulid.MaxValue.ToString(), out var r5));
Assert.IsTrue(Ulid.MaxValue == r5);
var target = Ulid.NewUlid(KNOWNTIMESTAMP_DTO, new FakeUlidRng());
Assert.IsTrue(Ulid.TryParse(KNOWNTIMESTAMP_STRING + KNOWNRANDOMSEQ_STRING, out var r6));
Assert.AreEqual(r6, target);
}
/// <summary>
/// Creates and returns random bytes based on internal <see cref="IUlidRng"/>.
/// </summary>
/// <param name="dateTime">
/// DateTime for which the random bytes need to be generated; this value is used to determine wether a sequence
/// needs to be incremented (same timestamp with millisecond resolution) or reset to a new random value.
/// </param>
/// <returns>Random bytes.</returns>
/// <exception cref="InvalidOperationException">
/// Thrown when the specified <paramref name="dateTime"/> is before the last time this method was called.
/// </exception>
public override byte[] GetRandomBytes(DateTimeOffset dateTime)
{
lock (_genlock)
{
// Get unix time for given datetime
var timestamp = Ulid.ToUnixTimeMilliseconds(dateTime);
if (timestamp < _lastgen)
{
throw new InvalidOperationException("Clock moved backwards; this is not supported.");
}
if (timestamp == _lastgen) // Same timestamp as last time we generated random values?
{
// Increment our random value by one.
var i = RANDLEN;
while (--i >= 0 && ++_lastvalue[i] == 0)
{
;
}
// If i made it all the way to -1 we have an overflow and we throw
if (i < 0)
{
throw new OverflowException();
}
}
else // New(er) timestamp, so generate a new random value and store the new(er) timestamp
{
_lastvalue = _rng.GetRandomBytes(dateTime); // Use internal RNG to get bytes from
for (var i = 0; i < _mask.Length && _mask[i] < 255; i++) // Mask out desired number of MSB's
{
_lastvalue[i] = (byte)(_lastvalue[i] & _mask[i]);
}
_lastgen = timestamp; // Store last timestamp
}
return(_lastvalue);
}
}
// Note:
// This validation uses a dynamic password sent to the user via email
// instead of a regular password.
public async Task ValidateAsync(ResourceOwnerPasswordValidationContext context)
{
if (await db.CanUserLoginWithCode(context.UserName, context.Password))
{
// We have guarantee it will have value
Ulid id = (await db.GetUserIdFromEmail(context.UserName)).Value;
context.Result = new GrantValidationResult(
subject: id.ToString(),
authenticationMethod: "custom",
claims: new Claim[]
{
}
);
}
else
{
context.Result = new GrantValidationResult(
TokenRequestErrors.InvalidGrant,
"Bad passcode");
}
}
public void Ulid_RandomIs_Immutable()
{
Ulid.MinValue.Random[0] = 42;
Assert.AreEqual(0, Ulid.MinValue.Random[0]);
Ulid.MaxValue.Random[0] = 42;
Assert.AreEqual(255, Ulid.MaxValue.Random[0]);
Ulid.Empty.Random[0] = 42;
Assert.AreEqual(0, Ulid.Empty.Random[0]);
var u = Ulid.NewUlid(new FakeUlidRng());
u.Random[0] = 42;
Assert.AreEqual(107, u.Random[0]);
// Make sure when we pass an array into the constructor we cannot modify the source array (constructor copies, doesn't use reference)
var x = Ulid.MaxValue.ToByteArray();
var t = new Ulid(x);
x[6] = 0;
Assert.AreEqual(255, t.Random[0]);
}
public Employee Generate(Company c)
{
var name = RandomName();
var experience = RandomExperience();
var base_efficiency = RandomEfficiency();
var salary = (decimal)RandomSalary(experience);
var liveDuration = RandomLiveDuration();
var employee = new Employee
{
id = Ulid.NewUlid(),
name = name,
baseEfficiency = base_efficiency,
experience = experience,
salary = salary,
liveTime = liveDuration + c.ut,
abilities = new Dictionary <string, float>
{
["java"] = 1.0f
}
};
return(employee);
}
static void Main()
{
var simplerng = new SimpleUlidRng();
var csrng = new CSUlidRng();
var simplemonotonicrng = new MonotonicUlidRng(simplerng);
var csmonotonicrng = new MonotonicUlidRng(csrng);
var plainrng = new Random();
var pt = new SimpleBencher(10000000);
//pt.BenchRunning += (s, e) => Console.WriteLine($"Running {e.Title}, {e.Iterations:N0} iterations...");
//pt.BenchWarmup += (s, e) => Console.WriteLine($"Warmup {e.Title}, {e.Iterations:N0} iterations...");
pt.BenchComplete += (s, e) => Console.WriteLine($"Completed {e.Title,-40}: {e.Result.OperationsPerSecond(),15:N0}/sec.");
var d = DateTimeOffset.Now;
var benchtests = new IBench[] {
new ForBench("Guid.NewGuid()", () => Guid.NewGuid()),
new ForBench("Ulid.NewUlid(SimpleUlidRng)", () => Ulid.NewUlid(simplerng)),
new ForBench("Ulid.NewUlid(CSUlidRng)", () => Ulid.NewUlid(csrng)),
new ForBench("Ulid.NewUlid(SimpleMonotonicUlidRng)", () => Ulid.NewUlid(simplemonotonicrng)),
new ForBench("Ulid.NewUlid(CSMonotonicUlidRng)", () => Ulid.NewUlid(csmonotonicrng)),
new ForEachBench <string>("Guid.Parse(string)", (i) => Guid.Parse(i), (i) => Enumerable.Range(0, i).Select(n => Guid.NewGuid().ToString())),
new ForEachBench <string>("Ulid.Parse(string)", (i) => Ulid.Parse(i), (i) => Enumerable.Range(0, i).Select(n => Ulid.NewUlid().ToString())),
new ForEachBench <Guid>("Guid.ToString()", (i) => i.ToString(), (i) => Enumerable.Range(0, i).Select(n => Guid.NewGuid())),
new ForEachBench <Ulid>("Ulid.ToString()", (i) => i.ToString(), (i) => Enumerable.Range(0, i).Select(n => Ulid.NewUlid())),
new ForEachBench <byte[]>("new Guid(byte[])", (i) => new Guid(i), (i) => Enumerable.Range(0, i).Select(n => { var b = new byte[16]; plainrng.NextBytes(b); return(b); })),
new ForEachBench <byte[]>("new Ulid(byte[])", (i) => new Ulid(i), (i) => Enumerable.Range(0, i).Select(n => { var b = new byte[16]; plainrng.NextBytes(b); return(b); })),
new ForEachBench <Guid>("Guid.ToByteArray()", (i) => i.ToByteArray(), (i) => Enumerable.Range(0, i).Select(n => Guid.NewGuid())),
new ForEachBench <Ulid>("Ulid.ToByteArray()", (i) => i.ToByteArray(), (i) => Enumerable.Range(0, i).Select(n => Ulid.NewUlid())),
new ForEachBench <Ulid>("Ulid.ToGuid()", (i) => i.ToGuid(), (i) => Enumerable.Range(0, i).Select(n => Ulid.NewUlid())),
new ForEachBench <Guid>("new Ulid(Guid)", (i) => new Ulid(i), (i) => Enumerable.Range(0, i).Select(n => Guid.NewGuid())),
};
var results = pt.BenchMark(benchtests).ToArray();
Console.WriteLine("Done.");
}
public async Task <IActionResult> JoinChannel(
[FromRoute] string id
)
{
var userId = HttpContext.User.Claims.Where(claim => claim.Type == "sub")
.Select(claim => claim.Value)
.Single();
if (!Ulid.TryParse(id, out var _channelId))
{
return(BadRequest(new ErrorResult(
"not deserialized", $"'{id}' is not a valid Ulid")));
}
if (!Ulid.TryParse(userId, out var _userId))
{
return(BadRequest(new ErrorResult(
"not deserialized", $"'{userId}' is not a valid Ulid")));
}
// Regular join without invitation
var result = await this._db.AddUserToChannel(
_userId,
_channelId,
addToPrivateChannel : false);
return(result switch
{
AddResult.Success => NoContent(),
AddResult.AlreadyExist => BadRequest(new ErrorResult(
"resource already exists",
"The user has already been in the channel")),
_ => BadRequest(new ErrorResult(
"Unable to join into channel.",
"Either it doesn't exist at all or it's private.")),
});
public Contract Generate(Company c)
{
var contractor = RandomContractor();
// var nameDescriptionPair = RandomNameDescription(contractor);
var contract = new Contract
{
id = Ulid.NewUlid(),
status = ContractStatus.Open,
contractor = contractor,
name = title.Replace("$contractor", contractor),
description = description.Replace("$contractor", contractor),
startTime = c.ut,
LiveDuration = RandomLiveDuration(),
LimitDuration = durationCurve.Evaluate(c.reputation),
totalWorkload = workloadCurve.Evaluate(c.reputation),
depositReward = baseDepositReward.Copy(),
breakContractPunishment = baseAbortPunishment.Copy(),
completeReward = baseFinishReward.Copy(),
techStack = "java",
};
// MultiplyPow(ref contract.depositReward.reputation, );
return(contract);
}
public void TestUlid()
{
// just create
var anything = Ulid.Create();
Assert.IsTrue(anything.ToString() != null);
// from timestamp
var dto = DateTimeOffset.FromUnixTimeMilliseconds(1484581420);
var ulid = Ulid.Create(dto);
Assert.IsTrue(ulid.ToString().StartsWith("0001C7STHC"));
// string roundtrip
var str = anything.ToString();
var rev = Ulid.Parse(str);
Assert.IsTrue(str == rev.ToString());
// bytes roundtrip
var bytes = new byte[16];
anything.AsBytes(bytes);
var fromBytes = new Ulid(bytes);
Assert.IsTrue(anything.Equals(fromBytes));
Assert.IsTrue(anything.ToString() == fromBytes.ToString());
// test operators
var one = new Ulid(100UL, 200UL);
var two = new Ulid(42UL, 43UL);
var three = new Ulid(42UL, 43UL);
Assert.IsTrue(one != two);
Assert.IsTrue(two == three);
}
public void AddRemoveEmployeeTest()
{
var newEmployee = new Employee()
{
id = Ulid.NewUlid(),
name = "Someone Else",
baseEfficiency = 1,
abilities = new Dictionary <string, float>()
{
["csharp"] = 1.0f
},
isWorking = false
};
var oldEmployeeCount = mockCompany.employees.Count;
mockCompany.AddEmployee(newEmployee);
Assert.That(mockCompany.employees.Count, Is.EqualTo(oldEmployeeCount + 1), "Employee count should increase after adding");
Assert.That(mockCompany.employees.Contains(newEmployee), "The employee should be added");
Assert.That(mockCompany.RemoveEmployee(newEmployee.id), Is.True, "The employee should be removed by this call");
Assert.That(!mockCompany.employees.Contains(newEmployee), "The employee should be removed");
Assert.That(mockCompany.RemoveEmployee(newEmployee.id), Is.False, "The employee should not be avaliable");
}
public void Ulid_IsCaseInsensitive()
{
var target = new Ulid(KNOWNTIMESTAMP_STRING + KNOWNRANDOMSEQ_STRING);
Assert.AreEqual(target, new Ulid(KNOWNTIMESTAMP_STRING.ToLowerInvariant() + KNOWNRANDOMSEQ_STRING.ToLowerInvariant()));
}
public void Ulid_ObjectEquals_WorksCorrectly()
{
var a = Ulid.NewUlid();
var b = new Ulid(a.ToByteArray());
Assert.IsTrue(a.Equals((object)b));
Assert.IsTrue(a.Equals((object)a));
Assert.IsFalse(a.Equals((object)Ulid.Empty));
Assert.IsFalse(a.Equals(null));
Assert.IsFalse(a.Equals(new object()));
}
public void Ulid_HandlesMaxTimePlus1MSCorrectly()
{
var maxtime_plusone = "76EZ91ZQ00";
var target = new Ulid(maxtime_plusone + KNOWNMINRANDOM_STRING);
}
public void Ulid_RandomIs_Immutable()
{
Ulid.MinValue.Random[0] = 42;
Assert.AreEqual(0, Ulid.MinValue.Random[0]);
Ulid.MaxValue.Random[0] = 42;
Assert.AreEqual(255, Ulid.MaxValue.Random[0]);
Ulid.Empty.Random[0] = 42;
Assert.AreEqual(0, Ulid.Empty.Random[0]);
var u = Ulid.NewUlid(new FakeUlidRng());
u.Random[0] = 42;
Assert.AreEqual(107, u.Random[0]);
// Make sure when we pass an array into the constructor we cannot modify the source array (constructor copies, doesn't use reference)
var x = Ulid.MaxValue.ToByteArray();
var t = new Ulid(x);
x[6] = 0;
Assert.AreEqual(255, t.Random[0]);
}
public void Ulid_EqualsOperator_WorksCorrectly()
{
var a = Ulid.NewUlid();
var b = new Ulid(a.ToByteArray());
Assert.IsTrue(a == b);
}
public void Ulid_Equals_WorksCorrectly()
{
var a = Ulid.NewUlid();
var b = new Ulid(a.ToByteArray());
Assert.IsTrue(a.Equals(b));
Assert.IsTrue(a.Equals(a));
Assert.IsFalse(a.Equals(Ulid.Empty));
}
public void Ulid_NewUlid_ThrowsArgumentOutOfRangeException_OnTimestamp() => Ulid.NewUlid(Ulid.MinValue.Time.AddMilliseconds(-1));
public void Ulid_HandlesMaxTimeCorrectly()
{
var target = new Ulid(KNOWNMAXTIMESTAMP_STRING + KNOWNMAXRANDOM_STRING);
Assert.AreEqual(target.Time, StripMicroSeconds(DateTimeOffset.MaxValue));
}
