public void FixedStringBuilder_Clear_Resets_Builder()
        {
            FixedStringBuilder target = new FixedStringBuilder(1);

            Assert.IsTrue(target.TryAppend('X', 0));
            Assert.AreEqual("X", target.ToString());
            target.Clear();
            Assert.AreEqual(string.Empty, target.ToString());
        }
        public void FixedStringBuilder_TryAppend_Does_Not_Exceed_Capacity_With_Character()
        {
            FixedStringBuilder target = new FixedStringBuilder(1);

            Assert.IsTrue(target.TryAppend('X', 0));
            Assert.IsFalse(target.TryAppend('X', 0));
            Assert.AreEqual("X", target.ToString());
        }
        public void FixedStringBuilder_TryAppend_Rolls_Back_When_Capacity_Is_Reached_With_String_And_Reserve()
        {
            FixedStringBuilder target = new FixedStringBuilder(4);

            Assert.IsTrue(target.TryAppend("XX", 1, 0));
            Assert.IsFalse(target.TryAppend("XX", 1, 0));
            Assert.AreEqual(string.Empty, target.ToString());
        }
        public void FixedStringBuilder_TryAppend_Does_Not_Exceed_Capacity_With_String_And_Reserve()
        {
            FixedStringBuilder target = new FixedStringBuilder(4);

            Assert.IsTrue(target.TryAppend("XX", 1));
            Assert.IsFalse(target.TryAppend("XX", 1));
            Assert.AreEqual("XX", target.ToString());
        }
    static void Main(string[] args)
    {
        FixedStringBuilder sb         = new FixedStringBuilder(100);
        string             fieldValue = "12345";
        int startPos = 16;

        sb.Replace(startPos, fieldValue);
        string buffer = sb.ToString();
    }
        public void FixedStringBuilder_TryResize_Can_Always_Expand_Capacity()
        {
            FixedStringBuilder target = new FixedStringBuilder(1);

            Assert.IsTrue(target.TryAppend('X', 0));
            Assert.IsTrue(target.TryResize(2, 0));
            Assert.IsTrue(target.TryAppend('X', 0));
            Assert.AreEqual("XX", target.ToString());
        }
        public void FixedStringBuilder_TryResize_Only_Reduces_Capacity_If_There_Is_Room()
        {
            FixedStringBuilder target = new FixedStringBuilder(3);

            Assert.IsTrue(target.TryAppend('X', 0));
            Assert.IsTrue(target.TryAppend('X', 0));
            Assert.IsFalse(target.TryResize(1, 0));
            Assert.IsTrue(target.TryResize(2, 0));
            Assert.AreEqual("XX", target.ToString());
        }
        public void FixedStringBuilder_TryExpand_Does_Nothing_If_Capacity_Is_Already_Larger()
        {
            FixedStringBuilder target = new FixedStringBuilder(3);

            Assert.IsTrue(target.TryAppend('X', 0));
            Assert.IsFalse(target.TryExpand(2));
            Assert.IsTrue(target.TryAppend('X', 0));
            Assert.IsTrue(target.TryAppend('X', 0));
            Assert.AreEqual("XXX", target.ToString());
        }
        public void FixedStringBuilder_TryAppend_Keeps_Rollback_When_Capacity_Is_Reached_With_Character_And_Reserve()
        {
            FixedStringBuilder target = new FixedStringBuilder(2);

            Assert.IsTrue(target.TryAppend('X', 1));
            int actual = 0;

            Assert.IsFalse(target.TryAppend('X', 1, out actual));
            Assert.AreEqual(1, actual);
            Assert.AreEqual("X", target.ToString());
        }
        public void FixedStringBuilder_TryAppend_Sets_Rollback_With_Character_And_Reserve()
        {
            FixedStringBuilder target = new FixedStringBuilder(3);

            Assert.IsTrue(target.TryAppend('X', 0));
            int actual = 0;

            Assert.IsTrue(target.TryAppend('X', 1, out actual));
            Assert.IsFalse(target.TryAppend('X', 1, actual));
            Assert.AreEqual(1, actual);
            Assert.AreEqual("X", target.ToString());
        }
Beispiel #11
0
        public override string ToString()
        {
            // Create a new fixed string builder instance.
            FixedStringBuilder builder = new FixedStringBuilder();

            // Emit the prototype.
            builder.Append(this.Prototype.ToString());

            // Emit and append the body.
            builder.Append(this.Body.ToString());

            // Trim and return the resulting string.
            return(builder.ToString().Trim());
        }
