private int IncrementAndAppendChars(
IWriter output,
char b1,
char b2,
char b3) {
      var count = 0;
      if (!this.unlimitedLineLength) {
        if (this.lineCount + 3 > 75) {
          // 76 including the final '='
          output.WriteByte(0x3d);
          output.WriteByte(0x0d);
          output.WriteByte(0x0a);
          this.lineCount = 0;
          count += 3;
        }
      }
      if (this.lineCount==0 && b1=='.') {
        output.WriteByte((byte)'=');
        output.WriteByte((byte)'2');
        output.WriteByte((byte)'E');
        this.lineCount += 2;
        count += 2;
      } else {
        output.WriteByte((byte)b1);
      }
      output.WriteByte((byte)b2);
      output.WriteByte((byte)b3);
      this.lineCount += 3;
      count += 3;
      return count;
    }

        public void SetUp()
        {
            _reader = MockRepository.GenerateStub<IReader<Artist>>();
            _writer = MockRepository.GenerateStub<IWriter<Artist>>();

            _operationOutput = new ExceptionOperationOutput();
        }

 private int IncrementAndAppend(IWriter output, string appendStr) {
   var count = 0;
   if (!this.unlimitedLineLength) {
     if (this.lineCount + appendStr.Length > 75) {
       // 76 including the final '='
       output.WriteByte(0x3d);
       output.WriteByte(0x0d);
       output.WriteByte(0x0a);
       this.lineCount = 0;
       count += 3;
     }
   }
   for (int i = 0; i < appendStr.Length; ++i) {
     if (i==0 && this.lineCount == 0 && appendStr[i] == '.') {
       output.WriteByte((byte)'=');
       output.WriteByte((byte)'2');
       output.WriteByte((byte)'E');
       this.lineCount += 2;
       count += 2;
     } else {
       output.WriteByte((byte)appendStr[i]);
     }
     ++count;
   }
   this.lineCount += appendStr.Length;
   return count;
 }

        public static void WriteElement(IScope scope, IWriter writer, object obj)
        {
            var type = obj.GetType();

            var xmlWriter = writer as XmlWriterImpl;
            if (xmlWriter != null)
            {
                var surrogate = scope.GetSurrogate(type);
                if (surrogate != null)
                {
                    surrogate.Write(xmlWriter.XmlWriter, obj);
                    return;
                }
            }

            var def = scope.GetElementDef(type);
            if (def != null)
            {
                var subScope = def as IScope ?? scope;
                WriteElement(subScope, writer, obj, def, def.Name);
                return;
            }

            throw new NotSupportedException();
        }

 public EventEngine(IReader reader, IWriter writer, IEventHolder eventHolder, IEventLogger eventLogger)
 {
     this.reader = reader;
     this.writer = writer;
     this.eventHolder = eventHolder;
     this.eventLogger = eventLogger;
 }

 protected AzureService(string subscriptionId, X509Certificate certificate, IWriter writer)
 {
     this.subscriptionId = subscriptionId;
     this.certificate = certificate;
     Writer = writer;
     ServiceUri = new ServiceUri(subscriptionId);
 }

        public static void ParseCommand(string input, IWriter output, BlobDatabase database)
        {
            var tokens = input.Split(' ').ToArray();
            var commandType = tokens[0];
            switch (commandType)
            {
                case "create":
                    CreateCommand(database, tokens);
                    break;
                case "attack":
                    AttackCommand(database, tokens);
                    break;
                case "pass":

                    break;
                case "status":
                    StatusCommand(output, database);
                    break;
                case "report-events":
                    //todo: report events
                    break;
                default:
                    throw new InvalidOperationException("Invalid Command.");
            }

            foreach (var blob in database)
            {
                if (blob.BlobBehavior.HasBeenTriggered)
                {
                    blob.BlobBehavior.EndTurnAction(blob);
                }
            }
        }

 protected override void RenderChildren(IWriter writer)
 {
     foreach(Section section in this.Sections)
     {
         section.Render(writer);
     }
 }

        public CSVReaderWriter(IWriter writerStream)
        {
            ReaderStream = null;
            writerStream.ThrowIfNull("writerStream");

            WriterStream = writerStream;
        }

 public int Encode(int b, IWriter output) {
   if (b < 0) {
     return this.finalized ? (-1) : this.FinalizeEncoding(output);
   }
   b &= 0xff;
   var count = 0;
   if (this.lenientLineBreaks) {
     if (b == 0x0d) {
       // CR
       this.haveCR = true;
       count += this.AddByteInternal(output, (byte)0x0d);
       count += this.AddByteInternal(output, (byte)0x0a);
       return count;
     }
     if (b == 0x0a && !this.haveCR) {
       // bare LF
       if (this.haveCR) {
         // Do nothing, this is an LF that follows CR
         this.haveCR = false;
       } else {
         count += this.AddByteInternal(output, (byte)0x0d);
         count += this.AddByteInternal(output, (byte)0x0a);
         this.haveCR = false;
       }
       return count;
     }
   }
   count += this.AddByteInternal(output, (byte)b);
   this.haveCR = false;
   return count;
 }

        private static void WriteLocaleChanges(Patch patch, IWriter writer)
        {
            if (patch.LanguageChanges.Count == 0)
                return;

            long startPos = writer.Position;
            writer.WriteInt32(AssemblyPatchBlockID.Locl);
            writer.WriteUInt32(0); // Size filled in later
            writer.WriteByte(0); // Version 0

            // Write change data for each language
            writer.WriteByte((byte)patch.LanguageChanges.Count);
            foreach (LanguageChange language in patch.LanguageChanges)
            {
                writer.WriteByte(language.LanguageIndex);

                // Write the change data for each string in the language
                writer.WriteInt32(language.LocaleChanges.Count);
                foreach (LocaleChange change in language.LocaleChanges)
                {
                    writer.WriteUInt16((ushort)change.Index);
                    writer.WriteUTF8(change.NewValue);
                }
            }

            // Fill in the block size
            long endPos = writer.Position;
            writer.SeekTo(startPos + 4);
            writer.WriteUInt32((uint)(endPos - startPos));
            writer.SeekTo(endPos);
        }

 public Core(ILogicController controller, IReader reader, IWriter writer, IGameInstance game)
 {
     this.controller = controller;
     this.reader = reader;
     this.writer = writer;
     this.game = game;
 }

 public Nav(IWriter writer, string activeIdentifier, NavSettings settings = null)
     : base(writer)
 {
     _activeIdentifier = activeIdentifier;
     _settings = settings ?? new NavSettings();
     WriteOpening();
 }

 public AddChips(IWriter writer)
 {
     this.InitializeComponent();
     this.ControlBox = false;
     this.outOfChipsLabel.BorderStyle = BorderStyle.FixedSingle;
     this.writer = writer;
 }

		public static void WritePatch(Patch patch, IWriter writer)
		{
			var container = new ContainerWriter(writer);
			container.StartBlock("asmp", 0);
			WriteBlocks(patch, container, writer);
			container.EndBlock();
		}

        /// <summary>
        /// Fills a section of a stream with a repeating byte.
        /// </summary>
        /// <param name="writer">The IWriter to fill a section of.</param>
        /// <param name="b">The byte to fill the section with.</param>
        /// <param name="size">The size of the section to fill.</param>
        public static void Fill(IWriter writer, byte b, int size)
        {
            if (size == 0)
                return;
            if (size < 0)
                throw new ArgumentException("The size of the data to insert must be >= 0");
            if (writer.Position == writer.Length)
                return;

            const int BufferSize = 0x1000;
            byte[] buffer = new byte[BufferSize];
            long length = writer.Length;
            long pos = writer.Position;
            int filled = 0;

            // Fill the buffer
            for (int i = 0; i < buffer.Length; i++)
                buffer[i] = b;

            // Write it
            while (filled < size)
            {
                writer.WriteBlock(buffer, 0, (int)Math.Min(length - pos, BufferSize));
                filled += BufferSize;
                pos += BufferSize;
            }
        }

 private static long WriteBlockHeader(IWriter writer, int magic)
 {
     var startPos = writer.Position;
     writer.WriteInt32(magic);
     writer.WriteUInt32(0); // Size filled in later
     return startPos;
 }

        private static void WriteResourcePages(TagContainer tags, ContainerWriter container, IWriter writer)
        {
            foreach (ResourcePage page in tags.ResourcePages)
            {
                container.StartBlock("rspg", 1);

                writer.WriteInt32(page.Index);
                writer.WriteUInt16(page.Salt);
                writer.WriteByte(page.Flags);
                writer.WriteAscii(page.FilePath ?? "");
                writer.WriteInt32(page.Offset);
                writer.WriteInt32(page.UncompressedSize);
                writer.WriteByte((byte) page.CompressionMethod);
                writer.WriteInt32(page.CompressedSize);
                writer.WriteUInt32(page.Checksum);
                WriteByteArray(page.Hash1, writer);
                WriteByteArray(page.Hash2, writer);
                WriteByteArray(page.Hash3, writer);
                writer.WriteInt32(page.Unknown1);
                writer.WriteInt32(page.Unknown2);
                writer.WriteInt32(page.Unknown3);

                container.EndBlock();
            }
        }

 private static void EndBlock(IWriter writer, long headerPos)
 {
     var endPos = writer.Position;
     writer.SeekTo(headerPos + 4);
     writer.WriteUInt32((uint)(endPos - headerPos));
     writer.SeekTo(endPos);
 }

        private long _offset; // The offset that the writer is currently at

        #endregion Fields

        #region Constructors

        private StructureWriter(StructureValueCollection values, IWriter writer)
        {
            _writer = writer;
            _baseOffset = writer.Position;
            _offset = _baseOffset;
            _collection = values;
        }