コード例 #1
0
        public IGen <Test> ItWillProducesShrinksThatCanRecreateTheOriginalList() =>
        from minLength in TestGen.MinLength()
        from list in DomainGen.AnyList().WithCountGreaterThanEqual((minLength + 1) * 2)
        select Property.ForThese(() =>
        {
            var func = ShrinkFunc.Bisect <object>(minLength);

            var shrinks = func(list.ToList());

            shrinks.SelectMany(x => x).Should().BeEquivalentTo(list.ToList());
        });
コード例 #2
0
        public IGen <Test> IfListLengthIsLessThanDoubleMinLength_ItWillNotShrink() =>
        from minLength in TestGen.MinLength(minMinLength: 1)
        from list in DomainGen.AnyList().WithCountLessThan(minLength * 2)
        select Property.ForThese(() =>
        {
            var func = ShrinkFunc.Bisect <object>(minLength);

            var shrinks = func(list.ToList());

            shrinks.Should().BeEmpty();
        });
コード例 #3
0
        public IGen <Test> IfListHasOneElement_ItWillNotShrink() =>
        from minLength in TestGen.MinLength()
        from list in DomainGen.AnyList().WithCount(1)
        select Property.ForThese(() =>
        {
            var func = ShrinkFunc.Bisect <object>(minLength);

            var shrinks = func(list.ToList());

            shrinks.Should().BeEmpty();
        });
コード例 #4
0
        public IGen <Test> ItWillProduceDistinctShrinks() =>
        from minLength in TestGen.MinLength()
        from list in DomainGen.AnyList().WithCountGreaterThan(minLength)
        select Property.ForThese(() =>
        {
            var func = ShrinkFunc.DropOne <object>(minLength);

            var shrinks = func(list.ToList());

            shrinks.Should().OnlyHaveUniqueItems();
        });
コード例 #5
0
        public NebulaCheck.IGen <Test> OtherwiseIfCharTypeHasWhitespace_ItShrinksToSpace() =>
        from charType in TestGen.CharType(GalaxyCheck.Gen.CharType.Alphabetical)
        from seed in DomainGen.Seed()
        from size in DomainGen.Size()
        select Property.ForThese(() =>
        {
            var gen = GalaxyCheck.Gen.Char(GalaxyCheck.Gen.CharType.Whitespace | charType);

            var minimum = gen.Minimum(seed: seed, size: size);

            minimum.Should().Be(' ');
        });
コード例 #6
0
        public NebulaCheck.IGen <Test> IfCharTypeHasAlphabetical_ItShrinksToLowercaseA() =>
        from charType in TestGen.CharType()
        from seed in DomainGen.Seed()
        from size in DomainGen.Size()
        select Property.ForThese(() =>
        {
            var gen = GalaxyCheck.Gen.Char(GalaxyCheck.Gen.CharType.Alphabetical | charType);

            var minimum = gen.Minimum(seed: seed, size: size);

            minimum.Should().Be('a');
        });
コード例 #7
0
        public IGen <Test> ItWillProduceTwoShrinksOfSimilarLengths() =>
        from minLength in TestGen.MinLength()
        from list in DomainGen.AnyList().WithCountGreaterThanEqual((minLength + 1) * 2)
        select Property.ForThese(() =>
        {
            var func = ShrinkFunc.Bisect <object>(minLength);

            var shrinks = func(list.ToList());

            shrinks.Should().HaveCount(2);
            shrinks.First().Count.Should().BeCloseTo(shrinks.Skip(1).Single().Count, 1);
        });
コード例 #8
0
        public IGen <Test> ItWillNotProduceShrinksLessThanMinimumLength() =>
        from minLength in TestGen.MinLength()
        from list in DomainGen.AnyList().WithCountGreaterThanEqual((minLength + 1) * 2)
        select Property.ForThese(() =>
        {
            var func = ShrinkFunc.Bisect <object>(minLength);

            var shrinks = func(list.ToList());

            shrinks.Should()
            .NotBeEmpty().And
            .OnlyContain(shrink => shrink.Count >= minLength);
        });
コード例 #9
0
        public IGen <Test> ItWillProduceAShrinkForEachElementInTheList() =>
        from minLength in TestGen.MinLength()
        from list in DomainGen.AnyList().WithCountGreaterThan(minLength)
        select Property.ForThese(() =>
        {
            var func = ShrinkFunc.DropOne <object>(minLength);

            var shrinks = func(list.ToList());

            shrinks.Should()
            .NotBeEmpty().And
            .OnlyContain(shrink => shrink.Count == list.Count - 1);
        });
