public void TestIndex()
{
// Arrange
var movies = new List<Movie> {
new Movie {Title="Star Wars", Director="Lucas"},
new Movie {Title="Star Wars II", Director="Lucas"},
new Movie {Title="Star Wars III", Director="Lucas"}
};
var mockMovieRepository = new Mock<IMovieRepository>();
mockMovieRepository.Setup(r => r.ListAllMovies()).Returns(movies);
var controller = new HomeController(mockMovieRepository.Object);
var vm = new List<IndexViewModel>();
movies.ToList().ForEach(m => vm.Add(new IndexViewModel {
Id = m.Id,
Title = m.Title,
Director = m.Director
}));
// Act
var result = (ViewResult)controller.Index();
var model = (List<IndexViewModel>)result.Model;
// Assert
Assert.AreEqual(vm[0].Title, model[0].Title);
}
List<int> BubbleSort(List<int> l)
{
var result = l.ToList();
swapped = true;
while (swapped)
{
i = 0;
swapped = false;
while (i < result.Count - 1)
{
if (result[i] > result[i + 1])
{
t = result[i];
result[i] = result[i + 1];
result[i + 1] = t;
swapped = true;
}
i = i + 1;
}
}
return result;
}
public void TestComponentAbilityFiltering()
{
// targeted test data
var provoke = new TestBattleAbility("Provoke", true, false, false);
var fire = new TestBattleAbility("Fire", true, false, false);
// Buffs test data
var protect = new TestBattleAbility("Protect", true, true, true);
var shell = new TestBattleAbility("Shell", true, true, true);
// Enabled test data
var water = new TestBattleAbility("Water", false, false, false);
var testData = new List<TestBattleAbility>
{
provoke,
protect,
shell,
fire,
water
};
// Create the desired outcome with water removed since
// it won't be enabled.
var desiredOutcome = testData.ToList();
desiredOutcome.Remove(water);
var ordering = testData
.Where(x => x.Enabled)
.Where(x => x.IsBuff && x.HasEffectWore || !x.IsBuff);
Assert.IsTrue(ordering.SequenceEqual(desiredOutcome));
}
public void DeleteTheBest()
{
Random r = new Random();
List<int> values = new List<int>();
for (int i = 0; i < 100; i++)
{
values.Add(r.Next(100) - r.Next(100));
}
foreach (int value in values)
{
heap.Insert(value);
}
int deleteCount = r.Next(values.Count);
List<int> sortedValues = values.ToList();
sortedValues.Sort(comparision);
sortedValues.Reverse();
int expectedTheBestValue = sortedValues.Skip(deleteCount).FirstOrDefault();
for (int i = 0; i < deleteCount; i++)
{
Assert.IsTrue(heap.DeleteTheBest());
}
Assert.AreEqual(values.Count - deleteCount, heap.Count);
Assert.AreEqual(expectedTheBestValue, heap.GetTheBest());
}
public void OrderByNameDescendingTest()
{
var expextedResult = new List<Employee>() { employeeB, employeeA, employeeC }.AsQueryable();
var result = employeeList.AsQueryable().SortListBy(x => x.FirstName, ListSortDirection.Descending);
Assert.IsTrue(expextedResult.ToList().SequenceEqual(result.ToList(), new EmployeeListComparer()));
}
public void EmptySequenceList()
{
IList<Bid> expected = new List<Bid>();
IList<BiddingSequence> biddingSequences = new List<BiddingSequence>();
var result = BiddingConverter.Convert(biddingSequences);
CollectionAssert.AreEqual(expected.ToList(), result.ToList());
}
public void AddFieldsForReturnsErrorWhenEmptyFieldDisplayIsAdded()
{
// Setup
const string Tenant = "tenant";
var mockTenant = new Mock<Tenant>();
var metadata = new UDFMetadata { Name = "name", Display = string.Empty };
var mockTenantStore = new Mock<ITenantStore>();
mockTenantStore.Setup(m => m.GetTenant(Tenant)).Returns(mockTenant.Object);
IEnumerable<UDFMetadataError> errors = new List<UDFMetadataError>();
var udfDictionary = new UDFDictionary(mockTenantStore.Object);
// Act
var result = udfDictionary.AddFieldFor<TestExtension>(Tenant, metadata, out errors);
// Assert
Assert.IsFalse(result);
Assert.IsTrue(errors.Count() > 0);
Assert.AreEqual(UDFMetadataField.Display, errors.ToList()[0].Field);
Assert.AreEqual("Cannot be empty", errors.ToList()[0].Message);
}
public void TiposItemController_AgregarTipoDeItemAProyecto()
{
HelperTestSistema.LimpiarArchivoBD();
HelperTestSistema.IniciarServidor();
//Creamos 1 proyecto1 directamente en la BD con dos tipos de item
var tiposDeItemProyecto1 = HelperInstanciacionItems.GetTiposDeItem( "Proyecto 1", 2 );
var proyecto = HelperInstanciacionProyectos.GetProyectos( 1 )[0];
proyecto.AgregarTipoDeItem( tiposDeItemProyecto1[0] );
proyecto.AgregarTipoDeItem( tiposDeItemProyecto1[1] );
//Guardamos los objetos en la BD
using ( IContextoProceso contexto = new ContextoProceso( HelperTestSistema.ObjectFactory ) )
{
contexto.ContenedorObjetos.Store( proyecto );
}
HelperTestSistema.ReiniciarConexion();
//Creamos un tipo de item y lo agregamos al proyecto a traves de la API
var controller = new TiposItemController( HelperTestSistema.ObjectFactory );
//Obtenemos el 2 ya que tenemos que simular un nuevo tipo de item
var nuevoTipoItem = HelperInstanciacionItems.GetTiposDeItem( "Proyecto 1" ,3 )[2];
controller.Post( "P1", nuevoTipoItem );
HelperTestSistema.ReiniciarConexion();
//Obtenemos los datos directamente de la base de datos para verificarlos
var proyectosBD = new List<Proyecto>();
using ( IContextoProceso contexto = new ContextoProceso(HelperTestSistema.ObjectFactory) )
{
proyectosBD = (from Proyecto p in contexto.ContenedorObjetos select p).ToList();
}
HelperTestSistema.ReiniciarConexion();
HelperTestSistema.FinalizarServidor();
//Asserts
Assert.Inconclusive( "Refactorizar y terminar este test" );
//Debe haber un solo proyecto en la base de datos
Assert.AreEqual( 1, proyectosBD.ToList().Count );
//El proyecto debe tener 3 tipos de item
Assert.AreEqual( 3, proyectosBD[0].TiposDeItem.Count() );
//El tercer tipo de item debe ser el que agregamos
Assert.AreEqual( "Proyecto 1-Tipo de item de prueba 3", proyectosBD[0].TiposDeItem.ToList()[2].Descripcion );
}
public void GetAllSuperheroes_WhenThereAreSuperheroes()
{
var superherosList = new List<Superhero>()
.AsQueryable();
Mock.Arrange(() => this.mockSuperheroes.Entities)
.Returns(superherosList);
var service = new SuperheroesService(this.mockUnitOfWork, this.mockSuperheroes, this.mockPowers, this.mockCities);
var superheroes = service.GetAllSuperheroes()
.ToList();
CollectionAssert.AreEqual(superherosList.ToList(), superheroes);
}
static DatamodelTests()
{
var binary = new byte[16];
new Random().NextBytes(binary);
var quat = Quaternion.Normalize(new Quaternion(1, 2, 3, 4)); // dmxconvert will normalise this if I don't!
TestValues_V1 = new List<object>(new object[] { "hello_world", 1, 1.5f, true, binary, null, System.Drawing.Color.Blue,
new Vector2(1,2), new Vector3(1,2,3), new Vector4(1,2,3,4), quat, new Matrix4x4(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16) });
TestValues_V2 = TestValues_V1.ToList();
TestValues_V2[5] = TimeSpan.FromMinutes(5) + TimeSpan.FromTicks(TimeSpan.TicksPerMillisecond / 2);
TestValues_V3 = TestValues_V1.Concat(new object[] { (byte)0xFF, (UInt64)0xFFFFFFFF }).ToList();
}
public void AutoMapperTest()
{
List<User> users = new List<User>
{
new User("1","1",null),
new User("2","2",null)
};
Mapper.CreateMap<User, UserDTO>();
Mapper.AssertConfigurationIsValid();
List<UserDTO> userDtos = Mapper.Map<List<User>, List<UserDTO>>(users.ToList());
Assert.IsTrue(userDtos.Count == 2);
}
public void Search_Empty_Query_Expected_View_Result_Returned()
{
// Arrange
string query = string.Empty;
var stubResultsExpected = new List<SearchResultItem>();
_mockSearchService.Setup(x => x.Search(query)).Returns(stubResultsExpected.ToList());
// Act
var result = _controller.Search(string.Empty);
var model = result.Model as SearchResultViewModel;
// Assert
model.SearchQuery.Should().Be(query, " because that was the query we entered");
model.Results.ShouldAllBeEquivalentTo(stubResultsExpected, " we expect the method to return the result from ISearchService unchanged");
}
public void DeckInitialisedWithCorrectCardsFromCardList()
{
List<Card> cards = new List<Card>();
cards.Add(new Card() { Name = "TestCard1" });
cards.Add(new Card() { Name = "TestCard2" });
cards.Add(new Card() { Name = "TestCard2" });
cards.Add(new Card() { Name = "TestCard3" });
Deck deck = Deck.CreateFromCardList(cards);
CollectionAssert.AreEquivalent(
deck.Cards.ToList(),
cards.ToList(),
"Deck contains correct list of cards.");
}
List<int> Reverse(List<int> l)
{
var result = l.ToList();
i = 0;
s = result.Count;
while (i < s)
{
t = result[i];
result.RemoveAt(i);
result.Insert(0, t);
i = i + 1;
}
return result;
}
public void SeveralTheatres_ListTheatres_ShouldReturnListedTheatres()
{
//Arrange
var database = new PerformanceDatabase();
//Act
database.AddTheatre("Theatre Gosho");
database.AddTheatre("Theatre Petka");
database.AddTheatre("Ivana Theatre");
var listed = database.ListTheatres();
var expected = new List<IEnumerable> { "Ivana Theatre", "Theatre Gosho", "Theatre Petka" };
//Assert
CollectionAssert.AreEqual(expected.ToList(), listed.ToList());
}
public void OrderBy()
{
var sigilTypes = typeof(Emit<>).Assembly.GetTypes();
var linq = sigilTypes.Single(t => t.Name == "LinqAlternative");
var sigilListGeneric = sigilTypes.Single(t => t.Name == "LinqList`1");
var sigilListT = sigilListGeneric.MakeGenericType(typeof(Tuple<int, double>));
var sigilListCons = sigilListT.GetConstructor(new[] { typeof(List<Tuple<int, double>>) });
var sigilFuncGeneric = sigilTypes.Single(t => t.Name == "SigilFunc`2");
var sigilFunc = sigilFuncGeneric.MakeGenericType(typeof(Tuple<int, double>), typeof(double));
var asEnumerable = sigilListT.GetMethod("AsEnumerable");
var orderByGeneric = sigilListT.GetMethod("OrderBy");
var orderBy = orderByGeneric.MakeGenericMethod(typeof(double));
var toSort = new List<Tuple<int, double>>();
var rand = new Random();
for (var i = 0; i < 1000; i++)
{
toSort.Add(Tuple.Create(i, rand.NextDouble()));
}
Func<Tuple<int, double>, double> p1 = _OrderSelect;
var p2 = Delegate.CreateDelegate(sigilFunc, this.GetType().GetMethod("_OrderSelect"));
var asSigilList = sigilListCons.Invoke(new object[] { toSort });
var sigilOrderedInternal = orderBy.Invoke(asSigilList, new object[] { p2 });
var sigilOrdered = (IEnumerable<Tuple<int, double>>)asEnumerable.Invoke(sigilOrderedInternal, new object[0]);
var linqOrdered = toSort.ToList().OrderBy(p1);
var sigilList = sigilOrdered.ToList();
var linqList = linqOrdered.ToList();
Assert.AreEqual(linqList.Count, sigilList.Count);
for (var i = 0; i < linqList.Count; i++)
{
Assert.AreEqual(linqList[i], sigilList[i]);
}
}
public void CodeGen_ObjectTo_List()
{
List<String> list = new List<string> { "1", "2" };
ArrayList arrayList = new ArrayList(list);
List<String> list2 = Utils.ObjectToList<string>(arrayList);
CheckOutputList(list, list2);
string[] array = list.ToArray();
List<String> list3 = Utils.ObjectToList<string>(array);
CheckOutputList(list, list3);
List<string> listCopy = list.ToList();
List<String> list4 = Utils.ObjectToList<string>(listCopy);
CheckOutputList(list, list4);
IReadOnlyList<string> readOnlyList = list.ToList();
List<String> list5 = Utils.ObjectToList<string>(readOnlyList);
CheckOutputList(list, list5);
}
public void Search_NonEmpty_Query_Expected_View_Result_Returned()
{
// Arrange
string query = "TFS";
var stubResultsExpected = new List<SearchResultItem>
{
new SearchResultItem("p1", "e1", "en1"),
new SearchResultItem("p2", "e2", "en2")
};
_mockSearchService.Setup(x => x.Search(query)).Returns(stubResultsExpected.ToList());
// Act
var result = _controller.Search(query);
// Assert
var model = result.Model as SearchResultViewModel;
model.SearchQuery.Should().Be(query, " because that was the query we entered");
model.Results.ShouldBeEquivalentTo(stubResultsExpected, options => options.WithStrictOrdering(), " we expect the method to return the result from ISearchService unchanged");
}
public void ClrNamespace()
{
var type = typeof(DummyClass);
string clrNamespace = $"clr-namespace:{type.Namespace};Assembly={type.GetTypeInfo().Assembly.GetName().Name}";
var prefix = "prefix";
var input = new List<ProtoXamlInstruction>
{
P.NamespacePrefixDeclaration(prefix, clrNamespace),
P.EmptyElement(type, RootNs),
};
var expectedInstructions = new List<XamlInstruction>
{
X.NamespacePrefixDeclaration(clrNamespace, prefix),
X.StartObject<DummyClass>(),
X.EndObject(),
};
var actualNodes = sut.Parse(input);
CollectionAssert.AreEqual(expectedInstructions.ToList(), actualNodes.ToList());
}
public void TestKruskalWith9VerticesAnd11Edges()
{
int numberOfVertices = 9;
var graphEdges = new List<Edge>
{
new Edge(0, 3, 9),
new Edge(0, 5, 4),
new Edge(0, 8, 5),
new Edge(1, 4, 8),
new Edge(1, 7, 7),
new Edge(2, 6, 12),
new Edge(3, 5, 2),
new Edge(3, 6, 8),
new Edge(3, 8, 20),
new Edge(4, 7, 10),
new Edge(6, 8, 7)
};
var minimumSpanningForest = KruskalAlgorithm.Kruskal(numberOfVertices, graphEdges.ToList());
var totalWeight = minimumSpanningForest.Sum(edge => edge.Weight);
var expectedTotalWeight = 45;
var expectedForest = new[]
{
graphEdges[6],
graphEdges[1],
graphEdges[2],
graphEdges[4],
graphEdges[10],
graphEdges[3],
graphEdges[5]
};
Assert.AreEqual(expectedTotalWeight, totalWeight, "Weights should match.");
CollectionAssert.AreEqual(
expectedForest,
minimumSpanningForest,
"The correct edges should be present in the MST in the correct order.");
}
public void AddFieldsForReturnsErrorWhenDuplicateFieldIsAdded()
{
// Setup
const string Tenant = "tenant";
var mockTenant = new Mock<Tenant>();
var metadata = new UDFMetadata { Name = "custom", Display = "custom" };
var duplicateMetadata = new UDFMetadata { Name = "custom", Display = "custom" };
var mockTenantStore = new Mock<ITenantStore>();
mockTenantStore.Setup(m => m.GetTenant(Tenant)).Returns(mockTenant.Object);
IEnumerable<UDFMetadataError> errors = new List<UDFMetadataError>();
var udfDictionary = new UDFDictionary(mockTenantStore.Object);
udfDictionary.AddFieldFor<TestExtension>(Tenant, metadata, out errors);
// Act
var result = udfDictionary.AddFieldFor<TestExtension>(Tenant, duplicateMetadata, out errors);
// Assert
Assert.IsFalse(result);
Assert.IsTrue(errors.Count() > 0);
Assert.IsTrue(errors.ToList()[0].Field == UDFMetadataField.Name);
}
public void NamespaceDeclarationOnly()
{
var input = new List<ProtoXamlInstruction>
{
P.NamespacePrefixDeclaration(RootNs),
};
var expectedInstructions = new List<XamlInstruction>
{
X.NamespacePrefixDeclaration(RootNs),
};
var actualNodes = sut.Parse(input);
CollectionAssert.AreEqual(expectedInstructions.ToList(), actualNodes.ToList());
}
public void TestGetFilmById()
{
var filmData = new List<DatabaseClient.TableEntity.Film>
{
new Film { description = "Most anticipated film this year", film_id = 1, length = 47, release_year = 2015, title = "Brazzers best shots" },
new Film { description = "Wystraczy Cię na śmierć", film_id = 2, length = 97, release_year = 2001, title = "Jumanji" },
new Film { description = "Na faktach autentycznych", film_id = 3, length = 97, release_year = 2011, title = "Wysyp żywych trupów" }
}.AsQueryable();
var filmSet = new Mock<DbSet<Film>>();
filmSet.As<IQueryable<Film>>().Setup(m => m.Provider).Returns(filmData.Provider);
filmSet.As<IQueryable<Film>>().Setup(m => m.Expression).Returns(filmData.Expression);
filmSet.As<IQueryable<Film>>().Setup(m => m.ElementType).Returns(filmData.ElementType);
filmSet.As<IQueryable<Film>>().Setup(m => m.GetEnumerator()).Returns(filmData.GetEnumerator());
var categoryData = new List<DatabaseClient.TableEntity.Category>
{
new Category{category_id=11,last_update=DateTime.Now, name="Horror"},
new Category{category_id=4,last_update=DateTime.Now, name="Biography"}
}.AsQueryable();
var categorySet = new Mock<DbSet<Category>>();
categorySet.As<IQueryable<Category>>().Setup(m => m.Provider).Returns(categoryData.Provider);
categorySet.As<IQueryable<Category>>().Setup(m => m.Expression).Returns(categoryData.Expression);
categorySet.As<IQueryable<Category>>().Setup(m => m.ElementType).Returns(categoryData.ElementType);
categorySet.As<IQueryable<Category>>().Setup(m => m.GetEnumerator()).Returns(categoryData.GetEnumerator());
var mockContext = new Mock<DVDRentalContext>();
mockContext.Setup(context => context.Films).Returns(filmSet.Object);
mockContext.Setup(context => context.Categorys).Returns(categorySet.Object);
List<FilmToCategory> ftc = new List<FilmToCategory>()
{
new FilmToCategory{category_id=4,film_id=2},
new FilmToCategory{category_id=11,film_id=2}
};
mockContext.Setup(context => context.FillEntity<FilmToCategory>(It.IsAny<string>()))
.Returns(ftc);
repository = new FilmContext(mockContext.Object);
var result = repository.GetFilmById(2);
var expectedFilm = filmData.ToList()[1];
Assert.AreEqual(expectedFilm.film_id, result.Id);
Assert.AreEqual(expectedFilm.length, result.Length);
Assert.AreEqual(expectedFilm.release_year, result.ReleaseYear);
Assert.AreEqual(expectedFilm.title, result.Title);
Assert.AreEqual(expectedFilm.description, result.Description);
Assert.AreEqual(typeof(Models.Film), result.GetType()); // testowanie mapowania
Assert.AreEqual(2, result.Categories.Count());
Assert.AreEqual(typeof(List<Models.Category>), result.Categories.ToList().GetType()); // testowanie mapowania
}
public void GetAllByDate_WhenValid_ShouldReturnBugsCollection()
{
var repo = Mock.Create<IRepository<Bug>>();
var bugs =
new List<Bug> { new Bug() { LogDate = DateTime.Now, Status = Status.Pending, Text = "Tralala 1" } }
.AsQueryable();
Mock.Arrange(() => repo.All()).Returns(() => bugs);
var controller = new BugsController(repo);
var result = controller.GetAfterDate("20-02-2014");
CollectionAssert.AreEqual(
bugs.ToList(),
(result as OkNegotiatedContentResult<IQueryable<Bug>>).Content.ToList());
}
public void SubscriberServicesModel_When_MaxBandwidth_variable_is_null_MaxBandwidthList_matches_count_of_values_from_configuration_file_and_the_values_match_too()
{
// Arrange
var output = new StringBuilder();
Assert.IsNotNull(_expectedBandwidthValues, "The appSettings key MaxBandwidthValues is missing from the unit test App.Config file");
// First item is empty string for the UI
var expectedMaxBandwidthList = new List<string>
{
string.Empty
};
// Other items are coming from the MaxBandwidthValues appSettings
expectedMaxBandwidthList.AddRange(_expectedBandwidthValues.Split(','));
// Act
var actualSubscriberServicesModel = new SubscriberServicesModel();
actualSubscriberServicesModel.MaxBandwidth = null;
// Assert
if (expectedMaxBandwidthList.Count != actualSubscriberServicesModel.MaxBandwidthList.Count())
{
output.AppendLine();
output.AppendFormat("The expected and actual lists have different number of items, {0} compared to {1} respectively", expectedMaxBandwidthList.Count, actualSubscriberServicesModel.MaxBandwidthList.Count());
output.AppendLine();
output.AppendFormat("The expected list has the following values {0}", string.Join(", ", expectedMaxBandwidthList.ToList()));
output.AppendLine();
output.AppendFormat("The actual list has the following values {0}", string.Join(", ", actualSubscriberServicesModel.MaxBandwidthList.ToList()));
}
foreach (var expectedIndividualString in expectedMaxBandwidthList)
{
if (!actualSubscriberServicesModel.MaxBandwidthList.Contains(expectedIndividualString))
{
output.AppendLine();
output.AppendFormat("The actual results is missing the value {0}", expectedIndividualString);
}
}
if (output.Length != 0)
{
Assert.Fail(output.ToString());
}
}
public void ValidationConstraints_Validate()
{
const string errorMessage = "The object should not have been saved given its constraints";
//var transac = SessionManagement.Db.StartTransaction();
IList<ValidationConstraint> testConstraints = new List<ValidationConstraint>();
try
{
var accor = SessionManagement.Db.GetAllAssets().SingleOrDefault(a => a.Name == "ACCOR");
var total = SessionManagement.Db.GetAllAssets().SingleOrDefault(a => a.Name == "TOTAL");
Assert.IsNotNull(total);
var nameConstraint = new ValidationConstraint
{
ConstraintType = trkValidationConstraintType.Equal,
ObjectType = _typeOfAssetEditable,
Property = "Name",
PropertyType = _typeOfString,
MainArgument = "ACCOR"
};
testConstraints.Add(nameConstraint);
var savedNameConstraint = ValidationConstraintService.Instance.SaveOrUpdateList(testConstraints).SingleOrDefault();
//Should succeed
ValidationConstraintService.Instance.ValidateObject(accor);
//Should fail
try
{
ValidationConstraintService.Instance.ValidateObject(total);
Assert.Fail(errorMessage);
}
catch (Exception e)
{
Console.WriteLine(e);
}
//Second Level
var idConstraint1 = new ValidationConstraint
{
ConstraintType = trkValidationConstraintType.Greater,
ObjectType = _typeOfAssetEditable,
Property = "Id",
PropertyType = _typeOfString,
MainArgument = "0",
ParentConstraint = savedNameConstraint
};
testConstraints.Add(idConstraint1);
ValidationConstraintService.Instance.SaveOrUpdateList(testConstraints);
//Should succeed
ValidationConstraintService.Instance.ValidateObject(accor);
//Should Fail (Id = 122)
var idConstraint2 = new ValidationConstraint
{
ConstraintType = trkValidationConstraintType.Lower,
ObjectType = _typeOfAssetEditable,
Property = "Id",
PropertyType = _typeOfString,
MainArgument = "30",
ParentConstraint = savedNameConstraint
};
testConstraints.Add(idConstraint2);
testConstraints = ValidationConstraintService.Instance.SaveOrUpdateList(testConstraints);
try
{
ValidationConstraintService.Instance.ValidateObject(accor);
}
catch (Exception e)
{
Console.WriteLine(e);
}
//Remove it now that it has been tested
testConstraints.ToList().ForEach(c =>
{
if (c == idConstraint2)
c.RequiresDeletion = true;
});
var handlingQuotesConstraint = new ValidationConstraint
{
ConstraintType = trkValidationConstraintType.True,
ObjectType = _typeOfAssetEditable,
Property = "HandlingQuotes",
PropertyType = _typeOfBool,
ParentConstraint = savedNameConstraint
};
testConstraints.Add(handlingQuotesConstraint);
var thirdLevel = ValidationConstraintService.Instance.SaveOrUpdateList(testConstraints).SingleOrDefault(c => c.ToString() == handlingQuotesConstraint.ToString());
//Should succeed
ValidationConstraintService.Instance.ValidateObject(accor);
var betweenConstraint = new ValidationConstraint
{
ConstraintType = trkValidationConstraintType.Between,
ObjectType = _typeOfAssetEditable,
Property = "Id",
PropertyType = _typeOfInt,
MainArgument = "0",
SecondaryArgument = "100000000",
ParentConstraint = thirdLevel
};
testConstraints.Add(betweenConstraint);
ValidationConstraintService.Instance.SaveOrUpdateList(testConstraints);
//Should succeed
ValidationConstraintService.Instance.ValidateObject(accor);
var notNullConstraint = new ValidationConstraint
{
ConstraintType = trkValidationConstraintType.NotNull,
ObjectType = _typeOfAssetEditable,
Property = "Status",
PropertyType = _typeOfAssetStatus,
ParentConstraint = thirdLevel
};
testConstraints.Add(notNullConstraint);
ValidationConstraintService.Instance.SaveOrUpdateList(testConstraints);
//Should succeed
ValidationConstraintService.Instance.ValidateObject(accor);
var differentConstraint = new ValidationConstraint
{
ConstraintType = trkValidationConstraintType.Different,
ObjectType = _typeOfAssetEditable,
Property = "Id",
PropertyType = _typeOfInt,
MainArgument = "1",
ParentConstraint = thirdLevel
};
testConstraints.Add(differentConstraint);
ValidationConstraintService.Instance.SaveOrUpdateList(testConstraints);
//Should succeed
ValidationConstraintService.Instance.ValidateObject(accor);
var nullConstraint = new ValidationConstraint
{
ConstraintType = trkValidationConstraintType.Null,
ObjectType = _typeOfAssetEditable,
Property = "AssetType",
PropertyType = _typeOfAssetType,
ParentConstraint = thirdLevel
};
testConstraints.Add(nullConstraint);
ValidationConstraintService.Instance.SaveOrUpdateList(testConstraints);
try
{
//Should fail.
ValidationConstraintService.Instance.ValidateObject(accor);
Assert.Fail(errorMessage);
}
catch (Exception e)
{
Console.WriteLine(e);
}
//If you want to add constraint remove the top one from the list.
}
finally
{
//SessionManagement.Db.RollbackTrans(transac);
}
}
public void SortTest()
{
var list = new List<int>();
for (int i = 0; i < 100; i++)
{
list.Add(RandomUtils.GetRandom(0, 1000));
}
var watch = Stopwatch.StartNew();
watch.Restart();
for (int i = 0; i < 100; i++)
{
var copyList = list.ToList();
copyList.QuickSort((a, b) => a.CompareTo(b));
}
Trace.WriteLine("QuickSort:" + watch.ElapsedMilliseconds);
watch.Restart();
for (int i = 0; i < 100; i++)
{
var copyList = list.ToList();
var temp = copyList.OrderBy(t => t);
}
Trace.WriteLine("OrderBy:" + watch.ElapsedMilliseconds);
watch.Restart();
for (int i = 0; i < 100; i++)
{
var copyList = list.ToList();
copyList.Sort((a, b) => a.CompareTo(b));
}
Trace.WriteLine("sort:" + watch.ElapsedMilliseconds);
}
public void TestToGuidList_StringList()
{
var list = new List<string>
{
"83B0233C-A24F-49FD-8083-1337209EBC9A",
"EAB523C6-2FE7-47BE-89D5-C6D440C3033A"
};
Assert.AreEqual(2, list.ToList<Guid>().Count);
Assert.AreEqual(new Guid("83B0233C-A24F-49FD-8083-1337209EBC9A"), list.ToList<Guid>()[0]);
Assert.AreEqual(new Guid("EAB523C6-2FE7-47BE-89D5-C6D440C3033A"), list.ToList<Guid>()[1]);
}
public void WhereIfTest_IQueryable()
{
IQueryable<int> source = new List<int> { 1, 2, 3, 4, 5, 6, 7 }.AsQueryable();
CollectionAssert.AreEqual(source.WhereIf(m => m > 5, false).ToList(), source.ToList());
List<int> actual = new List<int> { 6, 7 };
CollectionAssert.AreEqual(source.WhereIf(m => m > 5, true).ToList(), actual);
}
public void GetExecutionPlan_WhereTaskHasInitializationAndCleanup_ReturnsInitializationFirstAndCleanupLast()
{
// Arrange
var taskblock = typeof(InitializationAndCleanup);
var host = new Host
{
Hostname = SomeHostname
};
var config = new DeploymentConfig
{
Hosts = new[]
{
host
}
};
var expected = new List<ExecutionPlan>
{
new ExecutionPlan(host, taskblock.GetObjMethods("Init", "Task1", "Cleanup"))
};
// Act
var manager = new DeploymentManager<InitializationAndCleanup>(config);
var actual = manager.GetExecutionPlans();
// Assert
CollectionAssert.AreEqual(expected.ToList(), actual.ToList());
}
