public void Setup()
{
_isEmptyCalls = 0;
_tokenParser = Substitute.For <ITokenParser>();
_input = Substitute.For <IStringStream>();
_parserFactory = Substitute.For <IParserFactory>();
}
/// <summary>
/// Converts a group's value into recognizable tokens
/// </summary>
/// <param name="group"></param>
/// <returns></returns>
private IEnumerable <IToken> ParseTokens(IGroup group)
{
ITokenParser tokenParser = null;
if (group is CriterionGroup)
{
var groupIdentifier = new GroupIdentifier(group, _operators);
if (groupIdentifier.IsRangeCondition())
{
tokenParser = new RangeTokenParser(_operators);
}
else if (groupIdentifier.IsSingleCondition())
{
tokenParser = new SingleTokenParser(_operators);
}
}
else
{
tokenParser = new LogicTokenParser(_operators);
}
if (tokenParser != null)
{
return(tokenParser.Parse(group.Value));
}
return(null);
}
public IParserAlphabet Add(string character, ITokenParser tokenParser, bool isValid = true)
{
if (character == null || tokenParser == null)
{
throw new ArgumentNullException();
}
if (character.Length != 1)
{
throw new ArgumentException(RegSeedErrorMessages.AddCharacterTokenParserError);
}
if (_characterTokenParserMapper.ContainsKey(character))
{
throw new ArgumentException(RegSeedErrorMessages.CharacterTokenParserDuplicate);
}
_characterTokenParserMapper.Add(character, tokenParser);
if (!isValid)
{
return(this);
}
_validCharacterHashSet.Add(character);
_validCharacterRangeList.Add(character);
return(this);
}
/// <summary>
/// Create a new instance of this class
/// </summary>
/// <param name="parser">The parser to use</param>
/// <param name="whiteSpaceParser">The whitespace parser to use</param>
/// <param name="genericsParser">The custom generics parser to use</param>
public CalidusTokenParser(ITokenParser parser,
IWhiteSpaceTokenParser whiteSpaceParser,
IGenericsTokenParser genericsParser)
{
_parser = parser;
_whiteSpaceParser = whiteSpaceParser;
_genericsParser = genericsParser;
}
public void ParserShouldUseWhiteSpaceParserWhenPluggedParserDoesNotSupportWhiteSpace()
{
ITokenParser parserImp = Mocker.StrictMock <ITokenParser>();
Expect.Call(parserImp.Parse("")).Return(new List <TokenBase>()).Repeat.Once();
Expect.Call(parserImp.SupportsWhiteSpaceParsing).Return(false).Repeat.Once();
Expect.Call(parserImp.SupportsGenericsParsing).Return(true).Repeat.Once();
Mocker.ReplayAll();
CalidusTokenParser parser = new CalidusTokenParser(parserImp, _otherImpl, _otherImpl);
parser.Parse("");
Mocker.VerifyAll();
Assert.IsTrue(_otherImpl.WhiteSpaceWasCalled);
}
private void RunSimulation()
{
var hitCounterChannel = new Channel <bool>(10000);
ITokenParser parser = CreateTokenParser(hitCounterChannel);
var requestChannel = new Channel <string>(10000);
var statsChannel = new Channel <long>(10000);
var actors =
new IRunnable[] { new RequestSource(requestChannel) }
.Concat(
Enumerable.Range(0, Parameters.NumRequestProcessors)
.Select(n => new RequestProcessor(requestChannel, statsChannel, parser)))
.ToList();
var stats = new StatsProcessor(statsChannel);
var statsTask = stats.RunAsync();
var hitCounter = new HitCounter(hitCounterChannel);
var hitCounterTask = hitCounter.RunAsync();
var actorTasks = actors.Select(a => a.RunAsync()).ToArray();
Console.WriteLine("Waiting for simulation to complete");
Task.WaitAll(actorTasks);
Console.WriteLine("Simulation completed");
statsChannel.Close();
hitCounterChannel.Close();
Task.WaitAll(statsTask, hitCounterTask);
Console.WriteLine("Number of Messages: {0}", stats.Count);
Console.WriteLine("Min Processing Time: {0} ms", stats.Min);
Console.WriteLine("Average processing time: {0}", stats.Mean);
Console.WriteLine("Max Processing Time: {0} ms", stats.Max);
Console.WriteLine("Standard Deviation: {0}", stats.StandardDeviation);
Console.WriteLine("Cache Hit Rate: {0} ({1} of {2} requests)",
hitCounter.HitRate, hitCounter.TotalHits, hitCounter.TotalRequests);
Console.WriteLine();
Console.WriteLine("Min,Mean,Max,Std.Dev,HitRate,TotalHits,TotalRequests");
Console.WriteLine("{0},{1},{2},{3},{4},{5},{6}",
stats.Min, stats.Mean, stats.Max, stats.StandardDeviation,
hitCounter.HitRate, hitCounter.TotalHits, hitCounter.TotalRequests);
}
public void ParserShouldCheckWhiteSpaceBeforeCommentsBeforeGenerics()
{
ITokenParser parserImp = Mocker.StrictMock <ITokenParser>();
using (Mocker.Ordered())
{
Expect.Call(parserImp.Parse("")).Return(new List <TokenBase>()).Repeat.Once();
Expect.Call(parserImp.SupportsWhiteSpaceParsing).Return(true).Repeat.Once();
Expect.Call(parserImp.SupportsGenericsParsing).Return(true).Repeat.Once();
}
Mocker.ReplayAll();
CalidusTokenParser parser = new CalidusTokenParser(parserImp, _otherImpl, _otherImpl);
parser.Parse("");
Mocker.VerifyAll();
}
public StreamerController(
ChunkerConfig chunkerConfig,
StreamerSessionCfg streamerSessionCfg,
IDistributedCache cache,
ITokenBroker tokenBroker,
ISessionBroker sessionBroker,
ITokenParser tokenParser,
IChunkCollector chunkCollector,
IPlaylistAssembler playlistAssembler)
{
_cache = cache;
_tokenBroker = tokenBroker;
_tokenParser = tokenParser;
_sessionBroker = sessionBroker;
_chunkCollector = chunkCollector;
_playlistAssembler = playlistAssembler;
_chunkerConfig = chunkerConfig;
_sessionCfg = streamerSessionCfg;
}
public bool TryGetTokenParser(string character, out ITokenParser tokenParser)
{
tokenParser = null;
if (!_alphabet.IsValid(character))
{
return(false);
}
CheckCharacterClassStateDeactivation(character);
if (IsCharacterClassStateActive)
{
tokenParser = new CharacterClassCharacterParser(new PrimitiveParser(_alphabet));
return(true);
}
CheckCharacterClassStateActivation(character);
return(_alphabet.TryGetTokenParser(character, out tokenParser));
}
public FunctionApiDescriptionGroupCollectionProvider(
IFunctionHttpMethodProvider functionDataProvider,
ITokenParser tokenParser,
IEnumerable <IMapApiResponses> responseMappings,
IEnumerable <IMapApiParameterDescriptions> parameterMappings,
IParameterDescriptionFactory parameterDescriptionFactory,
ILogger <FunctionApiDescriptionGroupCollectionProvider> logger,
IApiRequestFormatMetadataProvider formatMetadataProvider,
IOptions <MvcOptions> mvcOptions,
IEnumerable <IApiDescriptionProvider> apiDescriptionProviders,
IActionDescriptorCollectionProvider actionDescriptorCollectionProvider)
{
_functionDataProvider = functionDataProvider;
_tokenParser = tokenParser;
_responseMappings = responseMappings;
_parameterMappings = parameterMappings;
_parameterDescriptionFactory = parameterDescriptionFactory;
_logger = logger;
_mvcOptions = mvcOptions;
_contentTypes = new MediaTypeCollection();
_contentTypes.Add(MediaTypeHeaderValue.Parse("application/json"));
}
public RequestProcessor(Channel <string> requestChannel, Channel <long> statsChannel, ITokenParser parser)
{
this.requestChannel = requestChannel;
this.statsChannel = statsChannel;
this.parser = parser;
}
public WebWorkContext(IHttpContextAccessor httpContextAccessor, ITokenParser tokenParser, BanobatDbContext dbContext)
{
_httpContextAccessor = httpContextAccessor;
_tokenParser = tokenParser;
_dbContext = dbContext;
}
/// <summary>
/// Construtor padrão.
/// </summary>
/// <param name="tokenParser"></param>
/// <param name="configuration"></param>
public Lexer(ITokenParser tokenParser, ILexerConfiguration configuration)
{
_tokenParser = tokenParser;
_configuration = configuration;
_keywords = configuration.GetKeywords();
}
/// <summary>
/// Registers a parser for a type into the Reader <typeparamref name="T"/>.
/// </summary>
/// <typeparam name="T">The type being parsed.</typeparam>
/// <param name="parser">An instance of ITokenParser wich can parse <typeparamref name="T"/>.</param>
public static void RegisterParser <T>(ITokenParser <T> parser)
{
Parsers[typeof(T)] = parser;
}
public RequestProcessor(Channel<string> requestChannel, Channel<long> statsChannel, ITokenParser parser)
{
this.requestChannel = requestChannel;
this.statsChannel = statsChannel;
this.parser = parser;
}
public bool TryGetTokenParser(string character, out ITokenParser tokenParser) => _characterTokenParserMapper.TryGetValue(character, out tokenParser);
public Markdown(ITokenParser parser, ITokenTreeTranslator translator, ITokenTreeBuilder treeBuilder)
{
this.parser = parser;
this.translator = translator;
this.treeBuilder = treeBuilder;
}
public Interpreter(ITokenizer <T> tokenizer, ITokenParser <T, V> parser)
{
this.tokenizer = tokenizer ?? throw new ArgumentNullException(nameof(tokenizer));
this.parser = parser ?? throw new ArgumentNullException(nameof(parser));
}
/// <summary>
/// Create a new instance of this class
/// </summary>
/// <param name="parser">The parser to use</param>
public CalidusTokenParser(ITokenParser parser)
: this(parser,
ObjectFactory.Get <IWhiteSpaceTokenParser>(),
ObjectFactory.Get <IGenericsTokenParser>())
{
}
public ContentParser(ITokenParser parser)
{
this.parser = parser;
parser.InvalidTokenFound += InvalidTokenFound;
}
public void Setup()
{
_parser = new TokenParser(
new[] { new LinkTokenType() });
_liveParser = new LiveParser(_parser);
}
public LiveParser(ITokenParser parser)
{
_parser = parser;
Tokens = new ReadOnlyCollection <Token>(_tokens);
}
public bool TryGetTokenParser(string character, out ITokenParser tokenParser)
{
tokenParser = null;
return(_alphabet.IsValid(character) && _alphabet.TryGetTokenParser(character, out tokenParser));
}
public Postfixer(ITokenParser tokenParser)
{
_tokenParser = tokenParser;
}
public SoftLinkProvider(ITokenParser tokenParser, ICardLinker cardLinker)
{
_tokenParser = tokenParser;
_cardLinker = cardLinker;
}
public AuthResponseParser(OidcSettings settings, ITokenParser tokenParser, IOidcLogger <AuthResponseParser> logger)
{
Settings = settings;
TokenParser = tokenParser;
Logger = logger;
}
public RegularSocket(Socket inner, ITokenParser parser)
{
_inner = inner;
_parser = parser;
}