コード例 #10
0
        public NebulaCheck.IGen <Test> OtherwiseIfCharTypeHasSymbol_ItShrinksToExclamationMark() =>
        from charType in TestGen.CharType(
            GalaxyCheck.Gen.CharType.Whitespace,
            GalaxyCheck.Gen.CharType.Alphabetical,
            GalaxyCheck.Gen.CharType.Numeric)
        from seed in DomainGen.Seed()
        from size in DomainGen.Size()
        select Property.ForThese(() =>
        {
            var gen = GalaxyCheck.Gen.Char(GalaxyCheck.Gen.CharType.Symbol | charType);

            var minimum = gen.Minimum(seed: seed, size: size);

            minimum.Should().Be('!');
        });
コード例 #11
0
        public NebulaCheck.IGen <Test> OtherwiseIfCharTypeHasExtended_ItShrinksToMajusculeCCedilla() =>
        from charType in TestGen.CharType(
            GalaxyCheck.Gen.CharType.Whitespace,
            GalaxyCheck.Gen.CharType.Alphabetical,
            GalaxyCheck.Gen.CharType.Numeric,
            GalaxyCheck.Gen.CharType.Symbol)
        from seed in DomainGen.Seed()
        from size in DomainGen.Size()
        select Property.ForThese(() =>
        {
            var gen = GalaxyCheck.Gen.Char(GalaxyCheck.Gen.CharType.Extended | charType);

            var minimum = gen.Minimum(seed: seed, size: size);

            minimum.Should().Be('\u0080');
        });
