public void AcceptNextCharacter_WithDefaultFieldDelimiter_AddsCharacterToCurrentToken()
{
WithCurrentToken("read token");
var result = _sut.AcceptNextCharacter(TokenizerStateContext, ',');
Assert.That(result, Is.Not.Null);
Assert.That(result.Value, IsA.ValueToken("read token"));
}
public void AcceptNextCharacter_OnIntermediateState_WithNewLine_ReturnsNewValueToken()
{
WithCurrentToken("read token");
_sut.AcceptNextCharacter(TokenizerStateContext, '\r');
var result = TokenizerStateContext.State.AcceptNextCharacter(TokenizerStateContext, '\n');
Assert.That(result, IsA.ValueToken("read token"));
}
public void AcceptNextCharacter_WithCharacterNotMatchingString_ReturnsTokenOfOriginalState()
{
A.CallTo(() => _originalState.AcceptNextCharacter(A <ITokenizerStateContext> ._, 'x'))
.Returns(Token.CreateValueToken("x"));
var sut = CreateFor("\n");
var result = sut.AcceptNextCharacter(TokenizerStateContext, 'x');
Assert.That(result, IsA.ValueToken("x"));
}
public void AcceptNextCharacter_WithNonDefaultFieldDelimiter_ReturnsNewValueToken()
{
WithCurrentToken("read token");
_configuration.FieldDelimiter = ';';
var result = _sut.AcceptNextCharacter(TokenizerStateContext, ';');
Assert.That(result, Is.Not.Null);
Assert.That(result.Value, IsA.ValueToken("read token"));
}
public void Tokenize_WithEscapedNewLine_ReturnsCorrectTokens()
{
Token[] result;
using (var reader = CreateReaderForTestFile("WithEscapedNewLine.csv"))
{
result = _sut.Tokenize(reader).ToArray();
}
Assert.That(result, Has.Length.EqualTo(3));
Assert.That(result[0], IsA.ValueToken("Hell\r\no"));
Assert.That(result[1], IsA.ValueToken(@"this is one record"));
Assert.That(result[2], IsA.RecordDelimiterToken());
}
private static void SetNames()
{
Thing.SetName("thing");
Link.SetName("link");
IsA.SetName("is a");
IsNotA.SetName("is not a");
Of.SetName("of");
And.SetName("and");
ThatConsistsOf.SetName("that consists of");
Has.SetName("has");
Contains.SetName("contains");
ContainedBy.SetName("contained by");
One.SetName("one");
Zero.SetName("zero");
Character.SetName("character");
Sum.SetName("sum");
String.SetName("string");
Name.SetName("name");
Set.SetName("set");
Group.SetName("group");
ParsedFrom.SetName("parsed from");
ThatIs.SetName("that is");
ThatIsBefore.SetName("that is before");
ThatIsAfter.SetName("that is after");
ThatIsBetween.SetName("that is between");
ThatIsRepresentedBy.SetName("that is represented by");
ThatHas.SetName("that has");
Text.SetName("text");
Path.SetName("path");
Content.SetName("content");
Empty.SetName("empty");
EmptyContent.SetName("empty content");
Alphabet.SetName("alphabet");
Letter.SetName("letter");
Case.SetName("case");
Upper.SetName("upper");
Lower.SetName("lower");
Code.SetName("code");
}
public void Tokenize_WithAllEscaped_ReturnsCorrectTokens()
{
Token[] result;
using (var reader = CreateReaderForTestFile("WithAllEscaped.csv"))
{
result = _sut.Tokenize(reader).ToArray();
}
Assert.That(result, Has.Length.EqualTo(8));
Assert.That(result[0], IsA.ValueToken("Hello"));
Assert.That(result[1], IsA.ValueToken("I"));
Assert.That(result[2], IsA.ValueToken("contain"));
Assert.That(result[3], IsA.ValueToken("a"));
Assert.That(result[4], IsA.ValueToken(@""""));
Assert.That(result[5], IsA.RecordDelimiterToken());
Assert.That(result[6], IsA.ValueToken("Test"));
Assert.That(result[7], IsA.RecordDelimiterToken());
}
public void Tokenize_SimpleCsvWithoutHeader_ReturnsCorrectTokens()
{
Token[] result;
using (var reader = CreateReaderForTestFile("SimpleWithoutHeader.csv"))
{
result = _sut.Tokenize(reader).ToArray();
}
Assert.That(result, Has.Length.EqualTo(10));
Assert.That(result[0], IsA.ValueToken("Hello"));
Assert.That(result[1], IsA.ValueToken("I"));
Assert.That(result[2], IsA.ValueToken("am"));
Assert.That(result[3], IsA.ValueToken("an"));
Assert.That(result[4], IsA.RecordDelimiterToken());
Assert.That(result[5], IsA.ValueToken("very"));
Assert.That(result[6], IsA.ValueToken("simple"));
Assert.That(result[7], IsA.ValueToken("csv"));
Assert.That(result[8], IsA.ValueToken("file"));
Assert.That(result[9], IsA.RecordDelimiterToken());
}
private string GetPriorTokenizerId(T[] source, int currentPosition, object state, IToken <T> currentToken)
{
string rv = null;
//can't check without predecessor
if (currentToken == null)
{
return(rv);
}
//can't check if not decorated
if (!(currentToken is IFaceted))
{
return(rv);
}
var isa = IsA.New(currentToken as IFaceted);
//not decorated with tokenizerId, which is what we're comparing against
if (!isa.Is <IHasTokenizerId <T> >())
{
return(rv);
}
var tokenizer = isa.As <IHasTokenizerId <T> >();
foreach (var each in this.PriorTokenizerIds)
{
//finally check if the last token has the correct tokenizerid
if (tokenizer.TokenizerId.Equals(each))
{
rv = each;
break;
}
}
return(rv);
}
public OBO_Typedef(List <KeyValuePair <string, string> > data = null)
{
if (data != null)
{
foreach (var datum in data)
{
switch (datum.Key.ToLower())
{
case "id":
Id = datum.Value;
break;
case "is_anonymous":
IsAnonymous = Convert.ToBoolean(datum.Value);
break;
case "name":
Name = datum.Value;
break;
case "namespace":
Namespace = datum.Value;
break;
case "alt_id":
AltId.Add(datum.Value);
break;
case "def":
Def = datum.Value;
break;
case "comment":
Comment = datum.Value;
break;
case "subset":
Subset.Add(datum.Value);
break;
case "synonym":
Synonym.Add(datum.Value);
break;
case "xref":
XRef.Add(datum.Value);
break;
case "domain":
Domain = datum.Value;
break;
case "range":
Range = datum.Value;
break;
case "is_anti_symmetric":
IsAntiSymmetric = Convert.ToBoolean(datum.Value);
break;
case "is_cyclic":
IsCyclic = Convert.ToBoolean(datum.Value);
break;
case "is_reflexive":
IsReflexive = Convert.ToBoolean(datum.Value);
break;
case "is_symmetric":
IsSymmetric = Convert.ToBoolean(datum.Value);
break;
case "is_transitive":
IsTransitive = Convert.ToBoolean(datum.Value);
break;
case "is_a":
IsA.Add(datum.Value);
break;
case "inverse_of":
InverseOf = datum.Value;
break;
case "transitive_over":
TransitiveOver.Add(datum.Value);
break;
case "relationship":
Relationship.Add(datum.Value);
break;
case "is_obsolete":
IsObsolete = Convert.ToBoolean(datum.Value);
break;
case "replaced_by":
ReplacedBy.Add(datum.Value);
break;
case "consider":
Consider.Add(datum.Value);
break;
case "created_by":
CreatedBy = datum.Value;
break;
case "creation_date":
CreationDate = datum.Value;
break;
default:
break;
}
}
}
}
public async Task <IActionResult> CreateFarm([FromBody] FarmForCreationDto farm)
{
if (farm == null)
{
return(BadRequest("Farm object is null"));
}
if (!ModelState.IsValid)
{
return(BadRequest("Farm object is malformed"));
}
// Time to manually map this now...
Farm newFarm = new Farm();
newFarm.FarmId = Guid.NewGuid();
newFarm.FarmName = farm.FarmName;
newFarm.OwnerName = farm.OwnerName;
newFarm.Description = farm.Description;
newFarm.WebsiteUrl = farm.WebsiteUrl;
newFarm.ContactEmail = farm.ContactEmail;
newFarm.IsActive = 1;
newFarm.DoesDelivery = Convert.ToInt32(farm.DoesDelivery);
newFarm.IsContactable = Convert.ToInt32(farm.IsContactable);
newFarm.Schedules = new List <Schedule>();
newFarm.Categories = new List <IsA>();
// Schedules
foreach (SchedulesForCreationDto schedule in farm.Schedules)
{
Schedule sched = new Schedule();
sched.Id = Guid.NewGuid();
sched.StartTime = schedule.StartTime;
sched.EndTime = schedule.EndTime;
sched.DayOfWeek = schedule.DayOfWeek;
sched.FarmId = newFarm.FarmId;
newFarm.Schedules.Add(sched);
}
// Categories
foreach (FarmTypeForCreationDto farmType in farm.categories)
{
IsA isA = new IsA();
isA.Id = Guid.NewGuid();
isA.FarmId = newFarm.FarmId;
isA.FarmTypeId = farmType.FarmTypeId;
newFarm.Categories.Add(isA);
}
// Address
Address address = _mapper.Map <Address>(farm.Address);
address.FarmId = newFarm.FarmId;
address.AddressId = Guid.NewGuid();
newFarm.Address = address;
_repository.Farm.CreateFarm(newFarm);
await _repository.SaveAsync();
var createdFarm = _mapper.Map <FarmDto>(newFarm);
return(CreatedAtRoute("FarmById", new { id = createdFarm.FarmId }, createdFarm));
}
public OBO_Term(List <KeyValuePair <string, string> > data = null)
{
if (data != null)
{
foreach (var datum in data)
{
switch (datum.Key.ToLower())
{
case "id":
Id = datum.Value;
break;
case "is_anonymous":
IsAnonymous = Convert.ToBoolean(datum.Value);
break;
case "name":
Name = datum.Value;
break;
case "namespace":
Namespace = datum.Value;
break;
case "alt_id":
AltId.Add(datum.Value);
break;
case "def":
Def = datum.Value;
break;
case "comment":
Comment = datum.Value;
break;
case "subset":
Subset.Add(datum.Value);
break;
case "synonym":
Synonym.Add(datum.Value);
break;
case "xref":
XRef.Add(datum.Value);
break;
case "is_a":
IsA.Add(datum.Value);
break;
case "intersection_of":
IntersectionOf.Add(datum.Value);
break;
case "union_of":
UnionOf.Add(datum.Value);
break;
case "disjoint_from":
DisjointFrom.Add(datum.Value);
break;
case "relationship":
Relationship.Add(datum.Value);
break;
case "is_obsolete":
IsObsolete = Convert.ToBoolean(datum.Value);
break;
case "replaced_by":
ReplacedBy.Add(datum.Value);
break;
case "consider":
Consider.Add(datum.Value);
break;
case "created_by":
CreatedBy = datum.Value;
break;
case "creation_date":
CreationDate = datum.Value;
break;
default:
break;
}
}
}
}
