public ValuesController()
{
_jwtSecurityTokenHandler = new JwtSecurityTokenHandler();
_tokenCreator = new TokenCreator();
_certificateReader = new CertificateReader();
_tokenValidator = new TokenValidator(_jwtSecurityTokenHandler, _certificateReader);
}
public void NextTokenShouldNotReturnWhiteSpaceToken()
{
TokenBase identifier = TokenCreator.Create <IdentifierToken>("test");
TokenBase space = TokenCreator.Create <SpaceToken>();
StatementBase classStatement = StatementCreator.CreateClassStatement();
StatementBase memberStatement = StatementCreator.CreateMemberStatement("test");
IList <TokenBase> totalList = new List <TokenBase>();
foreach (TokenBase aToken in classStatement.Tokens)
{
totalList.Add(aToken);
}
foreach (TokenBase aToken in memberStatement.Tokens)
{
totalList.Add(aToken);
}
totalList.Add(space);
totalList.Add(identifier);
IList <TokenBase> identifierList = new List <TokenBase>();
identifierList.Add(space);
identifierList.Add(identifier);
_manager.Encountered(new[] { classStatement }, classStatement.Tokens.Count(), totalList);
Assert.AreEqual(identifier, _manager.GetContext(memberStatement.Tokens).NextTokenFromCurrentStatement);
}
public static IToken GenerateToken(IToken consumerToken, RetrieveCaptchaDelegate getCaptchaDelegate)
{
Console.WriteLine("Starting Token Generation...");
ITokenCreator creator = new TokenCreator(consumerToken.ConsumerKey,
consumerToken.ConsumerSecret);
Console.WriteLine("Please enter the verifier key...");
IToken newToken = creator.CreateToken(getCaptchaDelegate);
if (newToken != null)
{
Console.WriteLine("Token generated!");
Console.WriteLine("Token Information : ");
Console.WriteLine("Consumer Key : {0}", newToken.ConsumerKey);
Console.WriteLine("Consumer Secret : {0}", newToken.ConsumerSecret);
Console.WriteLine("Access Token : {0}", newToken.AccessToken);
Console.WriteLine("Access Token Secret : {0}", newToken.AccessTokenSecret);
ITokenUser loggedUser = new TokenUser(newToken);
Console.WriteLine("Your name is {0}!", loggedUser.ScreenName);
return(newToken);
}
Console.WriteLine("Token could not be generated. Please login and specify your verifier key!");
return(null);
}
public static IToken ToToken(this ISecuredToken token)
{
return(new Token()
{
AccessToken = TokenCreator.Create(token.Id, token.Key),
});
}
public void Register(TokenCreator c)
{
if (null != c)
{
_creators.Add(c);
}
}
public Tokenizer AddOperand(string name, string matcherRegex)
{
var tokenCreator = new TokenCreator(new OperandTokenType(name), new Regex(matcherRegex));
_tokenCreators.Add(tokenCreator);
return(this);
}
public void ParseSourceWithGenericsShouldIgnoreCommentsAndTerminateAtLine()
{
IList <TokenBase> input = new List <TokenBase>();
input.Add(TokenCreator.Create <ForwardSlashToken>());
input.Add(TokenCreator.Create <ForwardSlashToken>());
input.Add(TokenCreator.Create <IdentifierToken>("IList"));
input.Add(TokenCreator.Create <SpaceToken>());
input.Add(TokenCreator.Create <OpenAngleBracketToken>());
input.Add(TokenCreator.Create <TabToken>());
input.Add(TokenCreator.Create <IdentifierToken>("String"));
input.Add(TokenCreator.Create <SpaceToken>());
input.Add(TokenCreator.Create <CloseAngleBracketToken>());
input.Add(TokenCreator.Create <NewLineToken>());
IList <TokenBase> expected = new List <TokenBase>(input);
input.Add(TokenCreator.Create <IdentifierToken>("IList"));
input.Add(TokenCreator.Create <OpenAngleBracketToken>());
input.Add(TokenCreator.Create <IdentifierToken>("String"));
input.Add(TokenCreator.Create <CloseAngleBracketToken>());
IdentifierToken expectedToken = new IdentifierToken(2, 1, 19, "IList<String>");
expected.Add(expectedToken);
Assert.AreEqual(expected, _parser.Parse(input));
}
public void ParserShouldCallStatementFactoryAndContextManagerWhenParsingTokens()
{
IList <TokenBase> input = new List <TokenBase>();
input.Add(TokenCreator.Create <GenericToken>("source", null));
input.Add(TokenCreator.Create <GenericToken>("code", null));
IStatementFactory factory = Mocker.StrictMock <IStatementFactory>();
IStatementContext context = Mocker.StrictMock <IStatementContext>();
IStatementContextManager contextManager = Mocker.StrictMock <IStatementContextManager>();
Expect.Call(factory.CanCreateStatementFrom(new List <TokenBase>(), context)).IgnoreArguments().Return(true).Repeat.Once();
Expect.Call(factory.Create(input, context)).Return(new GenericStatement(input, context)).Repeat.Once();
Expect.Call(() => contextManager.Encountered(new[] { new GenericStatement(input, context) }, input.Count, input)).Repeat.Once();
Expect.Call(contextManager.GetContext(input)).Return(context).Repeat.Once();
input.Add(TokenCreator.Create <SemiColonToken>());
StubStatementFactoryProvider provider = new StubStatementFactoryProvider(factory);
CalidusStatementParser parser = new CalidusStatementParser(provider, contextManager);
Mocker.ReplayAll();
parser.Parse(input);
Mocker.VerifyAll();
}
public void CloseBlockStatementShouldSetParentToTopParent()
{
ClassStatement classStatement = StatementCreator.CreateClassStatement();
_manager.Encountered(new[] { classStatement }, TokenCreator.Created().Count(), TokenCreator.Created());
OpenBlockStatement openBlock = StatementCreator.CreateOpenBlockStatement();
_manager.Encountered(new[] { openBlock }, TokenCreator.Created().Count(), TokenCreator.Created());
ClassStatement internalClassStatement = StatementCreator.CreateClassStatement();
_manager.Encountered(new[] { internalClassStatement }, TokenCreator.Created().Count(), TokenCreator.Created());
OpenBlockStatement secondOpenBlock = StatementCreator.CreateOpenBlockStatement();
_manager.Encountered(new[] { secondOpenBlock }, TokenCreator.Created().Count(), TokenCreator.Created());
CloseBlockStatement closeBlock = StatementCreator.CreateCloseBlockStatement();
CollectionAssert.AreEquivalent(new[] { new StatementParent(new[] { classStatement }, openBlock), new StatementParent(new[] { internalClassStatement }, secondOpenBlock) }, _manager.GetContext(closeBlock.Tokens).Parents);
_manager.Encountered(new[] { closeBlock }, TokenCreator.Created().Count(), TokenCreator.Created());
CollectionAssert.AreEquivalent(new[] { new StatementParent(new[] { classStatement }, openBlock) }, _manager.GetContext(openBlock.Tokens).Parents);
_manager.Encountered(new[] { closeBlock }, TokenCreator.Created().Count(), TokenCreator.Created());
}
public async Task <string> GetAccessToken()
{
TokenCreator accessToken = new TokenCreator();
//ReportCreator report = new ReportCreator();
return(await accessToken.GetAccessToken());
}
public static void Main(string[] args)
{
AssemblyMachine am = new AssemblyMachine();
TokenCreator tc = new TokenCreator();
TokenReader tr = new TokenReader();
string path = Path.GetFullPath("Instructions.txt");
var sr = new StreamReader(path);
string line;
while ((line = sr.ReadLine()) != null)
{
//Console.WriteLine(line);
am.addInstruction(line);
}
List <string> instructions = am.instructions;
foreach (var instuction in instructions)
{
String[] tokens = tc.Create(instuction);
tr.Store(tokens);
}
tr.ShowInstructions();
//tr.CreateKernel();
}
public void CreateWithWhiteSpace()
{
var identifier = Guid.NewGuid();
var key = Guid.NewGuid().ToString();
var data = string.Format("{0}{1}", identifier, key).ToBase64();
Assert.AreEqual <string>(data, TokenCreator.Create(identifier, string.Format(" {0} ", key)));
}
public void NextTokenOccurenceTestIsValidShouldBeFalseForWrongToken()
{
Queue <TokenBase> input = new Queue <TokenBase>();
input.Enqueue(TokenCreator.Create <SemiColonToken>());
Assert.IsFalse(_occurence.IsValidFor(input));
}
public void LineCommentTokenShouldBeLineComment()
{
IList <TokenBase> input = new List <TokenBase>();
input.Add(TokenCreator.Create <LineCommentToken>("Test"));
Assert.IsTrue(_factory.CanCreateStatementFrom(input, null));
}
public void RegionEndTokenShouldParseAsRegionEndStatement()
{
IList <TokenBase> input = new List <TokenBase>();
input.Add(TokenCreator.Create <RegionEndToken>("#endregion"));
Assert.IsTrue(_factory.CanCreateStatementFrom(input, null));
}
public void IndentationCharacterValidationShouldValidateLine()
{
IndentationCharacterValidationRule rule = new IndentationCharacterValidationRule(true, true);
Line aLine = new Line(new[] { TokenCreator.Create <IdentifierToken>("test") });
Assert.IsTrue(rule.Validates(aLine));
}
public void ExpiryTest()
{
var tc = new TokenCreator(PASSWORD, SALT, 1);
var enc = tc.Create("1");
Thread.Sleep(2000); // wait for token to expire
Assert.Throws <ArgumentException>(() => { tc.Decode(enc, 1); });
}
public void NextTokenOccurenceTestIsValidShouldBeTrueForMatchingTokenOne()
{
Queue <TokenBase> input = new Queue <TokenBase>();
input.Enqueue(TokenCreator.Create <IdentifierToken>("test"));
Assert.IsTrue(_occurence.IsValidFor(input));
}
public void ContainsNoTokenOccurenceShouldBeValidForListNotContainingToken()
{
IList <TokenBase> input = new List <TokenBase>();
input.Add(TokenCreator.Create <SpaceToken>());
input.Add(TokenCreator.Create <ForwardSlashToken>());
Assert.IsTrue(_occurence.IsValidFor(input));
}
public void RuleShouldNotBeValidForElementsWIthoutAccessModifier()
{
IList <TokenBase> input = new List <TokenBase>();
input.Add(TokenCreator.Create <ClassToken>());
input.Add(TokenCreator.Create <SpaceToken>());
input.Add(TokenCreator.Create <IdentifierToken>("Test"));
Assert.IsFalse(_rule.IsValidFor(new ClassStatement(input, null)));
}
public void ExpressionStartWithShouldMatchAppropriateTokenList()
{
IList <TokenBase> input = new List <TokenBase>();
input.Add(TokenCreator.Create <SemiColonToken>());
IStatementExpression toMatch = _expression.StartsWith <SemiColonToken>();
Assert.IsTrue(toMatch.Matches(input));
}
public void ExpressionContainsNoShouldMatchAppropriateTokenList()
{
IList <TokenBase> input = new List <TokenBase>();
input.Add(TokenCreator.Create <PrivateModifierToken>());
IStatementExpression toMatch = _expression.ContainsNo <SemiColonToken>();
Assert.IsTrue(toMatch.Matches(input));
}
public void SquareBracketDelimitedCodeShouldBeAttribute()
{
IList <TokenBase> input = new List <TokenBase>();
input.Add(TokenCreator.Create <OpenSquareBracketToken>());
input.Add(TokenCreator.Create <IdentifierToken>("Test"));
input.Add(TokenCreator.Create <CloseSquareBracketToken>());
Assert.IsTrue(_factory.CanCreateStatementFrom(input, null));
}
public void NameSpaceStatementTokensShouldParseAsNameSpaceStatement()
{
IList <TokenBase> input = new List <TokenBase>();
input.Add(TokenCreator.Create <NameSpaceToken>());
input.Add(TokenCreator.Create <SpaceToken>());
input.Add(TokenCreator.Create <IdentifierToken>("JDT"));
Assert.IsTrue(_factory.CanCreateStatementFrom(input, null));
}
public void ClassIdentifierFollowedByIdentifierShouldBeClassStatement()
{
IList <TokenBase> input = new List <TokenBase>();
input.Add(TokenCreator.Create <ClassToken>());
input.Add(TokenCreator.Create <SpaceToken>());
input.Add(TokenCreator.Create <IdentifierToken>("Test"));
Assert.IsTrue(_factory.CanCreateStatementFrom(input, null));
}
public void OnlyOpenCurlyBracketTokenShouldBeOpenBlockStatement()
{
IList <TokenBase> input = new List <TokenBase>();
input.Add(TokenCreator.Create <IdentifierToken>("Test"));
input.Add(TokenCreator.Create <OpenCurlyBracketToken>());
input.Add(TokenCreator.Create <TabToken>());
Assert.IsFalse(_factory.CanCreateStatementFrom(input, null));
}
public void OpenCurlyBracketTokenShouldBeOpenBlockStatement()
{
IList <TokenBase> input = new List <TokenBase>();
input.Add(TokenCreator.Create <SpaceToken>());
input.Add(TokenCreator.Create <OpenCurlyBracketToken>());
input.Add(TokenCreator.Create <TabToken>());
Assert.IsTrue(_factory.CanCreateStatementFrom(input, null));
}
public void TokenListWithAssignmentTokenShouldBeAssignmentStatement()
{
IList <TokenBase> input = new List <TokenBase>();
input.Add(TokenCreator.Create <AssignmentToken>());
input.Add(TokenCreator.Create <IdentifierToken>("test"));
input.Add(TokenCreator.Create <SemiColonToken>());
Assert.IsTrue(_factory.CanCreateStatementFrom(input, null));
}
public void StandardNoExpirationTest()
{
var tc = new TokenCreator(PASSWORD, SALT);
var enc = tc.Create("1", "2", "3");
var values = tc.Decode(enc, 3);
Assert.Equal(values[0], "1");
Assert.Equal(values[1], "2");
Assert.Equal(values[2], "3");
}
public void StrictTokenOccurencePopFromShouldNeverPop()
{
Queue <TokenBase> tokens = new Queue <TokenBase>();
tokens.Enqueue(TokenCreator.Create <SpaceToken>());
_occurence.PopFrom(tokens);
Assert.AreEqual(1, tokens.Count);
}
