public void ValidateOutput(List <string> rawFileTypes, List <string> nonRawFileTypes, List <string> videoFileTypes)
{
var outputDirectory = new DirectoryInfo(m_OutputDirectory);
Assert.IsTrue(outputDirectory.Exists);
foreach (var referenceFile in m_ReferenceFileDescriptions)
{
var files = outputDirectory.GetFiles(referenceFile.FileName, SearchOption.AllDirectories);
Assert.IsNotNull(files);
Assert.That(files.Count, Is.AtMost(1));
var requiredFileKind = FileKind.Unrecognized;
if (rawFileTypes.Contains(referenceFile.Extension.ToLowerInvariant()))
{
requiredFileKind = FileKind.RawImage;
}
if (nonRawFileTypes.Contains(referenceFile.Extension.ToLowerInvariant()))
{
requiredFileKind = FileKind.JpegImage;
}
if (videoFileTypes.Contains(referenceFile.Extension.ToLowerInvariant()))
{
requiredFileKind = FileKind.Video;
}
var expectedPath = referenceFile.GetExpectedPath(requiredFileKind);
var expectedPathPresent = files[0].FullName.EndsWith(expectedPath);
Assert.IsTrue(
expectedPathPresent,
$"Expected {expectedPath}, got {files[0].FullName}"
);
}
}
public void check_of_returning_statement()
{
var sql = @"insert into regions (region_id, region_name) values (6, 'Antarctica') returning ""REGION_ID"", ""REGION_NAME"", ""CREATEDATE"" into :p1, :p2, :p3";
using (var c = GetCommand(sql))
{
var p1 = c.CreateParameter();
p1.ParameterName = "p1";
p1.Value = 1m;
p1.Direction = ParameterDirection.Output;
var p2 = c.CreateParameter();
p2.ParameterName = "p2";
p2.Value = "a";
p2.Size = 25;
p2.Direction = ParameterDirection.Output;
var p3 = c.CreateParameter();
p3.ParameterName = "p3";
p3.Value = DateTime.MinValue;
p3.Direction = ParameterDirection.Output;
c.Parameters.Add(p1);
c.Parameters.Add(p2);
c.Parameters.Add(p3);
c.Connection.Open();
c.ExecuteNonQuery();
Assert.AreEqual(6, c.Parameters["p1"].Value);
Assert.AreEqual("Antarctica", c.Parameters["p2"].Value);
var timeSpan = (DateTime.Now - ((DateTime)c.Parameters["p3"].Value));
Console.WriteLine(timeSpan.TotalMilliseconds);
Assert.That(timeSpan.TotalMilliseconds, Is.AtMost(2000));
}
}
public void ChildrenNumbersMoreOrEqualTo(int moreThen)
{
AllureLifecycle.Instance.RunStep("Get children' number", () => { });
int children = AllureLifecycle.Instance.RunStep <int>("Cointing children", () => City.HowManyBuildings);
Assert.That(children, Is.AtMost(moreThen), "No, still less");
}
public async Task Should_stop_pumping_messages_after_first_unsuccessful_receive()
{
var successfulReceives = 46;
var queueSize = 1000;
var parser = new QueueAddressTranslator("nservicebus", "dbo", null, null);
var inputQueue = new FakeTableBasedQueue(parser.Parse("input").QualifiedTableName, queueSize, successfulReceives);
var pump = new MessagePump(
m => new ProcessWithNoTransaction(sqlConnectionFactory),
qa => qa == "input" ? (TableBasedQueue)inputQueue : new TableBasedQueue(parser.Parse(qa).QualifiedTableName, qa),
new QueuePurger(sqlConnectionFactory),
new ExpiredMessagesPurger(_ => sqlConnectionFactory.OpenNewConnection(), TimeSpan.MaxValue, 0),
new QueuePeeker(sqlConnectionFactory, new QueuePeekerOptions()),
new SchemaInspector(_ => sqlConnectionFactory.OpenNewConnection()),
TimeSpan.MaxValue);
await pump.Init(
_ => Task.FromResult(0),
_ => Task.FromResult(ErrorHandleResult.Handled),
new CriticalError(_ => Task.FromResult(0)),
new PushSettings("input", "error", false, TransportTransactionMode.None));
pump.Start(new PushRuntimeSettings(1));
await WaitUntil(() => inputQueue.NumberOfPeeks > 1);
await pump.Stop();
Assert.That(inputQueue.NumberOfReceives, Is.AtMost(successfulReceives + 2), "Pump should stop receives after first unsuccessful attempt.");
}
public void CreateSubOrder_Success()
{
var item = new InventoryItem(Component1Vertical, 60);
var order = new Order(Guid.NewGuid(), "Test order")
{
ItemsOrdered = new HashSet <InventoryItem>
{
new InventoryItem(Product1InteriorDoor, 20),
new InventoryItem(Product2InteriorDoor, 10),
},
ItemsProduced = new HashSet <InventoryItem>
{
InventoryItem.Empty(Product1InteriorDoor),
InventoryItem.Empty(Product2InteriorDoor),
},
ShipmentDeadline = new DateTimeOffset(2020, 1, 1, 1, 1, 1, TimeSpan.Zero)
};
var now = DateTimeOffset.Now;
var subOrder = OrderService.CreateSubOrder(item, order);
Assert.That(subOrder.ParentOrder, Is.EqualTo(order));
Assert.That(subOrder.ItemsOrdered.Contains(item), Is.True);
Assert.That(subOrder.Status, Is.EqualTo(OrderStatus.New));
Assert.That(subOrder.Type, Is.EqualTo(OrderType.Internal));
Assert.That(order.SubOrders.Contains(subOrder), Is.True);
Assert.That(TimberComponentShop.Orders.Contains(subOrder), Is.True);
Assert.That(subOrder.CreatedAt, Is.AtLeast(now));
Assert.That(subOrder.CreatedAt, Is.AtMost(DateTimeOffset.Now));
}
public async Task ConsumerHeartbeatsWithinTimeLimit(int heartbeatMilliseconds, int totalMilliseconds)
{
var protocol = new JoinGroupRequest.GroupProtocol(new ConsumerProtocolMetadata("mine"));
var router = Substitute.For <IRouter>();
var conn = Substitute.For <IConnection>();
router.GetGroupConnectionAsync(Arg.Any <string>(), Arg.Any <CancellationToken>())
.Returns(_ => Task.FromResult(new GroupConnection(_.Arg <string>(), 0, conn)));
var lastHeartbeat = DateTimeOffset.UtcNow;
var heartbeatIntervals = ImmutableArray <TimeSpan> .Empty;
conn.SendAsync(Arg.Any <HeartbeatRequest>(), Arg.Any <CancellationToken>(), Arg.Any <IRequestContext>())
.Returns(_ => {
heartbeatIntervals = heartbeatIntervals.Add(DateTimeOffset.UtcNow - lastHeartbeat);
lastHeartbeat = DateTimeOffset.UtcNow;
return(Task.FromResult(new HeartbeatResponse(ErrorCode.NONE)));
});
var request = new JoinGroupRequest(TestConfig.GroupId(), TimeSpan.FromMilliseconds(heartbeatMilliseconds), "", ConsumerEncoder.Protocol, new [] { protocol });
var memberId = Guid.NewGuid().ToString("N");
var response = new JoinGroupResponse(ErrorCode.NONE, 1, protocol.protocol_name, memberId, memberId, new [] { new JoinGroupResponse.Member(memberId, new ConsumerProtocolMetadata("mine")) });
lastHeartbeat = DateTimeOffset.UtcNow;
using (new GroupConsumer(router, request.group_id, request.protocol_type, response)) {
await Task.Delay(totalMilliseconds);
}
foreach (var interval in heartbeatIntervals)
{
Assert.That((int)interval.TotalMilliseconds, Is.AtMost(heartbeatMilliseconds));
}
}
public void ComparisonTests()
{
// Classic Syntax
Assert.Greater(7, 3);
Assert.GreaterOrEqual(7, 3);
Assert.GreaterOrEqual(7, 7);
// Constraint Syntax
Assert.That(7, Is.GreaterThan(3));
Assert.That(7, Is.GreaterThanOrEqualTo(3));
Assert.That(7, Is.AtLeast(3));
Assert.That(7, Is.GreaterThanOrEqualTo(7));
Assert.That(7, Is.AtLeast(7));
// Classic syntax
Assert.Less(3, 7);
Assert.LessOrEqual(3, 7);
Assert.LessOrEqual(3, 3);
// Constraint Syntax
Assert.That(3, Is.LessThan(7));
Assert.That(3, Is.LessThanOrEqualTo(7));
Assert.That(3, Is.AtMost(7));
Assert.That(3, Is.LessThanOrEqualTo(3));
Assert.That(3, Is.AtMost(3));
}
public void QuantityIsLessOrEqual()
{
int expectedValue = 2;
int actualValue = 3;
// MSTest does not support this case.
// NUnit
Assert.That(actualValue, Is.LessThanOrEqualTo(expectedValue), () => "Some context");
Assert.That(actualValue, Is.AtMost(expectedValue), () => "Some context");
// Some context
// Expected: less than or equal to 2
// But was: 3
// XUnit does not support this case.
// Fluent
actualValue.Should().BeLessOrEqualTo(expectedValue, "SOME REASONS");
// Expected actualValue to be less or equal to 2 because SOME REASONS, but found 3.
// Shouldly
actualValue.ShouldBeLessThanOrEqualTo(expectedValue, "Some context");
// actualValue
// should be less than or equal to
// 2
// but was
// 3
//
// Additional Info:
// Some context
}
public async Task Test_Execute_TestPerformance()
{
// Arrange
var stopWatch = new Stopwatch();
var ipAddress = "0.0.0.0";
var oldHostFileContent = await TestHelpers.GetEmbeddedFileAsync("Resources/old-hosts");
_ = this.fileWrapperMock.Setup(f => f.ReadAllTextAsync(this.pathToHostsFile))
.ReturnsAsync(() => oldHostFileContent);
var remoteHostFileUrls = new List <Uri>
{
new Uri("https://www.adawayapk.net/downloads/hostfiles/official/1_hosts.txt"),
new Uri("https://www.adawayapk.net/downloads/hostfiles/official/2_ad_servers.txt"),
new Uri("https://www.adawayapk.net/downloads/hostfiles/official/3_yoyohost.txt")
};
var adAwayHost = new AdAwayHost(this.loggerMock.Object, this.hostFileDownloader, this.hostFileWriter);
// Act
stopWatch.Start();
await adAwayHost.UpdateHosts(remoteHostFileUrls, ipAddress);
stopWatch.Stop();
// Assert
Assert.That(stopWatch.Elapsed, Is.AtMost(TimeSpan.FromSeconds(10)));
}
public void BuildShouldReturnBookViewingViewModelWithValidViewingDate()
{
// Arrange
var builder = new BookViewingViewModelBuilder(_context);
var viewingsProperty1 = new List <Viewing> {
new Viewing {
ViewingDate = DateTime.Now
},
new Viewing {
ViewingDate = DateTime.Now.AddDays(1)
}
};
var property = new Domain.Models.Property {
Id = 5000, StreetName = "Smith Street", Description = "", IsListedForSale = true
};
_context.Properties.Find(property.Id).Returns(property);
// Act
var viewModel = builder.Build(property.Id);
// Assert
Assert.That(viewModel.ViewingDate, Is.AtMost(DateTime.Now));
}
public void SetUp()
{
parseTree = "<lessthanorequal 7>";
staticSyntax = Is.AtMost(7);
inheritedSyntax = Helper().AtMost(7);
builderSyntax = Builder().AtMost(7);
}
public void should_return_item_with_last_modified_date_within_a_minute_of_object_creation()
{
requestHeaderFields = new Dictionary <RequestHeaderFields, string>
{
{ RequestHeaderFields.IfModifiedSince, pastDateTime.ToString() }
};
using (var testHelper = new TestHelper(authToken, storageUrl))
{
ICloudFilesResponse getStorageItemResponse = null;
try
{
testHelper.PutItemInContainer();
var getStorageItem = new GetStorageItem(storageUrl, Constants.CONTAINER_NAME, Constants.StorageItemName, requestHeaderFields);
getStorageItemResponse = new GenerateRequestByType().Submit(getStorageItem, authToken);
Assert.That(getStorageItemResponse.Status, Is.EqualTo(HttpStatusCode.OK));
Assert.That(getStorageItemResponse.LastModified, Is.AtLeast(DateTime.Now.AddMinutes(-1)));
Assert.That(getStorageItemResponse.LastModified, Is.AtMost(DateTime.Now.AddMinutes(2)));
}
finally
{
if (getStorageItemResponse != null)
{
getStorageItemResponse.Dispose();
}
testHelper.DeleteItemFromContainer();
}
}
}
public IEnumerator StartAndCountTo100AndPauseAndResumeAt50()
{
countPos = 0;
SmartRoutine testObject = new SmartRoutine(CountToX(100));
Assert.That(SmartRoutineHelper.Instance.Routines.Count, Is.EqualTo(1), "1 SmartRoutine should be active.");
while (countPos != 50)
{
Assert.That(SmartRoutineHelper.Instance.Routines.Count, Is.EqualTo(1), "1 SmartRoutine should be active.");
yield return(new WaitForEndOfFrame());
}
Assert.That(SmartRoutineHelper.Instance.Routines.Count, Is.EqualTo(1), "1 SmartRoutine should be active.");
testObject.Stop(false);
Assert.That(testObject.IsPaused, Is.True, "SmartRoutine failed to pause.");
Assert.That(testObject.IsRunning, Is.True, "SmartRoutine stopped when it should be paused.");
Assert.That(SmartRoutineHelper.Instance.Routines.Count, Is.EqualTo(0), "No SmartRoutine should be active while paused.");
yield return(testObject);
Assert.That(countPos, Is.EqualTo(100), "Failed to count to 100.");
Assert.That(testObject.IsRunning, Is.False, "SmartRoutine failed to stop.");
Assert.That(SmartRoutineHelper.Instance.Routines.Count, Is.AtMost(0), "SmartRoutine did not complete.");
yield break;
}
/// <summary>
/// Tests creating a random integer generator with a particular set of lower bounds
/// and an integer count
/// </summary>
/// <param name="lowerBound">The lower bounds (inclusive) of the integers to be generated</param>
/// <param name="upperBound">The upper bounds (inclusive) of the integers to be generated</param>
/// <param name="count">The number of integers to be generated</param>
private void TestRandomIntegerGenerator(int lowerBound, int upperBound, int count)
{
Assert.That(count, Is.GreaterThanOrEqualTo(0));
Assert.That(lowerBound, Is.AtMost(upperBound));
IRandomIntegerGenerator randomIntGenerator = new RandomIntegerGenerator();
//Create the random integer generator
IEnumerable <int> randomIntegers = randomIntGenerator.CreateIntegerGenerator(lowerBound,
upperBound, count);
//Iterate over the random integers, verifying that there are the correct number of integers
//and that they all fall within the specified bounds
int integerCount = 0;
foreach (int randomInt in randomIntegers)
{
//Verify that the random integer is within the specified bounds
Assert.That(randomInt, Is.AtLeast(lowerBound));
Assert.That(randomInt, Is.AtMost(upperBound));
integerCount++;
}
//Verify that the correct number of integers were generated
Assert.That(integerCount, Is.EqualTo(count));
}
public void DefaultTimestampProvider_GetTimestamp_ReturnsValueInRange()
{
ITimestampProvider provider = new DefaultTimestampProvider();
long timestamp = provider.GetCurrentTimestampInMilliseconds();
Assert.That(timestamp,
Is.AtMost(IF_MORE_BASE_YEAR_MAY_BE_WRONG).And.AtLeast(IF_LESS_UNITS_ARE_WRONG));
}
public void PluginAPILevelIsLessThanOrEqualToSDKAPILevel()
{
if (!SDKUtility.sdkAvailable)
{
Assert.Ignore("Cannot locate Lumin SDK");
}
Assert.That(SDKUtility.pluginAPILevel, Is.AtMost(SDKUtility.sdkAPILevel));
}
public void CheckMaxLenghth()
{
// Create a random unique number
var number = randomNumberGen.GetUniqueRandomNumber();
// Check if its length is max 5
Assert.That(number, Is.AtMost(99999), "Number is greater than max number length of 5");
}
public void Test1()
{
var r1 = new RandomUsingOtherRandom();
var next = r1.Rand7();
Assert.That(next, Is.AtLeast(0));
Assert.That(next, Is.AtMost(6));
}
public IEnumerator StartAndRunToCompletionAndWaitFor1SecondWithArgs()
{
SmartRoutine testObject = new SmartRoutine(WaitFor);
yield return(testObject.Start(1f));
Assert.That(SmartRoutineHelper.Instance.Routines.Count, Is.AtMost(0), "SmartRoutine did not complete.");
yield break;
}
public void WrapModeLoopWillLoopTheTime()
{
animation["Clip1"].wrapMode = WrapMode.Loop;
for (int i = 0; i < 4; i++)
{
animation.UpdateAnimationStates(0.55f);
}
Assert.That(animation["Clip1"].time, Is.AtMost(0.21f));
Assert.That(animation["Clip1"].enabled, Is.True);
}
public void should_calculate_the_distance_correctly_between_two_points()
{
var london = new LocationCoordinate(51.500288, -0.126269);
var paris = new LocationCoordinate(48.856495, 2.350907);
var result = Resolve <IDistanceCalculatorService>().DistanceBetween(london, paris) / 1000;
Assert.That(result, Is.AtLeast(342));
Assert.That(result, Is.AtMost(343));
}
public IEnumerator StartAndRunToCompletionAndSetABoolOnComplete()
{
bool test = false;
SmartRoutine testObject = new SmartRoutine(WaitFor(), () => { test = true; });
yield return(testObject);
Assert.That(test, Is.True, "Callback did not invoke on completion.");
Assert.That(SmartRoutineHelper.Instance.Routines.Count, Is.AtMost(0), "SmartRoutine did not complete.");
}
public IEnumerator CreateAndStartAndYieldUntilComplete()
{
SmartRoutine testObject = new SmartRoutine(WaitFor());
yield return(testObject);
Assert.That(testObject.IsRunning, Is.False, "SmartRoutine did not complete.");
Assert.That(SmartRoutineHelper.Instance.Routines.Count, Is.AtMost(0), "SmartRoutine did not complete.");
yield break;
}
public IEnumerator CreateAndStartInline()
{
SmartRoutine testObject = new SmartRoutine(WaitFor());
Assert.That(testObject.IsRunning, Is.True, "SmartRoutine did not start.");
Assert.That(SmartRoutineHelper.Instance.Routines.Count, Is.EqualTo(1), "SmartRoutine did not start.");
testObject.Stop();
Assert.That(SmartRoutineHelper.Instance.Routines.Count, Is.AtMost(0), "SmartRoutine did not stop.");
yield break;
}
public IEnumerator StartAndRunToCompletionAndSetABoolOnStopForCompletion()
{
bool? test = null;
SmartRoutine testObject = new SmartRoutine(WaitFor(.5f), (bool x) => { test = x; });
yield return(testObject);
Assert.That(test, Is.True, "OnStop did not return true for completion.");
Assert.That(SmartRoutineHelper.Instance.Routines.Count, Is.AtMost(0), "SmartRoutine did not complete.");
}
public void WrapModeDefaultWillTakeTheWrapModeFromTheAnimationComponent()
{
animation["Clip1"].wrapMode = WrapMode.Default;
animation.wrapMode = WrapMode.Loop;
for (int i = 0; i < 4; i++)
{
animation.UpdateAnimationStates(0.55f);
}
Assert.That(animation["Clip1"].time, Is.AtMost(0.21f));
Assert.That(animation["Clip1"].enabled, Is.True);
}
public async Task WhenNoConnectionThrowSocketExceptionAfterMaxRetry()
{
var reconnectionAttempt = 0;
var config = new ConnectionConfiguration(onConnecting: (endpoint, attempt, elapsed) => Interlocked.Increment(ref reconnectionAttempt));
var socket = new TcpSocket(new Endpoint(new Uri("http://not.com"), null), config, TestConfig.InfoLog);
var resultTask = socket.ReadAsync(4, CancellationToken.None);
Assert.ThrowsAsync <ConnectionException>(async() => await resultTask);
Assert.That(reconnectionAttempt, Is.AtLeast(ConnectionConfiguration.Defaults.MaxConnectionAttempts + 1));
Assert.That(reconnectionAttempt, Is.AtMost(ConnectionConfiguration.Defaults.MaxConnectionAttempts + 2));
}
public void Test(int[] dimensions, int bestSoFar, int targetCases)
{
int features = dimensions.Length;
string[][] sources = new string[features][];
for (int i = 0; i < features; i++)
{
string featureName = "ABCDEFGHIJKLMNOPQRSTUVWXYZ".Substring(i, 1);
int n = dimensions[i];
sources[i] = new string[n];
for (int j = 0; j < n; j++)
{
sources[i][j] = featureName + j.ToString();
}
}
ICombiningStrategy strategy = new PairwiseStrategy();
PairCounter pairs = new PairCounter();
int cases = 0;
foreach (NUnit.Framework.Internal.TestCaseParameters parms in strategy.GetTestCases(sources))
{
for (int i = 1; i < features; i++)
{
for (int j = 0; j < i; j++)
{
string a = parms.Arguments[i] as string;
string b = parms.Arguments[j] as string;
pairs[a + b] = null;
}
}
++cases;
}
int expectedPairs = 0;
for (int i = 1; i < features; i++)
{
for (int j = 0; j < i; j++)
{
expectedPairs += dimensions[i] * dimensions[j];
}
}
Assert.That(pairs.Count, Is.EqualTo(expectedPairs), "Number of pairs is incorrect");
Assert.That(cases, Is.AtMost(bestSoFar), "Regression: Number of test cases exceeded target previously reached");
#if DEBUG
//Assert.That(cases, Is.AtMost(targetCases), "Number of test cases exceeded target");
#endif
}
public void it_should_return_the_date_at_the_beginning_of_the_week()
{
foreach (var date in _randomDates)
{
DateTime expected = date.AtBeginningOfWeek();
Assert.That(expected.DayOfWeek, Is.EqualTo(DayOfWeek.Sunday));
Assert.That(expected.TimeOfDay, Is.EqualTo(_midnight));
Assert.That(date.Day, Is.GreaterThanOrEqualTo(expected.Day));
Assert.That(date.Day - expected.Day, Is.AtMost(6));
}
}
public void it_should_return_the_date_at_the_end_of_the_week()
{
foreach (var date in _randomDates)
{
DateTime expected = date.AtEndOfWeek();
Assert.That(expected.DayOfWeek, Is.EqualTo(DayOfWeek.Saturday));
Assert.That(expected.TimeOfDay, Is.EqualTo(_endOfDay));
Assert.That(date.Day, Is.LessThanOrEqualTo(expected.Day));
Assert.That(expected.Day - date.Day, Is.AtMost(6));
}
}
