public class Statistics {
    public String do(Stream stream) {
        reader = new StreamReader();
        formatter = new ResultFormatter();

        Data data1 = reader.readData(stream);
        Data data2 = reader.readData(stream);
        Data data3 = reader.readData(stream);
        
        if (data1.valid()) {
            return formatter.format(VALID, data1);
        } else if (data2.valid()) {
            return formatter.format(INVALID, data1) + formatter.format(VALID, data2);
        } else if (data3.valid()) {
            return formatter.format(INVALID, data1) + formatter.format(INVALID, data2) + formatter.format(VALID, data3);
        }
    }
}

public class Statistics {
    public String do(Stream stream) {
        return doInternal(stream, new StreamReader(), new ResultFormatter(), new ResultStringBuilder());
    }

    public String doInternal(Stream stream, StreamReader reader, ResultFormatter formatter, ResultStringBuilder resultBuilder) {
        Data data1 = reader.readData(stream);
        Data data2 = reader.readData(stream);
        Data data3 = reader.readData(stream);
        
        return resultBuilder.getResult(data1, data2, data3);
    }
    
    public static class ResultStringBuilder {
        public String getResult(Data data1, Data data2, Data data3) {
            if (data1.valid()) {
                return formatter.format(VALID, data1);
            } else if (data2.valid()) {
                return formatter.format(INVALID, data1) + formatter.format(VALID, data2);
            } else if (data3.valid()) {
                return formatter.format(INVALID, data1) + formatter.format(INVALID, data2) + formatter.format(VALID, data3);
            }
        }
    }
}

_>public class Statistics {
_>

_>}
_>

// класс для тестирования. Создается или руками или через Moq
public class StatisticsMoq : Statistics {
    public Func<Stream, StreamReader> FuncReaderFrom {get; set;}
    public Func<ResultFormatter> FuncFormatter {get; set;}
    public Func<ResultFormatter, Func<Data,bool, string> > FuncGetFormat {get; set;}

    protected override StreamReader ReaderFrom(Stream stream)
    {
    return FuncReaderFrom();
    }
    
    protected override ResultFormatter Formatter()
    {
    return FuncFormatter();
    }
    
    protected override Func<Data,bool, string> getFormat(ResultFormatter formatter)
    {
         return FuncGetFormat(formatter);
    }
}

public class Statistics {
    public String do(Stream stream) {
        // логика полностью тестируема со всеми потрохами    
         
        reader = ReaderFrom(stream);
        formatter = Formatter();

    var dataSequence = FetchFrom(reader);

        return FormatSequence(dataSequence, getFormat(formatter) );        
    }
    
    protected virtual Func<Data,bool, string> getFormat(ResultFormatter formatter)
    {
         // при тестировании можно(если нужно) что бы распознавать бехевиор FormatSequence 
  
         return (data, valid, stream) => formatter.format(valid.ToValidEnum();
    }

    protected virtual StreamReader ReaderFrom(Stream stream)
    {
        // этот метод можно(если нужно) переопределить для тестирования и там возвращать мок-ридер, что бы изолировать тесты от стрима      
         
    return new StreamReader(stream);
    }
    
    protected virtual ResultFormatter Formatter()
    {
        // этот метод можно(если нужно) переопределить для тестирования и там возвращать мок-форматтер, 
        // например если формат слишком сложный что бы колбасить его в тестах

    return new ResultFormatter();
    }
    
    public static IEnumerable<Data> FetchFrom(StreamReader reader)
    {  // идея в том, что извлечение из стрима отделяется от остальной логики. метод тестируемый - зависимость только от ридера  
        yield return reader.ReadData();
        yield return reader.ReadData();
        yield return reader.ReadData();
    }
    
    public static FormatSequence(IEnumerable<Data> seq, Func<Data,bool,string> format) 
    {
        // основная логика полностью тестируема - депенденсы только от Data
        
    var data1 = seq.ElementAt(1);
    var data2 = seq.ElementAt(2);
    var data3 = seq.ElementAt(3);
        
    if (data1.valid())
            return format(data1, true);
        if (data2.valid()) 
            return format(data1, false) + format(data2,true);
        if (data3.valid())
            return format(data1, false) + format(data2, false) + format(data3,true);
            
        что вернуть если valid ни разу не встретилось ?
    }
}

public enum ValidEnum
{
  VALID,
  INVALID
}

public static Helper
{
   public static ValidEnum ToValidEnum(this bool isValid)
   {
        return isValid ? VALID : INVALID;
   }
}

public interface StreamReader
{
    Data readData(Stream stream);
}

public interface ResultStringBuilder
{
    String getResult(Data data1, Data data2, Data data3);
}

public interface ResultFormatter
{
    public String format(int i, Data data);
}

public class DefaultResultStringBuilder implements ResultStringBuilder
{
    private ResultFormatter _formatter;

    public DefaultResultStringBuilder(ResultFormatter formatter)
    {
        _formatter = formatter;
    }

    public String getResult(Data data1, Data data2, Data data3)
    {
        if (data1.valid())
        {
            return _formatter.format(1, data1);
        }
        else if (data2.valid())
        {
            return _formatter.format(2, data1) + _formatter.format(1, data2);
        }
        else if (data3.valid())
        {
            return _formatter.format(3, data1) + _formatter.format(2, data2) + _formatter.format(2, data3);
        }

        return null;
    }
}

public class Statistics
{
    private StreamReader _reader;
    private ResultStringBuilder _resultStringBuilder;

    public Statistics(StreamReader reader, ResultStringBuilder resultStringBuilder)
    {
        _reader = reader;
        _resultStringBuilder = resultStringBuilder;
    }

    public String doIt(Stream stream)
    {
        Data data1 = _reader.readData(stream);
        Data data2 = _reader.readData(stream);
        Data data3 = _reader.readData(stream);
        return _resultStringBuilder.getResult(data1, data2, data3);
    }
}

// create mocks and setup expectations
Statistics statistics = new Statistics(readerMock, resultBuilderMock);
statistics.doIt(testStream);
// verify here that the mocks have been called with proper parameters

// create mock and setup expectations
DefaultResultStringBuilder builder = new DefaultResultStringBuilder(formatterMock);
String result = builder.getResult(data1, data2, data3);
// test the result value and verify that thу mock has been called properly