protected static void Compare(HumanDna dna,
ref int patternOccurrences,
ref int equalElementsCount,
ref int row,
ref int col,
int rowStep,
int colStep,
bool doStep = false)
{
equalElementsCount =
dna.Element(row, col) == dna.Element(row + 1 * rowStep, col + 1 * colStep)
? ++equalElementsCount
: 0;
if (equalElementsCount == 3)
{
equalElementsCount = 0;
patternOccurrences++;
row = row + 1 * rowStep;
col = col + 1 * colStep;
}
if (doStep)
{
row = row + 1 * rowStep;
col = col + 1 * colStep;
}
}
public void EvaluateMustReturnIsMutant()
{
//ARRANGE
var dna = new string[]
{
"ATGCGA", "CAGTGC", "TTATGT", "AGAAGG", "CCCCTA", "TCACTG"
};
var humanDna = new HumanDna(dna);
var mockDnaBuilder = _autoMoqer.GetMock <IDnaBuilder>();
mockDnaBuilder.Setup(x => x.AddDna(dna, DnaType.Human))
.Returns(mockDnaBuilder.Object);
mockDnaBuilder.Setup(x => x.Build())
.Returns(humanDna);
var mockDnaEvaluator = _autoMoqer.GetMock <IDnaEvaluator>();
mockDnaEvaluator.Setup(x => x.IsMutant(humanDna))
.Returns(true);
var mockDnaRepository = _autoMoqer.GetMock <IDnaRepository>();
mockDnaRepository.Setup(x => x.Insert(humanDna))
.Returns(Task.CompletedTask);
//ACT
var result = _dnaEvaluatorService.Evaluate(dna).Result;
//ASSERT
Assert.True(result);
Assert.Equal(humanDna.IsMutant, result);
}
public void InsertHumanDna()
{
//ARRANGE
var dna = new string[]
{
"ATGCGA", "CAGTGC", "TTATGT", "AGAAGG", "CCCCTA", "TCACTG"
};
var humanDna = new HumanDna(dna)
{
IsMutant = true
};
var mockDnaData = _autoMoqer.GetMock <IMongoCollection <DnaData> >();
mockDnaData.Setup(x => x.InsertOneAsync(It.IsAny <DnaData>(), It.IsAny <InsertOneOptions>(), It.IsAny <CancellationToken>()))
.Returns(Task.FromResult <object>(null));
var mockDbContext = _autoMoqer.GetMock <IDbContext>();
mockDbContext.Setup(x => x.Dna)
.Returns(mockDnaData.Object);
//ACT
_dnaRepository.Insert(humanDna);
//ASSERT
mockDnaData.Verify(x => x.InsertOneAsync(It.IsAny <DnaData>(), It.IsAny <InsertOneOptions>(), It.IsAny <CancellationToken>()), Times.Once);
}
public DnaEvaluatorTests()
{
_secuenciaNecesaria = 5;
_humanDna = HumanDna.Dummy(_secuenciaNecesaria * 2);
_mutantConfigurationMock = new Mock <IMutantConfiguration>();
_mutantConfigurationMock.Setup(mc => mc.SequencesNeeded).Returns(_secuenciaNecesaria);
}
public async Task Insert(HumanDna dna)
{
await _dbContext.Dna.InsertOneAsync(new DnaData
{
Dna = dna.Description,
IsMutant = dna.IsMutant
});
}
public void DnaConLongitudMenorQueLaSecuenciaNecesariaNoPuedeSerMutante()
{
var sut = new DnaEvaluator(new List <IRangeEvaluator>
{
new Mock <IRangeEvaluator>().Object
}, _mutantConfigurationMock.Object);
for (var dnaLength = 1; dnaLength < _secuenciaNecesaria; dnaLength++)
{
Assert.False(sut.IsMutant(HumanDna.Dummy(dnaLength)));
}
}
public async Task Save(HumanDna humanDna, bool isMutant)
{
var dna = humanDna.ToString();
var newId = GetHash(dna);
var humanDnaData = new HumanDnaData(newId, dna, isMutant);
await _dbContext.HumansDna.ReplaceOneAsync(
filter : i => i.Id == newId,
options : new UpdateOptions {
IsUpsert = true
},
replacement : humanDnaData);
}
public bool IsMutant(HumanDna dna)
{
if (dna.Length < 4)
{
return(false);
}
int patternCountAggregator(int patternCount, IRangeEvaluator evaluator)
=> patternCount + evaluator.GetPatternOccurrences(dna, _mutantConfiguration.SequencesNeeded - patternCount);
var dnaPatternCount = _evaluators.ToList().Aggregate(0, patternCountAggregator);
return(dnaPatternCount >= _mutantConfiguration.SequencesNeeded);
}
public void IsMutantMustReturnFalse()
{
//ARRANGE
var dna = new string[]
{
"ATGCGA", "CAGTGC", "TTATTT", "AGACGG", "GCGTCA", "TCACTG"
};
var humanDna = new HumanDna(dna);
//ACT
var result = _dnaEvaluator.IsMutant(humanDna);
//ASSERT
Assert.False(result);
}
public bool IsMutant(HumanDna humanDna)
{
var amountMatches = 0;
foreach (var conditions in _serviceProvider.GetServices <IDnaCondition>())
{
amountMatches += conditions.GetCoincidences(humanDna.Description);
if (amountMatches >= _matchesNeededToBeMutant)
{
return(true);
}
}
return(false);
}
public int GetPatternOccurrences(HumanDna dna, int atMost)
{
var patternOccurrences = 0;
var equalElementsCount = 0;
for (int col = 0; col < dna.Length && patternOccurrences < atMost; col++, equalElementsCount = 0)
{
for (int row = 0;
row < dna.Length - 1 && patternOccurrences < atMost;
row++)
{
Compare(dna, ref patternOccurrences, ref equalElementsCount, ref row, ref col, 1, 0);
}
}
return(patternOccurrences);
}
public int GetPatternOccurrences(HumanDna dna, int atMost)
{
var patternOccurrences = 0;
var equalElementsCount = 0;
// recorro diagonales de la parte superior superior de la matriz y la diagonal secundaria
for (var fixRow = 3;
fixRow <= dna.Length - 1 && patternOccurrences < atMost;
fixRow++)
{
var row = fixRow;
var col = 0;
equalElementsCount = 0;
while (row >= 1 && patternOccurrences < atMost)
{
Compare(dna, ref patternOccurrences, ref equalElementsCount, ref row, ref col, -1, 1, true);
}
}
// recorro diagonales de la parte inferior de la matriz
for (var fixCol = 1;
fixCol <= dna.Length - 3 && patternOccurrences < atMost;
fixCol++)
{
var row = dna.Length - 1;
var col = fixCol;
equalElementsCount = 0;
while (col < dna.Length - 1 && patternOccurrences < atMost)
{
Compare(dna, ref patternOccurrences, ref equalElementsCount, ref row, ref col, -1, 1, true);
}
}
return(patternOccurrences);
}
