public void Expect_that_a_serialized_object_can_be_deserialized_accurately()
        {
            var objIn = new TestState {
                A = decimal.MaxValue,
                B = "Hello World!",
                C = DateTime.MaxValue,
                D = long.MaxValue,
                E = new byte[] { 1, 2, 3 },
                F = true
            };

            var ms = new MemoryStream(128);
            var serializer = new Serializer();

            serializer.Serialize(ms, objIn);
            ms.Position = 0;
            var objOut = serializer.Deserialize<TestState>(ms);

            Assert.That(objOut.A == objIn.A);
            Assert.That(objOut.B == objIn.B);
            Assert.That(objOut.C == objIn.C);
            Assert.That(objOut.D == objIn.D);
            Assert.That(objOut.E.SequenceEqual(objIn.E));
            Assert.That(objOut.F == objIn.F);
        }

		public TestTreeNode(string name, TestNodeType nodeType)
		{
			this.name=name;
			this.nodeType = nodeType;
			this.state = TestState.NotRun;
			this.nodes = new TestTreeNodeCollection(this);
		}

 public void ShouldAddComponentToGameState()
 {
     var state = new TestState();
     Assert.False(state.HasComponent(typeof (FooComponent)));
     var comp = state.AddComponent(new FooComponent());
     Assert.True(state.HasComponent(comp));
 }

        public async Task CookiesOnTheRequestAndInTheContainer()
        {
            // ARRANGE
            var ts = new TestState
            {
                Request =
                {
                    Headers =
                    {
                        {"Cookie", "a=1; b=2"},
                        {"cookie", "c=3; "},
                        {"COOKIE", "d=4;"},
                        {"cOOKIE", "e=5"}
                    }
                }
            };
            ts.CookieContainer.Add(ts.Uri, new Cookie("f", "6"));
            ts.CookieContainer.Add(ts.Uri, new Cookie("g", "7"));

            // ACT
            await ts.HttpClient.SendAsync(ts.Request);

            // ASSERT
            ts.VerifyRequestCookie("a=1; b=2; c=3; d=4; e=5; f=6; g=7");
        }

        public async Task It_Reads_One_Chunk_Asynchronously()
        {
            // ARRANGE
            var ts = new TestState();

            // ACT, ASSERT
            await ts.ReadAndVerifyAsync(ts.MultipleChunks);
        }

        public async Task It_Reads_Multiple_Chunks_With_A_Large_Buffer_Asynchronously()
        {
            // ARRANGE
            var ts = new TestState { BufferSize = 1024 };

            // ACT, ASSERT
            await ts.ReadAndVerifyAsync(ts.MultipleChunks);
        }

        public void It_Reads_One_Chunk_Synchronously()
        {
            // ARRANGE
            var ts = new TestState();

            // ACT, ASSERT
            ts.ReadAndVerify(ts.MultipleChunks);
        }

        public void It_Reads_Multiple_Chunks_With_A_Large_Buffer_Synchronously()
        {
            // ARRANGE
            var ts = new TestState { BufferSize = 1024 };

            // ACT, ASSERT
            ts.ReadAndVerify(ts.MultipleChunks);
        }

        public async Task It_Can_Read_All_Lines_With_Trailing_Line_Endings()
        {
            // ARRANGE
            var ts = new TestState();

            // ACT, ASSERT
            await ts.VerifyAllLinesAsync(ts.TrailingLineEndings);
        }

            private void Process(string displayName, TestState state, string output = "")
            {
                Console.WriteLine($"{state} - {displayName}");
                var result = new TestResultData(displayName, state, output);

                _writer.Write(TestDataKind.Value);
                _writer.Write(result);
            }

 public void Fail(Exception exception)
 {
     if (exception == null)
         throw new ArgumentNullException("exception");
     this.Stop();
     this.state = TestState.Failure;
     this.exception = exception;
 }

 public void ShouldHaveComponentOfType()
 {
     var state = new TestState();
     var fooComp = new FooComponent();
     state.AddComponent(fooComp);
     Assert.True(state.HasComponent(typeof(FooComponent)));
     Assert.False(state.HasComponent(typeof(BarComponent)));
 }

        public async Task It_Returns_All_Contents_With_A_Large_Buffer()
        {
            // ARRANGE
            var ts = new TestState();

            // ACT, ASSERT
            await ts.VerifyReadLineThenReadBytesAsync(ts.TrailingLineEndings, ts.GetLength(ts.TrailingLineEndings) * 2);
        }

 public void ShouldHaveComponentMatchingPredicate()
 {
     var state = new TestState();
     var fooComp = new FooComponent();
     state.AddComponent(fooComp);
     Assert.True(state.HasComponent(c => ((FooComponent)c).Test == "Foo"));
     Assert.False(state.HasComponent(c => ((FooComponent)c).Test == "Bar"));
 }

 public void ShouldOnlyHaveExactReferenceToComponent()
 {
     var state = new TestState();
     var fooComp = new FooComponent();
     var fooComp2 = new FooComponent();
     state.AddComponent(fooComp);
     Assert.True(state.HasComponent(fooComp));
     Assert.False(state.HasComponent(fooComp2));
 }

        public async Task It_Returns_Correct_Line_With_Large_Buffer()
        {
            // ARRANGE
            var ts = new TestState();
            ts.BufferSize = ts.GetLength(ts.TwoLines) * 2;

            // ACT, ASSERT
            await ts.VerifyAllLinesAsync(ts.TwoLines);
        }

        public void Big_long_expressions_work(TestState testState, TestType testType, string expected)
        {

            var actual = _queryStringBuilder
                .QueryStringWith(testState == TestState.All ? "" : "state=" + testState.ToString().EnumNameToTransportCase())
                .AndWith(testType == TestType.All ? "" : "type=" + testType.ToString().EnumNameToTransportCase())
                .Build();
            actual.Should().Be(expected);
        }

 public TestResult(string runner, string assembly, string fixture, double milliseconds, string testName, TestState state, string message)
 {
     Runner = runner;
     Assembly = assembly;
     TestFixture = fixture;
     DurationInMilliseconds = milliseconds;
     TestName = testName;
     State = state;
     Message = message;
 }

 public void ShouldRemoveAllComponentsFromGameState()
 {
     var state = new TestState();
     var fooComp1 = new FooComponent();
     var fooComp2 = new FooComponent();
     state.AddComponent(fooComp1);
     state.AddComponent(fooComp2);
     Assert.AreEqual(state.GetAllComponents().Count(), 2);
     state.RemoveAllComponents();
     Assert.IsEmpty(state.GetAllComponents());
 }

        public static int CompareToForSorting(this TestState a, TestState b)
        {
            if (a == b) {
            return 0;
              }

              int aOrderId = GetOrderId(a);
              int bOrderId = GetOrderId(b);

              return aOrderId - bOrderId;
        }