コード例 #12
0
        public void TestDef(string name)
        {
            var client = new TcpClient("10.0.0.39", 12347);
            var socket = client.Client;

            void WriteAll(byte[] data)
            {
                var len = data.Length;
                var i   = 0;

                while (i < len)
                {
                    var s = socket.Send(data, i, len - i, SocketFlags.None);
                    if (s <= 0)
                    {
                        throw new Exception();
                    }
                    i += s;
                }
            }

            void Write(ulong v) => WriteAll(BitConverter.GetBytes(v));

            var cmdBuf = new byte[8];

            void ReadAll(byte[] data)
            {
                var len = data.Length;
                var i   = 0;

                while (i < len)
                {
                    var s = socket.Receive(data, i, len - i, SocketFlags.None);
                    if (s <= 0)
                    {
                        throw new Exception();
                    }
                    i += s;
                }
            }

            ulong Read()
            {
                ReadAll(cmdBuf);
                return(BitConverter.ToUInt64(cmdBuf));
            }

            var def = Core.Defs.First(x => x.Name == name);
            var tg  = new TestGen(def);
            var ran = false;

            foreach (var(insn, disasm, conds) in tg.InstructionsWithConditions)
            {
                ran = true;
                Console.WriteLine(disasm);
                var idata = BitConverter.GetBytes(insn);
                foreach (var(pre, post) in conds)
                {
                    var ms    = new HashSet <ulong>();
                    var nnzcv = false;
                    var nzcv  = 0UL;
                    foreach (var(k, v) in pre)
                    {
                        if (k is ulong addr)
                        {
                            ms.Add(addr << 12);
                            Write(2);
                            Write(addr << 12);
                            if (!(v is byte[] data))
                            {
                                throw new Exception();
                            }
                            if (data.Length == 8192)
                            {
                                Console.WriteLine($"Foo? {insn:X} {BitConverter.ToUInt32(data, 4):X} {BitConverter.ToUInt64(data, 4):X}");
                            }
                            Write((ulong)data.Length);
                            WriteAll(data);
                        }
                        else if (k is string reg)
                        {
                            if (reg[0] == 'X')
                            {
                                Write(1);
                                Write(ulong.Parse(reg.Substring(1)));
                                Write((ulong)v);
                            }
                            else if (reg == "SP")
                            {
                                Write(1);
                                Write(34);
                                Write((ulong)v);
                            }
                            else if (reg == "PC")
                            {
                                Write(1);
                                Write(32);
                                Write((ulong)v);
                            }
                            else if (reg[0] == 'V')
                            {
                                var ri  = ulong.Parse(reg.Substring(1));
                                var vec = (Vector128 <ulong>)v.As <ulong>();
                                Write(5);
                                Write(ri);
                                Write(vec[0]);
                                Write(vec[1]);
                            }
                            else if (reg[0] == 'N')
                            {
                                nnzcv = true;
                                var bit = ((ulong)v) & 1;
                                switch (reg[5])
                                {
                                case 'N':
                                    nzcv |= bit << 31;
                                    break;

                                case 'Z':
                                    nzcv |= bit << 30;
                                    break;

                                case 'C':
                                    nzcv |= bit << 29;
                                    break;

                                case 'V':
                                    nzcv |= bit << 28;
                                    break;
                                }
                            }
                            else
                            {
                                throw new NotImplementedException(reg);
                            }
                        }
                        else
                        {
                            throw new NotImplementedException(k.ToPrettyString());
                        }
                    }
                    var er     = new Dictionary <ulong, ulong>();
                    var ev     = new Dictionary <ulong, (ulong, ulong)>();
                    var em     = new Dictionary <ulong, byte[]>();
                    var nenzcv = false;
                    var enzcv  = nzcv;
                    pre.PrettyPrint();
                    post.PrettyPrint();
                    foreach (var(k, v) in post)
                    {
                        if (k is ulong addr)
                        {
                            addr <<= 12;
                            Write(4);
                            Write(addr);
                            em[addr] = (byte[])v;
                            if (!ms.Contains(addr))
                            {
                                ms.Add(addr);
                                Write(2);
                                Write(addr);
                                Write(0);
                            }
                        }
                        else if (k is string reg)
                        {
                            if (reg[0] == 'X')
                            {
                                Write(3);
                                var rn = ulong.Parse(reg.Substring(1));
                                Write(rn);
                                er[rn] = (ulong)v;
                            }
                            else if (reg == "SP")
                            {
                                Write(3);
                                Write(34);
                                er[34] = (ulong)v;
                            }
                            else if (reg == "PC")
                            {
                                Write(3);
                                Write(32);
                                er[32] = (ulong)v;
                            }
                            else if (reg[0] == 'V')
                            {
                                var rn = ulong.Parse(reg.Substring(1));
                                Write(6);
                                Write(rn);
                                var vec = (Vector128 <ulong>)v.As <ulong>();
                                ev[rn] = (vec[0], vec[1]);
                            }
                            else if (reg[0] == 'N')
                            {
                                var bit = ((ulong)v) & 1;
                                nenzcv = true;
                                switch (reg[5])
                                {
                                case 'N':
                                    enzcv = (enzcv & ~(1UL << 31)) | (bit << 31);
                                    break;

                                case 'Z':
                                    enzcv = (enzcv & ~(1UL << 30)) | (bit << 30);
                                    break;

                                case 'C':
                                    enzcv = (enzcv & ~(1UL << 29)) | (bit << 29);
                                    break;

                                case 'V':
                                    enzcv = (enzcv & ~(1UL << 28)) | (bit << 28);
                                    break;
                                }
                            }
                            else
                            {
                                throw new NotImplementedException(reg);
                            }
                        }
                        else
                        {
                            throw new NotImplementedException(k.ToPrettyString());
                        }
                    }
                    Write(1);
                    Write(32);
                    Write(TestGen.PC);
                    if (nenzcv)
                    {
                        Write(1);
                        Write(0x1000);
                        Write(nzcv);
                        Write(3);
                        Write(0x1000);
                        er[0x1000] = enzcv;
                    }
                    else if (nnzcv)
                    {
                        Write(1);
                        Write(0x1000);
                        Write(nzcv);
                    }

                    if (!ms.Contains(TestGen.PC) && !ms.Contains(TestGen.PC - 0x1000))
                    {
                        Write(2);
                        Write(TestGen.PC);
                        Write(4);
                        WriteAll(idata);
                    }

                    Write(0);

                    Assert.IsTrue(Read() == 1, "Execution");

                    var rc = Read();
                    Assert.AreEqual(er.Count, (int)rc);
                    for (var i = 0; i < (int)rc; ++i)
                    {
                        var rn = Read();
                        var v  = Read();
                        Assert.AreEqual(er[rn], v, rn switch { 34 => "SP", 32 => "PC", 0x1000 => "NZCV", _ => $"X{rn}" });