Beispiel #12
0
        public override string ToString()
        {
            // Create a new fixed string builder instance.
            FixedStringBuilder builder = new FixedStringBuilder();

            // Emit the header.
            builder.Append($"{this.Identifier}:");

            // Loop through all instructions.
            foreach (Instruction instruction in this.Instructions)
            {
                // Emit instruction to the builder.
                builder.Append(instruction.ToString());
            }

            // Return the resulting string.
            return(builder.ToString());
        }
        public void TestStringBuilders()
        {
            {
                Span <char> buf = stackalloc char[128];
                var         bdr = new FixedStringBuilder(buf);
                bdr.AppendLine("Hello World");
                bdr.Append("Hello");
                bdr.Append(' ');
                bdr.Append(12);
                bdr.Append(' ');
                bdr.AppendLine("Worlds");
                int numReplaced = bdr.Replace('e', 'u');
                Assert.AreEqual(2, numReplaced);

                var expected = "Hullo World" + Environment.NewLine + "Hullo 12 Worlds" + Environment.NewLine;
                Assert.AreEqual(expected.Length, bdr.Length);
                Assert.IsTrue(bdr.ReadOnlySpan.SequenceEqual(expected));

                numReplaced = bdr.Replace("Hullo", "Hi");
                Assert.AreEqual(2, numReplaced);
                expected = expected.Replace("Hullo", "Hi");
                Assert.IsTrue(bdr.ReadOnlySpan.SequenceEqual(expected));

                numReplaced = bdr.Replace("Hi", "");
                Assert.AreEqual(2, numReplaced);
                expected = expected.Replace("Hi", "");
                Assert.IsTrue(bdr.ReadOnlySpan.SequenceEqual(expected));

                bdr.Replace("World", "World");
                Assert.IsTrue(bdr.ReadOnlySpan.SequenceEqual(expected));
                bdr.Replace("Florka", "--");
                Assert.IsTrue(bdr.ReadOnlySpan.SequenceEqual(expected));
                bdr.Replace("Florka", "Florka");
                Assert.IsTrue(bdr.ReadOnlySpan.SequenceEqual(expected));

                bdr.Clear();
                Assert.AreEqual(0, bdr.Length);
                Assert.AreEqual("", bdr.ToString());
                bdr.Append("Koko");
                bdr.Append('s');
                Assert.AreEqual("Kokos".Length, bdr.Length);
                Assert.IsTrue(bdr.ReadOnlySpan.SequenceEqual("Kokos"));
            }

            {
                var sbdr = new ValueStringBuilder(8);
                sbdr.AppendLine("Hello World");
                sbdr.Append("Hello");
                sbdr.Append(' ');
                sbdr.Append(12u);
                sbdr.Append(' ');
                sbdr.AppendLine("Worlds");
                var numReplaced = sbdr.Replace('e', 'u');
                Assert.AreEqual(2, numReplaced);

                var expected = "Hullo World" + Environment.NewLine + "Hullo 12 Worlds" + Environment.NewLine;
                Assert.AreEqual(expected.Length, sbdr.Length);
                Assert.IsTrue(sbdr.ReadOnlySpan.SequenceEqual(expected));

                numReplaced = sbdr.Replace("Hullo", "Hi");
                Assert.AreEqual(2, numReplaced);
                expected = expected.Replace("Hullo", "Hi");
                Assert.IsTrue(sbdr.ReadOnlySpan.SequenceEqual(expected));

                numReplaced = sbdr.Replace("Hi", "");
                Assert.AreEqual(2, numReplaced);
                expected = expected.Replace("Hi", "");
                Assert.IsTrue(sbdr.ReadOnlySpan.SequenceEqual(expected));

                sbdr.Replace("World", "World");
                Assert.IsTrue(sbdr.ReadOnlySpan.SequenceEqual(expected));
                sbdr.Replace("Florka", "--");
                Assert.IsTrue(sbdr.ReadOnlySpan.SequenceEqual(expected));
                sbdr.Replace("Florka", "Florka");
                Assert.IsTrue(sbdr.ReadOnlySpan.SequenceEqual(expected));

                sbdr.Clear();
                Assert.AreEqual(0, sbdr.Length);
                Assert.AreEqual("", sbdr.ToString());
                sbdr.Append("Koko");
                sbdr.Append('s');
                Assert.AreEqual("Kokos".Length, sbdr.Length);
                Assert.IsTrue(sbdr.ReadOnlySpan.SequenceEqual("Kokos"));
            }
        }