public void GetFolderContent_NonEmptyFolderGeneral(string vPath)
{
var currentFolder = SetupFoldersHierarchy(vPath);
const int foldersCount = 2;
const int filesCount = 3;
currentFolder
.CreateFolders(foldersCount)
.CreateFiles(filesCount);
Assert.NotNull(controller);
var actionResult = controller.GetFolderContent(vPath);
Assert.That(actionResult, Is.AssignableFrom <ObjectResult>());
var result = (ObjectResult)actionResult;
Assert.NotNull(result?.Value);
Assert.That(result.Value, Is.AssignableFrom <List <FileSystemInfoDto> >());
var list = (List <FileSystemInfoDto>)result.Value;
// Check total objects
Assert.That(list.Count, Is.EqualTo(foldersCount + filesCount));
Assert.That(list.FindAll(item => !item.IsFile).Count, Is.EqualTo(foldersCount));
Assert.That(list.FindAll(item => item.IsFile).Count, Is.EqualTo(filesCount));
var folders = list.GetRange(0, foldersCount);
var files = list.GetRange(foldersCount, filesCount);
// Check that folders goes before files
Assert.That(folders.Any((item) => item.IsFile), Is.False);
Assert.That(files.Any((item) => !item.IsFile), Is.False);
// Objects are sorted asc by name
Assert.That(files[0], Is.LessThan(files[filesCount - 1]));
}
/// <summary>
/// A subtest for testing ExecuteAsync when an exception is thrown while sending the request. This is tested
/// with and without back-off. If back-off handler is attached to the service's message handler, there should
/// be 3 tries (the default value of <seealso cref="ConfigurableMessageHandler.NumTries"/>) before the
/// operation fails.
/// </summary>
/// <param name="backOff">Indicates if back-off handler is attached to the service.</param>
private void SubtestExecuteAsync_ThrowException(bool backOff)
{
var handler = new MockMessageHandler(true);
var initializer = new BaseClientService.Initializer()
{
HttpClientFactory = new MockHttpClientFactory(handler)
};
// Configure the back-off behavior by the input.
initializer.DefaultExponentialBackOffPolicy = backOff ?
ExponentialBackOffPolicy.Exception : ExponentialBackOffPolicy.None;
using (var service = new MockClientService(initializer))
{
var request = new TestClientServiceRequest(service, "GET", null);
var task = request.ExecuteAsync();
try
{
var result = task.Result;
Assert.Fail("Exception should be thrown");
}
catch (AggregateException ex)
{
Assert.That(ex.InnerException, Is.AssignableFrom(typeof(InvalidOperationMockException)));
}
int calls = backOff ? service.HttpClient.MessageHandler.NumTries : 1;
Assert.That(handler.Calls, Is.EqualTo(calls));
}
}
public void CreateFile_WhichDoesNotEXists(string vPath)
{
Assert.NotNull(controller);
var currentFolder = SetupFoldersHierarchy(vPath);
var newFilename = "newFile.txt";
// File does not exists
Assert.False(currentFolder.FileExists(newFilename));
var actionResult = controller.Createfile(vPath, newFilename);
Assert.That(actionResult, Is.AssignableFrom <CreatedAtRouteResult>());
var result = (CreatedAtRouteResult)actionResult;
// File was created
Assert.That(currentFolder.FileExists(newFilename));
// route param is set correctly
var expectedRouteParam = string.Format("{0}/{1}", vPath, newFilename);
Assert.That(result.RouteValues["targetPath"], Is.EqualTo(expectedRouteParam));
// correct entry returned
Assert.That(result.Value, Is.AssignableFrom <FileSystemInfoDto>());
var dto = (FileSystemInfoDto)result.Value;
Assert.That(dto.Name, Is.EqualTo(newFilename));
Assert.That(dto.Path, Is.EqualTo(expectedRouteParam));
Assert.That(dto.IsFile);
}
public void CreateFile_WichExistsDontOverrideContent(string vPath)
{
Assert.NotNull(controller);
var currentFolder = SetupFoldersHierarchy(vPath);
var newFilename = "newFile22.txt";
const string expectedContent = "some initial content";
currentFolder.CreateFileWithContent(newFilename, expectedContent);
Assert.That(currentFolder.FileExists(newFilename));
var actionResult = controller.Createfile(vPath, newFilename);
Assert.That(actionResult, Is.AssignableFrom <CreatedAtRouteResult>());
var result = (CreatedAtRouteResult)actionResult;
//Assert that file was not ovewritten
Assert.That(currentFolder.FileExists(newFilename));
var newContent = currentFolder.ReadFile(newFilename);
Assert.That(newContent, Is.EqualTo(expectedContent));
// correct entry returned
Assert.That(result.Value, Is.AssignableFrom <FileSystemInfoDto>());
var dto = (FileSystemInfoDto)result.Value;
Assert.That(dto.Name, Is.EqualTo(newFilename));
Assert.That(dto.Path, Is.EqualTo(string.Format("{0}/{1}", vPath, newFilename)));
Assert.That(dto.IsFile);
}
public void CreateFolder_ShouldReturnOkForExistingFolder(string vPath)
{
Assert.NotNull(controller);
var currentFolder = SetupFoldersHierarchy(vPath);
var newFolderName = "folderNew";
currentFolder.CreateFolder(newFolderName);
Assert.That(currentFolder.FolderExists(newFolderName));
var actionResult = controller.CreateFolder(vPath, newFolderName);
Assert.That(actionResult, Is.AssignableFrom <CreatedAtRouteResult>());
var result = (CreatedAtRouteResult)actionResult;
// route param is set correctly
var expectedRouteParam = string.Format("{0}/{1}", vPath, newFolderName);
Assert.That(result.RouteValues["targetPath"], Is.EqualTo(expectedRouteParam));
// correct entry returned
Assert.That(result.Value, Is.AssignableFrom <FileSystemInfoDto>());
var dto = (FileSystemInfoDto)result.Value;
Assert.That(dto.Name, Is.EqualTo(newFolderName));
Assert.That(dto.Path, Is.EqualTo(expectedRouteParam));
Assert.That(dto.IsFile, Is.False);
}
public void CreateFolder_FolderDoesNotExists(string vPath)
{
Assert.NotNull(controller);
var currentFolder = SetupFoldersHierarchy(vPath);
var newFolderName = "folderNew";
var actionResult = controller.CreateFolder(vPath, newFolderName);
Assert.That(actionResult, Is.AssignableFrom <CreatedAtRouteResult>(), "actionResult is not ssignable from <CreatedAtRouteResult>");
var result = (CreatedAtRouteResult)actionResult;
// folder has been created
Assert.That(currentFolder.FolderExists(newFolderName), "New Folder does not exists");
// route param is set correctly
var expectedRouteParam = string.Format("{0}/{1}", vPath, newFolderName);
Assert.That(result.RouteValues["targetPath"], Is.EqualTo(expectedRouteParam), "Route path is incorrect");
// correct entry returned
Assert.That(result.Value, Is.AssignableFrom <FileSystemInfoDto>(), "value returned is not assignable from <FileSystemInfoDto>");
var dto = (FileSystemInfoDto)result.Value;
Assert.That(dto.Name, Is.EqualTo(newFolderName), "dto.Name is not setup corretcly");
Assert.That(dto.Path, Is.EqualTo(expectedRouteParam), "dto.Path is not setup correctly");
Assert.That(dto.IsFile, Is.False, "dto.IsFile should be false");
}
public void GetFolderContent_CorrectEntryValuesReturned(string vPath)
{
var currentFolder = SetupFoldersHierarchy(vPath);
const string foldername = "Myfolder";
const string fileName = "myFile.txt";
currentFolder.CreateFolder(foldername);
currentFolder.CreateFile(fileName);
Assert.NotNull(controller);
var actionResult = controller.GetFolderContent(vPath);
Assert.That(actionResult, Is.AssignableFrom <ObjectResult>());
var result = (ObjectResult)actionResult;
Assert.NotNull(result?.Value);
Assert.That(result.Value, Is.AssignableFrom <List <FileSystemInfoDto> >());
var list = (List <FileSystemInfoDto>)result.Value;
Assert.That(list.Count, Is.EqualTo(2));
//Check folder, it should be first
var folderDto = list[0];
Assert.That(folderDto.IsFile, Is.False);
Assert.That(folderDto.Name, Is.EqualTo(foldername));
Assert.That(folderDto.Path, Is.EqualTo(string.Format("{0}/{1}", vPath, foldername)));
//Check file, it should be second
var fileDto = list[1];
Assert.That(fileDto.IsFile);
Assert.That(fileDto.Name, Is.EqualTo(fileName));
Assert.That(fileDto.Path, Is.EqualTo(string.Format("{0}/{1}", vPath, fileName)));
}
public void ShouldReturnTheController()
{
IController controller = _factory.CreateController(_context, "UnitySimple"); //typeof(SimpleController));
Assert.That(controller, Is.Not.Null);
Assert.That(controller, Is.AssignableFrom(typeof(UnitySimpleController)));
}
/// <summary>
/// A subtest for testing async execute when an exception is thrown during sending the request, with or without
/// back-off handler. If back-off handler is attached to the service's message handler, there are going to be
/// several retries (up to 2 minutes).
/// </summary>
/// <param name="backOff">Indicates if back-off handler is attached to the service.</param>
private void SubtestExecuteAsync_ThrowException(bool backOff)
{
var handler = new MockMessageHandler(true);
var initializer = new BaseClientService.Initializer()
{
HttpClientFactory = new MockHttpClientFactory(handler)
};
// by default back-off is used, so disable it in case backOff is false
if (!backOff)
{
initializer.DefaultExponentialBackOffPolicy = BaseClientService.ExponentialBackOffPolicy.None;
}
using (var service = new MockClientService(initializer))
{
var request = new TestClientServiceRequest(service, "GET", null);
var task = request.ExecuteAsync();
try
{
var result = task.Result;
Assert.Fail("Exception should be thrown");
}
catch (AggregateException ex)
{
Assert.That(ex.InnerException, Is.AssignableFrom(typeof(InvalidOperationMockException)));
}
// if back-off is enabled, we use 2 minutes maximum wait time for a request, so we should make lg(120)
// + 1 calls
int calls = backOff ? (int)Math.Ceiling(Math.Log(120, 2) + 1) : 1;
Assert.That(handler.Calls, Is.EqualTo(calls));
}
}
public void ShouldReturnTheSimpleDependencyAndCastToAnInterface()
{
var depedency = _dependencyResolver.GetImplementationOf <IDependency>(typeof(SimpleDependency));
Assert.That(depedency, Is.Not.Null);
Assert.That(depedency, Is.AssignableFrom(typeof(SimpleDependency)));
}
public void Test10()
{
using (var session = Domain.OpenSession())
using (var tx = session.OpenTransaction()) {
var exception = Assert.Throws<QueryTranslationException>(
() => session.Query.All<AClassTable>().OfType<IB1>()
.OfType<BaseEntity>().Run());
Assert.That(exception.InnerException, Is.AssignableFrom(typeof(NotSupportedException)));
}
using (var session = Domain.OpenSession())
using (var tx = session.OpenTransaction()) {
var exception = Assert.Throws<QueryTranslationException>(
() => session.Query.All<AConcreteTable>().OfType<IB1>()
.OfType<BaseEntity>().Run());
Assert.That(exception.InnerException, Is.AssignableFrom(typeof(NotSupportedException)));
}
using (var session = Domain.OpenSession())
using (var tx = session.OpenTransaction()) {
var exception = Assert.Throws<QueryTranslationException>(
() => session.Query.All<ASingleTable>().OfType<IB1>()
.OfType<BaseEntity>().Run());
Assert.That(exception.InnerException, Is.AssignableFrom(typeof(NotSupportedException)));
}
}
public void Language_DoesProduceCorrectTokens()
{
string test = null;
Grammar.Token[] testit() => new Grammar.Lexer(new StringReader(test)).ToArray();
test = "using namespace @namespace;";
var expected = new[] { Using, Namespace, Identifier, Semicolon, Eof };
var result = testit();
var resultTerminals = result.Select(r => r.Terminal).ToArray();
Assert.That(resultTerminals, Is.EquivalentTo(expected));
Assert.That(result[2], Is.AssignableFrom <IdentifierToken>());
Assert.That((result[2] as IdentifierToken).Name, Is.EqualTo("namespace"));
Assert.That(result[2].Lexeme, Is.EqualTo("@namespace"));
Assert.That(result.AsLexemes(), Is.EquivalentTo(new[] { "using", "namespace", "@namespace", ";", null }));
test = "34.3f";
result = testit();
Assert.That(result[0], Is.TypeOf <NumberToken>());
var number = result[0] as NumberToken;
Assert.That(number.GetFloatValue(), Is.EqualTo(34.3f));
Assert.That(number.IsTypeSpecified, Is.True);
Assert.That(number.TypeSuffix, Is.EqualTo('f'));
}
public async Task DetailsTestAsync()
{
DepartmentsController controller = new DepartmentsController(_context);
var actResult = await controller.Details(null);
Assert.IsTrue(typeof(NotFoundResult).IsInstanceOfType(actResult));
Assert.That(actResult, Is.AssignableFrom <NotFoundResult>());
actResult = await controller.Details(2687658);
Assert.IsTrue(typeof(NotFoundResult).IsInstanceOfType(actResult));
Assert.That(actResult, Is.AssignableFrom <NotFoundResult>());
actResult = await controller.Details(2);
Assert.IsTrue(typeof(ViewResult).IsInstanceOfType(actResult));
Assert.That(actResult, Is.AssignableFrom <ViewResult>());
ViewResult viewResult = actResult as ViewResult;
Department department = (Department)viewResult.Model;
decimal budget = department.Budget;
Assert.That(budget, Is.Not.Null);
}
public void Return_statement(string text)
{
var parser = new Parser(new Lexer(text));
var program = parser.ParseProgram();
Assert.That(program.Statements[0], Is.AssignableFrom <ReturnStatement>());
}
public void CorrectSingleProjectBoostTestDiscovererDispatchingExternalDll()
{
BoostTestAdapterSettings settings = CreateAdapterSettings();
settings.ExternalTestRunner = CreateExternalRunnerSettings(BoostTestDiscoverer.DllExtension);
// source that supports --list-content parameter
var source = "ListContentSupport" + BoostTestDiscoverer.ExeExtension;
var discoverer = this.DiscovererFactory.GetDiscoverer(source, settings);
Assert.That(discoverer, Is.Not.Null);
Assert.That(discoverer, Is.AssignableFrom(typeof(ListContentDiscoverer)));
// source that NOT supports --list-content parameter
source = "ParseSources" + BoostTestDiscoverer.ExeExtension;
discoverer = this.DiscovererFactory.GetDiscoverer(source, settings);
Assert.That(discoverer, Is.Not.Null);
Assert.That(discoverer, Is.AssignableFrom(typeof(SourceCodeDiscoverer)));
// source dll project
source = "DllProject" + BoostTestDiscoverer.DllExtension;
discoverer = this.DiscovererFactory.GetDiscoverer(source, settings);
Assert.That(discoverer, Is.Not.Null);
Assert.That(discoverer, Is.AssignableFrom(typeof(ExternalDiscoverer)));
}
public void ShouldReturnTheSimpleDependency()
{
IDependency depedency = _dependencyResolver.GetImplementationOf <SimpleDependency>();
Assert.That(depedency, Is.Not.Null);
Assert.That(depedency, Is.AssignableFrom(typeof(SimpleDependency)));
}
public void TestConstruction()
{
var obj = new ClassWithLists();
var container = new NodeContainer();
var model = container.GetOrCreateNode(obj);
Assert.That(model["IntList"].Retrieve(), Is.SameAs(obj.IntList));
Assert.That(model["IntList"].IsReference, Is.False);
Assert.That(model["ClassList"].Retrieve(), Is.SameAs(obj.ClassList));
//Assert.That(model["ClassList"].Reference, Is.AssignableFrom(typeof(ReferenceEnumerable)));
Assert.That(model["SimpleStructList"].Retrieve(), Is.SameAs(obj.SimpleStructList));
//Assert.That(model["SimpleStructList"].Reference, Is.AssignableFrom(typeof(ReferenceEnumerable)));
Assert.That(model["NestedStructList"].Retrieve(), Is.SameAs(obj.NestedStructList));
//Assert.That(model["NestedStructList"].Reference, Is.AssignableFrom(typeof(ReferenceEnumerable)));
Assert.That(model["ListOfSimpleStructLists"].Retrieve(), Is.SameAs(obj.ListOfSimpleStructLists));
//Assert.That(model["ListOfSimpleStructLists"].Reference, Is.AssignableFrom(typeof(ReferenceEnumerable)));
foreach (var reference in model["ListOfSimpleStructLists"].Target.ItemReferences)
{
Assert.That(reference, Is.AssignableFrom(typeof(ObjectReference)));
}
Assert.That(model["ListOfNestedStructLists"].Retrieve(), Is.SameAs(obj.ListOfNestedStructLists));
//Assert.That(model["ListOfNestedStructLists"].Reference, Is.AssignableFrom(typeof(ReferenceEnumerable)));
foreach (var reference in model["ListOfNestedStructLists"].Target.ItemReferences)
{
Assert.That(reference, Is.AssignableFrom(typeof(ObjectReference)));
}
Assert.That(container.GetNode(obj.ClassList[0]), !Is.Null);
}
public void Handler_Can_Be_Resolved_When_Not_Registered_With_Assembly_Filtering()
{
//ARRANGE
object action;
object boolean;
object logger = new Mock <IGWLogger <BaseMessageHandler <TestMessage> > >().Object;
_mockDependenyResolver.Setup(x => x.TryResolve(typeof(Action), out action))
.Returns(true);
_mockDependenyResolver.Setup(x => x.TryResolve(typeof(IGWLogger <BaseMessageHandler <TestMessage> >), out logger))
.Returns(true);
_mockDependenyResolver.Setup(x => x.TryResolve(typeof(bool), out boolean))
.Returns(true);
_mockHandlerResolverSettings.Setup(x => x.LimitAssembliesTo)
.Returns(new List <Assembly> {
GetType().Assembly
});
_mockHandlerResolverSettings.Setup(x => x.HasCustomAssemblyList).Returns(true);
var handlerResolver =
new HandlerResolver(_mockDependenyResolver.Object, _mockHandlerResolverSettings.Object);
//ACT
var handler = handlerResolver.ResolveAllHandlersFor(typeof(TestMessage));
//ASSERT
Assert.That(handler.Single(), Is.AssignableFrom(typeof(TestMessageHandler)));
}
public void TestPersistCustomFields()
{
string fieldsetName = "Foo_+ Bar";
string fieldName = "Baz";
string fieldValue = "noop";
var dumbValues = new Dictionary <string, string>();
dumbValues.Add(fieldName, fieldValue);
view.CustomFields[fieldsetName] = dumbValues;
view.Update();
View fromId = View.FromId(view.id);
Expect(fromId.CustomFields, Is.Not.Null, "should have custom fields defined");
Expect(fromId.CustomFields, Is.AssignableFrom(typeof(Dictionary <string, object>)));
Expect(fromId.CustomFields[fieldsetName], Is.Not.Null);
Expect(fromId.CustomFields[fieldsetName], Is.AssignableFrom(typeof(Dictionary <string, object>)));
Expect(fromId.MetadataFieldset(fieldsetName), Is.Not.Null, "should have a metadata fieldset");
Expect((string)fromId.MetadataFieldset(fieldsetName)[fieldName], Is.EqualTo(fieldValue), "value should be what we set it to");
}
public void SetUp()
{
parseTree = "<assignablefrom System.String>";
staticSyntax = Is.AssignableFrom(typeof(string));
inheritedSyntax = Helper().AssignableFrom(typeof(string));
builderSyntax = Builder().AssignableFrom(typeof(string));
}
public void Should_BeImpossibleTo_FindHiddenElements_WithWrongArguments(ElementsCount count, ElementState state)
{
const string name = "custom name";
Assert.Throws(Is.AssignableFrom(typeof(TimeoutException)).And.Message.Contains(name),
() => FindElements <Label>(HiddenElementsLoc, name, expectedCount: count, state: state),
$"Tried to find elements with expected count '{count}' and state '{state}'");
}
public void GetServiceFromContainer()
{
var service = ServiceContainer.GetService(typeof(ITestInterface));
Assert.That(service, Is.Not.Null);
Assert.That(service, Is.AssignableFrom(typeof(MyTestImplementation)));
Assert.That(service, Is.AssignableTo(typeof(ITestInterface)));
}
public void Test_GetNetworkLink()
{
var result = testCandidate.GetNetworkLink(Guid.NewGuid());
Assert.IsNotNull(result);
Assert.AreEqual(result.LinkGeometry, lineGeometry);
Assert.That(result.Id, Is.AssignableFrom(typeof(Guid)));
}
public void GetImageSourceForFileSystemEntryShouldReturnOverlayedIconWhenIsExcludedAndIsValid()
{
ImageSource result = iconProvider.GetImageSourceForFileSystemEntry(testFileName, true, true);
Assert.That(result, Is.Not.Null);
Assert.That(result, Is.AssignableFrom <DrawingImage>());
Assert.That(result.Width, Is.GreaterThan(0));
}
public void IsAssignableFrom()
{
int[] array10 = new int[10];
Assert.IsAssignableFrom(typeof(int[]), array10);
Assert.That(array10, Is.AssignableFrom(typeof(int[])));
Assert.IsAssignableFrom <int[]>(array10);
}
public void Let_expression_parses_as_let_expression(string text)
{
var parser = new Parser(new Lexer(text));
var program = parser.ParseProgram();
Assert.That(program.Statements[0], Is.AssignableFrom <LetStatement>());
AssertNoErrors(parser);
}
public void Test_GetNearestSegment()
{
var result = testCandidate.GetNearestSegment(dbGeometry);
Assert.IsNotNull(result);
Assert.AreEqual(result.First().Item1.LinkGeometry, lineGeometry);
Assert.That(result.First().Item1.Id, Is.AssignableFrom(typeof(Guid)));
}
public void AssignableFromTypeTests()
{
Assert.IsAssignableFrom(typeof(string), "Hello");
Assert.IsNotAssignableFrom(typeof(string), 5);
Assert.That("Hello", Is.AssignableFrom(typeof(string)));
Assert.That(5, Is.Not.AssignableFrom(typeof(string)));
}
public void CreateFromMemoryUseMemoryStream()
{
var dataStream = DataStreamFactory.FromMemory();
Assert.That(dataStream.BaseStream, Is.AssignableFrom <RecyclableMemoryStream>());
dataStream.Dispose();
}
public void AssignableFromTypeTests()
{
// Classic syntax
Assert.IsAssignableFrom(typeof(string), "Hello");
Assert.IsNotAssignableFrom(typeof(string), 5);
// Constraint Syntax
Assert.That("Hello", Is.AssignableFrom(typeof(string)));
Assert.That(5, Is.Not.AssignableFrom(typeof(string)));
}
