public void GetOrCreateRegistrationWhenRegistrationAlreadyExistsTest()
{
var expectedRegistration = new Registration
{
ID = 3,
ClientId = "client-id",
ClientSecret = "client-secret",
Instance = "mastodon.instance",
MastodonAppRegistrationID = "42"
};
_mockData.Setup(d => d.GetAppRegistration("mastodon.instance")).Returns(expectedRegistration);
var herdApp = new HerdApp(_mockData.Object, _mockHashTagRelevanceManager.Object, _mockMastodonApiWrapper.Object, _mockLogger.Object);
var result = herdApp.GetOrCreateRegistration(new GetOrCreateRegistrationCommand {
Instance = "mastodon.instance"
});
// Verify the result
Assert.True(result?.Success);
ExtendedAssert.ObjectsEqual(expectedRegistration, result.Data.Registration);
// Make sure the GetAppRegistration was called once and CreateAppRegistration was never called
_mockData.Verify(d => d.GetAppRegistration("mastodon.instance"), Times.Once());
_mockData.Verify(d => d.CreateAppRegistration(It.Is <Registration>(r => true)), Times.Never());
}
public void GeoRectangle_Wraparound()
{
// Verify that we detect coordinate wraparound.
ExtendedAssert.Throws <ArgumentException>(() => new GeoRectangle(new GeoCoordinate(45, 5), new GeoCoordinate(60, 0)));
ExtendedAssert.Throws <ArgumentException>(() => new GeoRectangle(new GeoCoordinate(45, -10), new GeoCoordinate(0, 0)));
}
public void IsSemver()
{
ExtendedAssert.IsTrueWithMessage(RegexHelper.IsSemver, "1.0.0-alpha-a.b-c-somethinglong+build.1-aef.1-its-okay");
ExtendedAssert.IsTrueWithMessage(RegexHelper.IsSemver, "1.0.0+0.build.1-rc.10000aaa-kk-0.1");
ExtendedAssert.IsTrueWithMessage(RegexHelper.IsSemver, "1.0.0-rc.1+build.1");
ExtendedAssert.IsTrueWithMessage(RegexHelper.IsSemver, "2.0.0-rc.1+build.123");
ExtendedAssert.IsTrueWithMessage(RegexHelper.IsSemver, "0.0.4");
ExtendedAssert.IsTrueWithMessage(RegexHelper.IsSemver, "1.2.3");
ExtendedAssert.IsTrueWithMessage(RegexHelper.IsSemver, "10.20.30");
ExtendedAssert.IsTrueWithMessage(RegexHelper.IsSemver, "1.2.3-beta");
ExtendedAssert.IsTrueWithMessage(RegexHelper.IsSemver, "10.2.3-DEV-SNAPSHOT");
ExtendedAssert.IsTrueWithMessage(RegexHelper.IsSemver, "1.2.3-SNAPSHOT-123");
ExtendedAssert.IsTrueWithMessage(RegexHelper.IsSemver, "1.0.0");
ExtendedAssert.IsTrueWithMessage(RegexHelper.IsSemver, "2.0.0");
ExtendedAssert.IsTrueWithMessage(RegexHelper.IsSemver, "1.1.7");
ExtendedAssert.IsTrueWithMessage(RegexHelper.IsSemver, "2.0.0+build.1848");
ExtendedAssert.IsTrueWithMessage(RegexHelper.IsSemver, "2.0.1-alpha.1227");
ExtendedAssert.IsTrueWithMessage(RegexHelper.IsSemver, "1.2.3----RC-SNAPSHOT.12.9.1--.12+788");
ExtendedAssert.IsFalseWithMessage(RegexHelper.IsSemver, "01.1.1");
ExtendedAssert.IsFalseWithMessage(RegexHelper.IsSemver, "1.2");
ExtendedAssert.IsFalseWithMessage(RegexHelper.IsSemver, "1.2.3.DEV");
ExtendedAssert.IsFalseWithMessage(RegexHelper.IsSemver, "1.2-SNAPSHOT");
ExtendedAssert.IsFalseWithMessage(RegexHelper.IsSemver, "1.2.3----RC-SNAPSHOT.12.09.1--..12+788");
ExtendedAssert.IsFalseWithMessage(RegexHelper.IsSemver, "1.2-RC-SNAPSHOT");
ExtendedAssert.IsFalseWithMessage(RegexHelper.IsSemver, "-1.0.3-gamma+b7718");
}
public void AsymmetricCrypto_EncryptedCredentials()
{
string privateKey = AsymmetricCrypto.CreatePrivateKey(CryptoAlgorithm.RSA, 1024);
string publicKey = AsymmetricCrypto.GetPublicKey(CryptoAlgorithm.RSA, privateKey);
Credentials credentials;
byte[] encrypted;
credentials = new Credentials("realm", "user", "password");
encrypted = AsymmetricCrypto.EncryptCredentials(credentials, "RSA", publicKey);
credentials = AsymmetricCrypto.DecryptCredentials(encrypted, "RSA", privateKey);
Assert.AreEqual("realm", credentials.Realm);
Assert.AreEqual("user", credentials.Account);
Assert.AreEqual("password", credentials.Password);
// Force a security failure by decrypting with the wrong key
ExtendedAssert.Throws <SecurityException>(
() =>
{
privateKey = AsymmetricCrypto.CreatePrivateKey(CryptoAlgorithm.RSA, 1024);
AsymmetricCrypto.DecryptCredentials(encrypted, "RSA", privateKey);
});
// Force a security failure by tampering with the encrypted credentials
ExtendedAssert.Throws <SecurityException>(
() =>
{
encrypted[4] = (byte)~encrypted[4];
AsymmetricCrypto.DecryptCredentials(encrypted, "RSA", privateKey);
});
}
public void CompositeEnumerator_SourceChanged()
{
// Verify that InvalidOperationExceptions are thrown when the when
// performing operations on the enumerator after the source has
// signalled that it has been modified.
List <int> source = new List <int>();
CompositeEnumerator <int> enumerator;
source.Add(0);
source.Add(1);
source.Add(2);
enumerator = new CompositeEnumerator <int>(source.GetEnumerator());
enumerator.OnSourceChanged();
ExtendedAssert.Throws <InvalidOperationException>(() => enumerator.MoveNext());
enumerator = new CompositeEnumerator <int>(source.GetEnumerator());
enumerator.OnSourceChanged();
ExtendedAssert.Throws <InvalidOperationException>(() => { int i = enumerator.Current; });
enumerator = new CompositeEnumerator <int>(source.GetEnumerator());
enumerator.OnSourceChanged();
ExtendedAssert.Throws <InvalidOperationException>(() => { enumerator.Reset(); });
}
public void GeoCoordinate_Valiate()
{
ExtendedAssert.Throws <ArgumentException>(() => new GeoCoordinate(91.0, 0));
ExtendedAssert.Throws <ArgumentException>(() => new GeoCoordinate(-91.0, 0));
ExtendedAssert.Throws <ArgumentException>(() => new GeoCoordinate(0, 181.0));
ExtendedAssert.Throws <ArgumentException>(() => new GeoCoordinate(0, -181.0));
}
public void Throws_Exception_On_Empty_Or_Null_String()
{
var myValidator = new Validator();
ExtendedAssert.Throws <InvalidOperationException>(() => myValidator.VerifyNotNullOrEmpty(string.Empty));
ExtendedAssert.Throws <InvalidOperationException>(() => myValidator.VerifyNotNullOrEmpty(null));
}
public void SerializedActionQueue_Limit()
{
// Verify that the queue throws an [InvalidOperationException] if the number of items in
// the queue are exceeded. I'm going to do this by queuing a relatively long-running action
// and then quickly submitting four more actions where the last one should exceed the limit
// of three actions I'm going to set for the queue.
var queue = new SerializedActionQueue(3);
var done = false;
var task1 = false;
try
{
queue.EnqueueAction(() =>
{
task1 = true;
Thread.Sleep(TimeSpan.FromSeconds(1));
done = true;
});
Helper.WaitFor(() => task1, TimeSpan.FromSeconds(1));
queue.EnqueueAction(() => Thread.Sleep(0));
queue.EnqueueAction(() => Thread.Sleep(0));
queue.EnqueueAction(() => Thread.Sleep(0));
ExtendedAssert.Throws <InvalidOperationException>(() => queue.EnqueueAction(() => Thread.Sleep(0)));
Helper.WaitFor(() => done, TimeSpan.FromSeconds(5));
}
finally
{
queue.Clear();
}
}
public void Throws_An_Exception_When_Any_Argument_Is_Null()
{
string one = "asdf";
string two = "sadf";
string three = null;
ExtendedAssert.Throws <ArgumentNullException>(() => new Validator().VerifyParamsNonNull(one, two, three));
}
public void Dispose_Of_The_Http_Client()
{
var target = new GithubInquisitor();
target.Dispose();
ExtendedAssert.Throws(() => target.Client.CancelPendingRequests());
}
public void AsyncManualResetEvent_Error()
{
AsyncManualResetEvent manualEvent;
// Verify that we get and [ObjectDisposedException] for [Set()] and [Reset()]
// a disposed event.
manualEvent = new AsyncManualResetEvent();
manualEvent.Dispose();
ExtendedAssert.Throws <ObjectDisposedException>(() => manualEvent.Set());
ExtendedAssert.Throws <ObjectDisposedException>(() => manualEvent.Reset());
Task.Run(() => ExtendedAssert.ThrowsAsync <ObjectDisposedException>(async() => await manualEvent.WaitAsync())).Wait();
// Verify that disposing an event causes any waiting tasks
// to unblock with an [ObjectDisposedException].
manualEvent = new AsyncManualResetEvent();
var taskInfo = new TaskStateCollection();
var badException = false;
for (int i = 0; i < taskInfo.Count; i++)
{
new Task(
async state =>
{
int taskIndex = (int)state;
taskInfo[taskIndex].IsRunning = true;
try
{
await manualEvent.WaitAsync();
}
catch (ObjectDisposedException)
{
taskInfo[taskIndex].IsFaulted = true;
}
catch
{
badException = true;
taskInfo[taskIndex].IsFaulted = true;
}
taskInfo[taskIndex].IsComplete = true;
},
i).Start();
}
Helper.WaitFor(() => taskInfo.AllRunning, defaultTimeout);
Assert.IsFalse(taskInfo.AnyComplete);
manualEvent.Dispose();
Helper.WaitFor(() => taskInfo.AllFaulted, defaultTimeout);
Assert.IsFalse(badException);
}
public void DynDnsClientSettings_LoadCluster()
{
var cfg = @"
§ion DynDnsClient
Enabled = true
NetworkBinding = ANY
Mode = CLUSTER
SharedKey = aes:ac2qGMV/VZXXdwdjFvaOBpLjOJgOuG6SbM86w3xk0NM=:B4s0wIHjn+PdRHsIcBgJPQ==
// Domain = ANY
// NameServer[0] =
BkInterval = 3s
DomainRefreshInterval = 4m
UdpRegisterInterval = 5m
§ion Cluster
ClusterBaseEP = abstract://LillTek/DataCenter/DynDNS
Mode = Normal
MasterBroadcastInterval = 1s
SlaveUpdateInterval = 1s
ElectionInterval = 3s
MissingMasterCount = 3
MissingSlaveCount = 3
MasterBkInterval = 1s
SlaveBkInterval = 1s
BkInterval = 1s
&endsection
&endsection
";
try
{
DynDnsClientSettings settings;
Config.SetConfig(cfg.Replace('&', '#'));
settings = new DynDnsClientSettings("DynDnsClient");
Assert.IsTrue(settings.Enabled);
Assert.IsTrue(settings.NetworkBinding.IsAny);
Assert.AreEqual(DynDnsMode.Cluster, settings.Mode);
Assert.AreNotEqual(new DynDnsClientSettings().SharedKey.ToString(), settings.SharedKey.ToString());
Assert.IsTrue(settings.Domain.IsAny);
ExtendedAssert.IsEmpty(settings.NameServers);
Assert.AreEqual(TimeSpan.FromSeconds(3), settings.BkInterval);
Assert.AreEqual(TimeSpan.FromMinutes(4), settings.DomainRefreshInterval);
Assert.AreEqual(TimeSpan.FromMinutes(5), settings.UdpRegisterInterval);
Assert.IsNotNull(settings.Cluster);
}
finally
{
Config.SetConfig(null);
}
}
public void ReadOnlyDictionary_TryModify()
{
var dictionary = new Dictionary <string, string>();
var readOnly = new ReadOnlyDictionary <string, string>(dictionary);
ExtendedAssert.Throws <NotSupportedException>(() => readOnly.Clear());
ExtendedAssert.Throws <NotSupportedException>(() => readOnly.Add("hello", "world"));
ExtendedAssert.Throws <NotSupportedException>(() => readOnly["test"] = "fail");
ExtendedAssert.Throws <NotSupportedException>(() => readOnly.Remove("hello"));
ExtendedAssert.Throws <NotSupportedException>(() => readOnly.Remove(new KeyValuePair <string, string>("hello", "world")));
}
public void ChannelVariableCollection_Exceptions()
{
var variables = new ChannelVariableCollection();
ExtendedAssert.Throws <ArgumentNullException>(() => variables.Add(null, "value"));
ExtendedAssert.Throws <ArgumentNullException>(() => variables.Add("name", null));
ExtendedAssert.Throws <ArgumentException>(() => variables.Add("", "value"));
ExtendedAssert.Throws <ArgumentException>(() => variables.Add("=", "value"));
ExtendedAssert.Throws <ArgumentException>(() => variables.Add(",", "value"));
ExtendedAssert.Throws <ArgumentException>(() => variables.Add("name", "^"));
}
public void Exception_CanBeSerialized()
{
var expectations = Expectations.GetInnerExceptionsWithNull();
foreach (var e in expectations)
{
var error = CreateCompositionError(e);
var result = SerializationTestServices.RoundTrip(error);
ExtendedAssert.IsInstanceOfSameType(error.Exception, result.Exception);
}
}
public void SwitchEventCodeSet_ReadOnly()
{
var readOnly = new SwitchEventCodeSet(SwitchEventCode.Heartbeat);
readOnly.IsReadOnly = true;
Assert.IsTrue(readOnly.IsReadOnly);
Assert.IsTrue(readOnly.Contains(SwitchEventCode.Heartbeat));
ExtendedAssert.Throws <InvalidOperationException>(() => readOnly.IsReadOnly = false);
ExtendedAssert.Throws <InvalidOperationException>(() => readOnly.Add(SwitchEventCode.Dtmf));
ExtendedAssert.Throws <InvalidOperationException>(() => readOnly.Remove(SwitchEventCode.Dtmf));
ExtendedAssert.Throws <InvalidOperationException>(() => readOnly.Clear());
}
public void InnerException_CanBeSerialized()
{
var expectations = Expectations.GetInnerExceptions();
foreach (var e in expectations)
{
var exception = CreateComposablePartException(e);
var result = SerializationTestServices.RoundTrip(exception);
ExtendedAssert.IsInstanceOfSameType(exception.InnerException, result.InnerException);
}
}
public void InnerException_CanBeSerialized()
{
var expectations = Expectations.GetInnerExceptionsWithNull();
foreach (var e in expectations)
{
var exception = CreateCardinalityMismatchException(e);
var result = SerializationTestServices.RoundTrip(exception);
ExtendedAssert.IsInstanceOfSameType(exception.InnerException, result.InnerException);
}
}
public void ArgCollection_ReadOnly()
{
ArgCollection ps = new ArgCollection();
ps["hello"] = "world!";
Assert.IsFalse(ps.IsReadOnly);
Assert.AreEqual("world!", ps["hello"]);
ps.IsReadOnly = true;
Assert.IsTrue(ps.IsReadOnly);
Assert.AreEqual("world!", ps["hello"]);
ExtendedAssert.Throws <InvalidOperationException>(() => ps.IsReadOnly = false);
ExtendedAssert.Throws <NotSupportedException>(() => ps["foo"] = "bar");
}
public void DynDnsClientSettings_Defaults()
{
DynDnsClientSettings def = new DynDnsClientSettings();
Assert.IsTrue(def.Enabled);
Assert.IsTrue(def.NetworkBinding.IsAny);
Assert.AreEqual(DynDnsMode.Cluster, def.Mode);
Assert.IsNotNull(def.SharedKey);
Assert.IsTrue(def.Domain.IsAny);
ExtendedAssert.IsEmpty(def.NameServers);
ExtendedAssert.IsEmpty(def.Hosts);
Assert.AreEqual(TimeSpan.FromSeconds(1), def.BkInterval);
Assert.AreEqual(TimeSpan.FromMinutes(15), def.DomainRefreshInterval);
Assert.AreEqual(TimeSpan.FromMinutes(1), def.UdpRegisterInterval);
Assert.IsNull(def.Cluster);
}
public void GeoCompositeRegion_VerifyNotComposible()
{
// Verify that we get an exception when trying to compose a composite region
// as a subtractive region.
ExtendedAssert.Throws <ArgumentException>(
() =>
{
new GeoCompositeRegion(
new GeoRegion[] {
new GeoRectangle(30, 0, 0, 30)
},
new GeoRegion[] {
new GeoCompositeRegion(new GeoRegion[0])
});
});
}
public void DynDnsClientSettings_LoadUdpDomain()
{
var cfg = @"
§ion DynDnsClient
Enabled = true
NetworkBinding = ANY
Mode = UDP
SharedKey = aes:ac2qGMV/VZXXdwdjFvaOBpLjOJgOuG6SbM86w3xk0NM=:B4s0wIHjn+PdRHsIcBgJPQ==
Domain = lilltek.net:DYNAMIC-DNS
// NameServer[0] =
BkInterval = 3s
DomainRefreshInterval = 4m
UdpRegisterInterval = 5m
&endsection
";
try
{
DynDnsClientSettings settings;
Config.SetConfig(cfg.Replace('&', '#'));
settings = new DynDnsClientSettings("DynDnsClient");
Assert.IsTrue(settings.Enabled);
Assert.IsTrue(settings.NetworkBinding.IsAny);
Assert.AreEqual(DynDnsMode.Udp, settings.Mode);
Assert.AreNotEqual(new DynDnsClientSettings().SharedKey.ToString(), settings.SharedKey.ToString());
Assert.AreEqual(new NetworkBinding("lilltek.net", NetworkPort.DynamicDns), settings.Domain);
ExtendedAssert.IsEmpty(settings.NameServers);
Assert.AreEqual(TimeSpan.FromSeconds(3), settings.BkInterval);
Assert.AreEqual(TimeSpan.FromMinutes(4), settings.DomainRefreshInterval);
Assert.AreEqual(TimeSpan.FromMinutes(5), settings.UdpRegisterInterval);
Assert.IsNull(settings.Cluster);
}
finally
{
Config.SetConfig(null);
}
}
public void KeyChain_Basic()
{
string privateKey1 = AsymmetricCrypto.CreatePrivateKey(CryptoAlgorithm.RSA, 1024);
string publicKey1 = AsymmetricCrypto.GetPublicKey(CryptoAlgorithm.RSA, privateKey1);
string privateKey2 = AsymmetricCrypto.CreatePrivateKey(CryptoAlgorithm.RSA, 1024);
string publicKey2 = AsymmetricCrypto.GetPublicKey(CryptoAlgorithm.RSA, privateKey2);
KeyChain keyChain = new KeyChain();
ExtendedAssert.Throws <CryptographicException>(
() =>
{
keyChain.GetPrivateKey(publicKey1);
});
keyChain.Add(privateKey1);
keyChain.Add(privateKey2);
Assert.AreEqual(privateKey1, keyChain.GetPrivateKey(publicKey1));
Assert.AreEqual(privateKey2, keyChain.GetPrivateKey(publicKey2));
}
public void Bits_ShiftLeft()
{
var b = new Bits("001100111001111001111100111111001111111");
Assert.AreEqual("001100111001111001111100111111001111111", (string)(b << 0));
Assert.AreEqual("011001110011110011111001111110011111110", (string)(b << 1));
Assert.AreEqual("110011100111100111110011111100111111100", (string)(b << 2));
Assert.AreEqual("100111001111001111100111111001111111000", (string)(b << 3));
Assert.AreEqual("001110011110011111001111110011111110000", (string)(b << 4));
Assert.AreEqual("011100111100111110011111100111111100000", (string)(b << 5));
var s = b.ToString();
for (int i = 0; i < 100; i++)
{
Assert.AreEqual(s, (string)(b << i));
s = s.Substring(1) + "0";
}
ExtendedAssert.Throws <ArgumentException>(() => { var output = b << -1; });
}
public void Bits_ShiftRight()
{
var b = new Bits("001100111001111001111100111111001111111");
Assert.AreEqual("001100111001111001111100111111001111111", (string)(b >> 0));
Assert.AreEqual("000110011100111100111110011111100111111", (string)(b >> 1));
Assert.AreEqual("000011001110011110011111001111110011111", (string)(b >> 2));
Assert.AreEqual("000001100111001111001111100111111001111", (string)(b >> 3));
Assert.AreEqual("000000110011100111100111110011111100111", (string)(b >> 4));
Assert.AreEqual("000000011001110011110011111001111110011", (string)(b >> 5));
var s = b.ToString();
for (int i = 0; i < 100; i++)
{
Assert.AreEqual(s, (string)(b >> i));
s = "0" + s.Substring(0, s.Length - 1);
}
ExtendedAssert.Throws <ArgumentException>(() => { var output = b >> -1; });
}
public void GetRegistrationTest()
{
var expectedRegistration = new Registration
{
ID = 3,
ClientId = "client-id",
ClientSecret = "client-secret",
Instance = "mastodon.instance",
MastodonAppRegistrationID = "42"
};
_mockData.Setup(d => d.GetAppRegistration(3)).Returns(expectedRegistration);
var herdApp = new HerdApp(_mockData.Object, _mockHashTagRelevanceManager.Object, _mockMastodonApiWrapper.Object, _mockLogger.Object);
var result = herdApp.GetRegistration(new GetRegistrationCommand {
ID = 3
});
Assert.True(result?.Success);
ExtendedAssert.ObjectsEqual(expectedRegistration, result.Data.Registration);
_mockData.Verify(d => d.GetAppRegistration(3), Times.Once());
}
public void GetOrCreateRegistrationWhenRegistrationDoesNotAlreadyExistTest()
{
_mockData.Setup(d => d.GetAppRegistration("mastodon.instance")).Returns(null as Registration);
_mockMastodonApiWrapper.Setup(a => a.RegisterApp()).Returns(Task.FromResult(new Registration
{
ClientId = "client-id",
ClientSecret = "client-secret",
Instance = "mastodon.instance",
MastodonAppRegistrationID = "42",
ID = -1
}));
_mockData.Setup(d => d.CreateAppRegistration(It.Is <Registration>(r => r.Instance == "mastodon.instance")))
.Returns <Registration>(registrationToCreate => registrationToCreate.With(r => r.ID = 3));
var herdApp = new HerdApp(_mockData.Object, _mockHashTagRelevanceManager.Object, _mockMastodonApiWrapper.Object, _mockLogger.Object);
var result = herdApp.GetOrCreateRegistration(new GetOrCreateRegistrationCommand {
Instance = "mastodon.instance"
});
// Verify the result
var expectedRegistration = new Registration
{
ID = 3,
ClientId = "client-id",
ClientSecret = "client-secret",
Instance = "mastodon.instance",
MastodonAppRegistrationID = "42"
};
Assert.True(result?.Success);
ExtendedAssert.ObjectsEqual(expectedRegistration, result.Data.Registration);
// Make sure the GetAppRegistration and CreateAppRegistration were each called exactly once
_mockData.Verify(d => d.GetAppRegistration("mastodon.instance"), Times.Once());
_mockMastodonApiWrapper.Verify(a => a.RegisterApp(), Times.Once());
_mockData.Verify(d => d.CreateAppRegistration(It.Is <Registration>(r => r.Instance == "mastodon.instance")), Times.Once());
}
public void SecureTicket_Tamper()
{
DateTime now = DateTime.UtcNow;
SymmetricKey key = new SymmetricKey("aes:Cz1uS3EYB5aLDgXdKKmzGPnMU3/QwK1i+8nY3KuUaCw=:Toel2ZQR6TBtOvq+zatyoA==");
SecureTicket ticket;
byte[] encrypted;
ticket = new SecureTicket("my-resource", TimeSpan.FromSeconds(10));
ticket.Set("arg0", "myarg-0");
ticket.Set("arg1", "myarg-1");
ticket["arg2"] = "myarg-2";
encrypted = ticket.ToArray(key);
encrypted[0] = (byte)~encrypted[0];
ExtendedAssert.Throws <CryptographicException>(
() =>
{
ticket = SecureTicket.Parse(key, encrypted);
Assert.Fail("Expected a CryptographicException");
});
}
public void ValidCommand_DoNotThrowsException()
{
var stubCommand = GetStubValidCommand();
ExtendedAssert.NotThrowsAnyExceptions(() => addEngineCommandValidator.Validate(stubCommand));
}
public void Does_Not_Throw_On_Valid_Argument()
{
var myValidator = new Validator();
ExtendedAssert.DoesNotThrow(() => myValidator.VerifyNotNullOrEmpty("a"));
}
