Show names of parameters

[lobster2012-user]

Hi!
Maybe I don’t know something, but to my surprise, in the test window (VS), I could not display the parameter names, in xunit they are displayed. This is solved simply enough to enable it by default. I would like to have such an opportunity at least optionally.

            public override string GetText(MethodInfo method, object[] arglist)
            {
                var sb = new StringBuilder();

                if (arglist != null)
                {
                    sb.Append('(');
                    var parameters = method.GetParameters();
                    for (int i = 0; i < arglist.Length; i++)
                    {
//sample code, nothing more.
                        if (i > 0) sb.Append(", ");
                        var paramName = parameters.Length > i ? parameters[i].Name : "?";
                        sb.Append(paramName);
                        sb.Append(": ");
                        sb.Append(GetDisplayString(arglist[i], Math.Max(1, _maxStringLength - paramName.Length - 3)));
                    }

                    sb.Append(')');
                }

                return sb.ToString();
            }

The result is pleasing.
What do you think about it?
(Above is a sample code for adding default functionality)

[CharliePoole]

I like it! I think the only reason we don't do it is that nobody has ever thought of doing it. 😄

[lobster2012-user]

@CharliePoole
The main question is to change the old implementation or add an option?

[CharliePoole]

@lobster2012-user That's definitely the main design question. The actual main question is "Does the team want to have / support this feature?" I hope so, but I'm just one guy. Let's see what others say about it.

Regarding that design question, however...

We generate the names of tests from a template, based on our own mini-templating system. So, rather than adding a boolean switch, I'd like to see us add this to the symbols we recognize. We now use {a} to represent the current display of arguments in parentheses. I would lean toward definiing a new symbol, maybe {A}, for the representation with names given. Using that representation, then setting the name of a test to {m}{A} would give the naming you want.

I don't believe we could change the default representation for NUnit 3 because that's a breaking change. But you can use a command-line argument in the console runner to override the default template.

Anyway, we're getting slightly ahead of ourselves, since right now only the two of us like this feature. 😄

[lobster2012-user]

Can I use Runsettings for this?

[CharliePoole]

I believe so, but I don't know for sure. The docs for the adapter are pretty good now, so I'd check there.

[OsirisTerje]

@lobster2012-user Yes, runsettings has a setting for the default name template, see DefaultTestNamePattern (https://github.com/nunit/docs/wiki/Tips-And-Tricks)

[lobster2012-user]

@OsirisTerje Thank you .
template {p}
+
ParamArgListFragment: NameFragment
+
specify the template in the project settings

= expected result ?

[lobster2012-user]

<RunSettings>
   <NUnit>
		<DefaultTestNamePattern>{m}{p}</DefaultTestNamePattern>
   </NUnit>
</RunSettings>

private class ParamArgListFragment : NameFragment
        {
            private readonly int _maxStringLength;

            public ParamArgListFragment(int maxStringLength)
            {
                _maxStringLength = maxStringLength;
            }

            public override string GetText(MethodInfo method, object[] arglist)
            {
                var sb = new StringBuilder();
                arglist = arglist ?? Array.Empty<object>();

                var parameters = method.GetParameters();

                sb.Append('(');
                var count = Math.Max(arglist.Length, parameters.Length);

                for (int i = 0; i < count; i++)
                {
                    if (i > 0) sb.Append(", ");

                    var paramName = GetDisplayString(parameters.Length > i ? parameters[i].Name : "?", _maxStringLength).Trim('\"');
                    sb.Append(paramName);
                    sb.Append(": ");
                    sb.Append(GetDisplayString(arglist.Length > i ? arglist[i] : "?", _maxStringLength));
                }

                sb.Append(')');


                return sb.ToString();
            }
        }

 case "{p}":
                        fragments.Add(new ParamArgListFragment(0));
                        break;

 default:
                        char c = token[1];
                        if (token.Length >= 5 && token[2] == ':' && (c == 'a' || c == 'p' || char.IsDigit(c)))
                        {
                            if (int.TryParse(token.Substring(3, token.Length - 4), out var length) && length > 0)
                            {
                                if (c == 'p')
                                    fragments.Add(new ParamArgListFragment(length));
                                else if (c == 'a')
                                    fragments.Add(new ArgListFragment(length));
                                else // It's a digit
                                    fragments.Add(new ArgumentFragment(c - '0', length));
                                break;
                            }
                        }

                        // Output the erroneous token to aid user in debugging
                        fragments.Add(new FixedTextFragment(token));
                        break;

 public class unit
    {
        [NUnit.Framework.TestCase(1, 2, 3)]
        public void NunitTest_TestCase(Int32 a, Int32 b, Int32 c)
        {
            Console.WriteLine(a);
            Console.WriteLine(b);
        }
        [NUnit.Framework.TestCase(1, 2)]
        public void NunitTest_TestCase2(Int32 a, Int32 b, Int32 c)
        {
            Console.WriteLine(a);
            Console.WriteLine(b);
        }
        [NUnit.Framework.TestCase(1, 2, 3, 4)]
        public void NunitTest_TestCase4(Int32 a, Int32 b, Int32 c)
        {
            Console.WriteLine(a);
            Console.WriteLine(b);
        }
        [NUnit.Framework.Test]
        public void NunitTest_TestCase0(Int32 a, Int32 b, Int32 c)
        {
            Console.WriteLine(a);
            Console.WriteLine(b);
        }
    }

I noticed that there are cases when there are not enough parameters and too many are processed in different ways, therefore it is not possible to display the values ​​of the parameters in the case of testcase2.

[lobster2012-user]

Hi!
What about my changes? Are they happy with everyone, does it make sense for me to do PR?

[CharliePoole]

@nunit/framework-team ? @rprouse ?

[jnm2]

Yes, I've actually wanted this for a long time but it hasn't bubbled to the top for me!

[rprouse]

I think this looks great. I wouldn't worry about your edge cases, they are invalid tests anyway. Interestingly, I think that your changes might even help people notice why the tests are invalid.