public void not_equal_version()
        {
            var v1 = new ProjectionVersion(10, 5, 6);
            var v2 = new ProjectionVersion(10, 5, 7);

            Assert.AreNotEqual(v1, v2);
        }

 public ParallelQueryProcessingStrategy(
     string name, ProjectionVersion projectionVersion, IProjectionStateHandler stateHandler,
     Func<IProjectionStateHandler> handlerFactory, ProjectionConfig projectionConfig,
     IQueryDefinition sourceDefinition, ProjectionNamesBuilder namesBuilder, ILogger logger,
     SpooledStreamReadingDispatcher spoolProcessingResponseDispatcher,
     ReaderSubscriptionDispatcher subscriptionDispatcher)
     : base(name, projectionVersion, projectionConfig, sourceDefinition, logger, subscriptionDispatcher)
 {
     _stateHandler = stateHandler;
     _projectionConfig = projectionConfig;
     _sourceDefinition = sourceDefinition;
     _namesBuilder = namesBuilder;
     _spoolProcessingResponseDispatcher = spoolProcessingResponseDispatcher;
     if (_sourceDefinition.CatalogStream == SystemStreams.AllStream)
     {
         _catalogStreamName = SystemStreams.AllStream;
     }
     else if (_sourceDefinition.HasCategories())
     {
         _catalogStreamName = _namesBuilder.GetCategoryCatalogStreamName(_sourceDefinition.Categories[0]);
     }
     else
     {
         _catalogStreamName = _sourceDefinition.CatalogStream;
     }
 }

 public static CheckpointTagVersion ParseCheckpointTagVersionExtraJson(this byte[] source, ProjectionVersion current)
 {
     if (source == null || source.Length == 0)
         return new CheckpointTagVersion { Version = new ProjectionVersion(current.ProjectionId, 0, 0), Tag = null };
     var reader = new JsonTextReader(new StreamReader(new MemoryStream(source)));
     return CheckpointTag.FromJson(reader, current);
 }

        public ProjectionProcessingStrategy CreateProjectionProcessingStrategy(
            string name, ProjectionVersion projectionVersion, ProjectionNamesBuilder namesBuilder,
            IQueryDefinition sourceDefinition, ProjectionConfig projectionConfig,
            Func<IProjectionStateHandler> handlerFactory, IProjectionStateHandler stateHandler)
        {

            if (!sourceDefinition.DisableParallelismOption && projectionConfig.StopOnEof && sourceDefinition.ByStreams
                && sourceDefinition.DefinesFold && !string.IsNullOrEmpty(sourceDefinition.CatalogStream))
            {
                return new ParallelQueryProcessingStrategy(
                    name, projectionVersion, stateHandler, handlerFactory, projectionConfig, sourceDefinition,
                    namesBuilder, _logger, _spoolProcessingResponseDispatcher, _subscriptionDispatcher);
            }

            if (!sourceDefinition.DisableParallelismOption && projectionConfig.StopOnEof && sourceDefinition.ByStreams
                && sourceDefinition.DefinesFold && sourceDefinition.HasCategories())
            {
                return new ParallelQueryProcessingStrategy(
                    name, projectionVersion, stateHandler, handlerFactory, projectionConfig, sourceDefinition,
                    namesBuilder, _logger, _spoolProcessingResponseDispatcher, _subscriptionDispatcher);
            }

            return projectionConfig.StopOnEof
                ? (ProjectionProcessingStrategy)
                    new QueryProcessingStrategy(
                        name, projectionVersion, stateHandler, projectionConfig, sourceDefinition, _logger,
                        _subscriptionDispatcher)
                : new ContinuousProjectionProcessingStrategy(
                    name, projectionVersion, stateHandler, projectionConfig, sourceDefinition, _logger,
                    _subscriptionDispatcher);
        }

 public ProjectionCheckpoint(
     RequestResponseDispatcher
         <ClientMessage.ReadStreamEventsBackward, ClientMessage.ReadStreamEventsBackwardCompleted> readDispatcher,
     RequestResponseDispatcher<ClientMessage.WriteEvents, ClientMessage.WriteEventsCompleted> writeDispatcher,
     ProjectionVersion projectionVersion, IPrincipal runAs, IProjectionCheckpointManager readyHandler,
     CheckpointTag from, PositionTagger positionTagger, CheckpointTag zero, int maxWriteBatchLength,
     ILogger logger = null)
 {
     if (readDispatcher == null) throw new ArgumentNullException("readDispatcher");
     if (writeDispatcher == null) throw new ArgumentNullException("writeDispatcher");
     if (readyHandler == null) throw new ArgumentNullException("readyHandler");
     if (positionTagger == null) throw new ArgumentNullException("positionTagger");
     if (zero == null) throw new ArgumentNullException("zero");
     if (from.CommitPosition <= from.PreparePosition) throw new ArgumentException("from");
     //NOTE: fromCommit can be equal fromPrepare on 0 position.  Is it possible anytime later? Ignoring for now.
     _readDispatcher = readDispatcher;
     _writeDispatcher = writeDispatcher;
     _projectionVersion = projectionVersion;
     _runAs = runAs;
     _readyHandler = readyHandler;
     _positionTagger = positionTagger;
     _zero = zero;
     _from = _last = from;
     _maxWriteBatchLength = maxWriteBatchLength;
     _logger = logger;
 }

        public void equal()
        {
            var v1 = new ProjectionVersion(10, 5, 6);
            var v2 = new ProjectionVersion(10, 5, 6);

            Assert.AreEqual(v1, v2);
        }

        public CheckpointTag AdjustBy(PositionTagger tagger, ProjectionVersion version)
        {
            if (SystemVersion == Projections.VERSION && Version.Version == version.Version
                && Version.ProjectionId == version.ProjectionId)
                return Tag;

            return tagger.AdjustTag(Tag);
        }

 public FakeProjectionProcessingStrategy(
     string name, ProjectionVersion projectionVersion, ILogger logger, FakeProjectionProcessingPhase phase1,
     FakeProjectionProcessingPhase phase2)
     : base(name, projectionVersion, logger)
 {
     _phase1 = phase1;
     _phase2 = phase2;
 }

 protected EventReaderBasedProjectionProcessingStrategy(
     string name, ProjectionVersion projectionVersion, ProjectionConfig projectionConfig,
     IQuerySources sourceDefinition, ILogger logger, ReaderSubscriptionDispatcher subscriptionDispatcher)
     : base(name, projectionVersion, logger)
 {
     _projectionConfig = projectionConfig;
     _sourceDefinition = sourceDefinition;
     _subscriptionDispatcher = subscriptionDispatcher;
 }

 public ProjectionProcessingStrategy CreateSlaveProjectionProcessingStrategy(
     string name, ProjectionVersion projectionVersion, ProjectionSourceDefinition sourceDefinition,
     ProjectionConfig projectionConfig, IProjectionStateHandler stateHandler, IPublisher resultsEnvelope,
     Guid masterCoreProjectionId, ProjectionCoreService projectionCoreService)
 {
     return new SlaveQueryProcessingStrategy(
         name, projectionVersion, stateHandler, projectionConfig, sourceDefinition, projectionCoreService.Logger,
         resultsEnvelope, masterCoreProjectionId, _subscriptionDispatcher);
 }

 public QueryProcessingStrategy(
     string name, ProjectionVersion projectionVersion, IProjectionStateHandler stateHandler,
     ProjectionConfig projectionConfig, IQuerySources sourceDefinition, ILogger logger,
     ReaderSubscriptionDispatcher subscriptionDispatcher)
     : base(
         name, projectionVersion, stateHandler, projectionConfig, sourceDefinition, logger,
         subscriptionDispatcher)
 {
 }

 public CoreProjectionCheckpointWriter(
     string projectionCheckpointStreamId, IODispatcher ioDispatcher, ProjectionVersion projectionVersion,
     string name)
 {
     _projectionCheckpointStreamId = projectionCheckpointStreamId;
     _logger = LogManager.GetLoggerFor<CoreProjectionCheckpointWriter>();
     _ioDispatcher = ioDispatcher;
     _projectionVersion = projectionVersion;
     _name = name;
 }

 public void a_null_name_throws_argument_null_excveption()
 {
     IProjectionStateHandler projectionStateHandler = new FakeProjectionStateHandler();
     var version = new ProjectionVersion(1, 0, 0);
     new ContinuousProjectionProcessingStrategy(
         null, version, projectionStateHandler, _defaultProjectionConfig,
         projectionStateHandler.GetSourceDefinition(), null, _subscriptionDispatcher).Create(
             Guid.NewGuid(), new FakePublisher(), SystemAccount.Principal, new FakePublisher(), _ioDispatcher,
             _subscriptionDispatcher, new RealTimeProvider());
 }

 public CoreProjectionCheckpointReader(
     IPublisher publisher, Guid projectionCorrelationId, IODispatcher ioDispatcher, string projectionCheckpointStreamId, ProjectionVersion projectionVersion, bool useCheckpoints)
 {
     _publisher = publisher;
     _projectionCorrelationId = projectionCorrelationId;
     _ioDispatcher = ioDispatcher;
     _projectionCheckpointStreamId = projectionCheckpointStreamId;
     _projectionVersion = projectionVersion;
     _useCheckpoints = useCheckpoints;
 }

 public void a_negative_checkpoint_handled_interval_throws_argument_out_of_range_exception()
 {
     IProjectionStateHandler projectionStateHandler = new FakeProjectionStateHandler();
     var version = new ProjectionVersion(1, 0, 0);
     var projectionConfig = new ProjectionConfig(null, -1, 10, 1000, 250, true, true, false, false, false);
     new ContinuousProjectionProcessingStrategy(
         "projection", version, projectionStateHandler, projectionConfig,
         projectionStateHandler.GetSourceDefinition(), null, _subscriptionDispatcher).Create(
             Guid.NewGuid(), new FakePublisher(), SystemAccount.Principal, new FakePublisher(), _ioDispatcher,
             _subscriptionDispatcher, new RealTimeProvider());
 }

 protected new virtual void When()
 {
     _projectionVersion = new ProjectionVersion(1, 0, 0);
     _projectionName = "projection";
     _checkpointWriter = new CoreProjectionCheckpointWriter(
         _namingBuilder.MakeCheckpointStreamName(), _ioDispatcher, _projectionVersion, _projectionName);
     _checkpointReader = new CoreProjectionCheckpointReader(
         GetInputQueue(), _projectionCorrelationId, _ioDispatcher, _projectionCheckpointStreamId,
         _projectionVersion, _checkpointsEnabled);
     _manager = GivenCheckpointManager();
 }

 public MultiStreamMultiOutputCheckpointManager(
     IPublisher publisher, Guid projectionCorrelationId, ProjectionVersion projectionVersion, IPrincipal runAs,
     IODispatcher ioDispatcher, ProjectionConfig projectionConfig, string name, PositionTagger positionTagger,
     ProjectionNamesBuilder namingBuilder, bool useCheckpoints, bool producesRunningResults, bool definesFold,
     CoreProjectionCheckpointWriter coreProjectionCheckpointWriter)
     : base(
         publisher, projectionCorrelationId, projectionVersion, runAs, ioDispatcher, projectionConfig, name,
         positionTagger, namingBuilder, useCheckpoints, producesRunningResults, definesFold,
         coreProjectionCheckpointWriter)
 {
     _positionTagger = positionTagger;
 }

 public ParallelQueryProcessingStrategy(
     string name, ProjectionVersion projectionVersion, Func<IProjectionStateHandler> handlerFactory,
     ProjectionConfig projectionConfig, IQueryDefinition sourceDefinition, ProjectionNamesBuilder namesBuilder,
     ILogger logger, SpooledStreamReadingDispatcher spoolProcessingResponseDispatcher,
     ReaderSubscriptionDispatcher subscriptionDispatcher)
     : base(name, projectionVersion, projectionConfig, sourceDefinition, logger, subscriptionDispatcher)
 {
     _projectionConfig = projectionConfig;
     _sourceDefinition = sourceDefinition;
     _namesBuilder = namesBuilder;
     _spoolProcessingResponseDispatcher = spoolProcessingResponseDispatcher;
 }

 public SlaveQueryProcessingStrategy(
     string name, ProjectionVersion projectionVersion, IProjectionStateHandler stateHandler,
     ProjectionConfig projectionConfig, IQuerySources sourceDefinition, ILogger logger,
     IPublisher resultsPublisher, Guid masterCoreProjectionId,
     ReaderSubscriptionDispatcher subscriptionDispatcher)
     : base(
         name, projectionVersion, stateHandler, projectionConfig, sourceDefinition, logger,
         subscriptionDispatcher)
 {
     _resultsPublisher = resultsPublisher;
     _masterCoreProjectionId = masterCoreProjectionId;
 }

 protected override void When()
 {
     _projectionVersion = new ProjectionVersion(1, 2, 3);
     _sut.Handle(
         new CoreProjectionManagementMessage.CreateAndPrepare(
             _projectionId,
             _workerId,
             _projectionName,
             _projectionVersion,
             _config,
             _handlerType,
             _query));
 }