Exemple #1
0
        public void If()
        {
            var airplane = new Airplane {
                Engine = new Engine()
            };

            Assert.Equal("crashing", airplane.With(x => airplane)
                         .With(x => x.Engine)
                         .If(x => x.HasFuel)
                         .Return(x => "flying", "crashing"));
            var engine = airplane.With(x => airplane)
                         .With(x => x.Engine)
                         .If(x => x.HasFuel);

            Assert.Null(engine);

            airplane.Engine.HasFuel = true;
            Assert.Equal("flying", airplane.With(x => airplane)
                         .With(x => x.Engine)
                         .If(x => x.HasFuel)
                         .Return(x => "flying", "crashing"));
            engine = airplane.With(x => airplane)
                     .With(x => x.Engine)
                     .If(x => x.HasFuel);
            Assert.NotNull(engine);

            Assert.True(true);
        }
Exemple #2
0
        public void Branch1()
        {
            var airplane = new Airplane {
                Engine = new Engine()
            };
            var hasEngine = string.Empty;

            airplane.With(a => a.Engine).Branch(_ => hasEngine = "yes", () => hasEngine = "no");
            Assert.Equal("yes", hasEngine);

            airplane.Engine = null;
            airplane.With(a => a.Engine).Branch(_ => hasEngine = "yes", () => hasEngine = "no");
            Assert.Equal("no", hasEngine);

            Assert.True(true);
        }
Exemple #3
0
        public void Guard()
        {
            // cast guard
            var jet = new Jet();

            Assert.Null(jet.CastSafe <Airplane>());

            // null guard
            var airplane = new Airplane();

            Assert.Null(airplane.With(a => a.Engine));

            // condition guard
            airplane.Engine = new Engine();
            Assert.Null(airplane.If(a => a.Engine.HasFuel));

            // all guards pass
            airplane.Engine.HasFuel = true;
            var result = string.Empty;

            airplane.CastSafe <Airplane>().With(a => a.Engine).If(e => e.HasFuel).Do(e => result = "success");
            Assert.Equal("success", result);

            Assert.True(true);
        }
Exemple #4
0
        public void Branch2()
        {
            var airplane = new Airplane {
                Engine = new Engine {
                    HasFuel = true
                }
            };
            var hasFuel = string.Empty;

            airplane.With(a => a.Engine).HasFuel.Branch(() => hasFuel = "yes", () => hasFuel = "no");
            Assert.Equal("yes", hasFuel);

            airplane.Engine.HasFuel = false;
            airplane.With(a => a.Engine).HasFuel.Branch(() => hasFuel = "yes", () => hasFuel = "no");
            Assert.Equal("no", hasFuel);

            Assert.True(true);
        }
Exemple #5
0
        public void IfReturn2()
        {
            var airplane = new Airplane {
                Engine = new Engine {
                    HasFuel = true, FuelType = "123"
                }
            };
            Func <string, string> func123     = s => s.Equals("123") ? "123 matches" : "123 does not match";
            Func <string, string> funcMissing = _ => "missing";

            Assert.Equal("123 matches", airplane.With(a => a.Engine).IfReturn(e => e.HasFuel, e => func123, funcMissing)("123"));
            Assert.Equal("123 does not match", airplane.With(a => a.Engine).IfReturn(e => e.HasFuel, e => func123, funcMissing)("456"));

            airplane.Engine = null;
            Assert.Equal("missing", airplane.With(a => a.Engine).IfReturn(e => e.HasFuel, e => func123, funcMissing)("123"));

            Assert.True(true);
        }
Exemple #6
0
        public void Return1()
        {
            var airplane = new Airplane();

            // if no fuelType, then return empty string
            Assert.Equal(string.Empty, airplane.With(x => airplane)
                         .With(x => x.Engine)
                         .Return(x => x.FuelType, string.Empty));

            airplane.Engine = new Engine {
                FuelType = "123"
            };
            Assert.Equal("123", airplane.With(x => airplane)
                         .With(x => x.Engine)
                         .Return(x => x.FuelType, string.Empty));

            Assert.True(true);
        }
Exemple #7
0
        public void Unless()
        {
            var airplane = new Airplane {
                Engine = new Engine()
            };

            Assert.Equal("crashing", airplane.With(x => airplane)
                         .With(x => x.Engine)
                         .Unless(x => x.HasFuel)
                         .Return(x => "crashing", "flying"));

            airplane.Engine.HasFuel = true;
            Assert.Equal("flying", airplane.With(x => airplane)
                         .With(x => x.Engine)
                         .Unless(x => x.HasFuel)
                         .Return(x => "crashing", "flying"));

            Assert.True(true);
        }
Exemple #8
0
        public void With()
        {
            var airplane = new Airplane();

            Assert.Null(airplane.With(x => airplane)
                        .With(x => x.Engine)
                        .With(x => x.FuelType));

            airplane.Engine = new Engine();
            Assert.Null(airplane.With(x => airplane)
                        .With(x => x.Engine)
                        .With(x => x.FuelType));

            airplane.Engine.FuelType = "123";
            Assert.NotNull(airplane.With(x => airplane)
                           .With(x => x.Engine)
                           .With(x => x.FuelType));

            Assert.True(true);
        }
Exemple #9
0
        public void Do()
        {
            var airplane = new Airplane {
                Engine = new Engine {
                    FuelType = "123", HasFuel = true
                }
            };

            Assert.Equal("correct fuel", airplane.With(x => airplane)
                         .With(x => x.Engine)
                         .Do(FillupAndTestFuelGrade())
                         .If(x => x.FuelTypeTest)
                         .Return(x => "correct fuel", "bad fuel"));

            airplane.Engine.FuelType = "999";
            Assert.Equal("bad fuel", airplane.With(x => airplane)
                         .With(x => x.Engine)
                         .Do(FillupAndTestFuelGrade())
                         .If(x => x.FuelTypeTest)
                         .Return(x => "correct fuel", "bad fuel"));

            Assert.True(true);
        }
Exemple #10
0
        public void Return3()
        {
            var airplane = new Airplane {
                Engine = new Engine {
                    FuelType = "123"
                }
            };

            Assert.Equal("123", airplane.With(x => airplane)
                         .With(x => x.Engine)
                         .Return(x => x.FuelType, () => string.Empty));

            Assert.True(true);
        }
Exemple #11
0
        public void Return5()
        {
            var airplane = new Airplane {
                Engine = new Engine {
                    FuelType = "123", HasFuel = true
                }
            };

            Assert.Equal("123", airplane.With(x => airplane)
                         .With(x => x.Engine)
                         .HasFuel
                         .Return(() => "123", () => string.Empty));

            Assert.True(true);
        }