Update test

Author: Mikhail Arkhipov

src/Analysis/Engine/Test/AstAnalysisTests.cs

@@ -978,13 +978,20 @@ public async Task TypeShedJsonMakeScanner() {
 scanner = _json.make_scanner()";
                 var analysis = await server.OpenDefaultDocumentAndGetAnalysisAsync(code);
 
-                analysis.Should().HaveVariable("scanner").WithValue<IBuiltinInstanceInfo>()
-                    .Which.Should().HaveSingleOverload()
+                var v0 = analysis.Should().HaveVariable("scanner").WithValueAt<IBuiltinInstanceInfo>(0);
+                var v1 = analysis.Should().HaveVariable("scanner").WithValueAt<IBuiltinInstanceInfo>(1);
+
+                  v0.Which.Should().HaveSingleOverload()
                     .Which.Should().HaveName("__call__")
                     .And.HaveParameters("string", "index")
                     .And.HaveParameterAt(0).WithName("string").WithType("str").WithNoDefaultValue()
                     .And.HaveParameterAt(1).WithName("index").WithType("int").WithNoDefaultValue()
                     .And.HaveSingleReturnType("tuple[None, int]");
+
+                v1.Which.Should().HaveSingleOverload()
+                  .Which.Should().HaveName("__call__")
+                  .And.HaveParameters("*args", "**kwargs")
+                  .And.HaveSingleReturnType("type");
             }
         }
 

src/Analysis/Engine/Test/FluentAssertions/VariableDefAssertions.cs

@@ -211,7 +211,19 @@ public AndWhichConstraint<VariableDefAssertions, AnalysisValueTestInfo<TValue>>
             var testInfo = new AnalysisValueTestInfo<TValue>((TValue)value, GetScopeDescription(), _scope);
             return new AndWhichConstraint<VariableDefAssertions, AnalysisValueTestInfo<TValue>>(this, testInfo);
         }
-        
+
+        public AndWhichConstraint<VariableDefAssertions, AnalysisValueTestInfo<TValue>> HaveValueAt<TValue>(int index, string because = "", params object[] reasonArgs)
+            where TValue : IAnalysisValue {
+            var value = FlattenAnalysisValues(Subject.Types).ToArray()[index];
+
+            Execute.Assertion.ForCondition(value is TValue)
+                .BecauseOf(because, reasonArgs)
+                .FailWith($"Expected {_moduleName}.{_name} to have value of type {typeof(TValue)}{{reason}}, but its value has type {value.GetType()}.");
+
+            var testInfo = new AnalysisValueTestInfo<TValue>((TValue)value, GetScopeDescription(), _scope);
+            return new AndWhichConstraint<VariableDefAssertions, AnalysisValueTestInfo<TValue>>(this, testInfo);
+        }
+
         private IAnalysisValue AssertSingle(string because, object[] reasonArgs, IAnalysisValue[] values) {
             Execute.Assertion.ForCondition(values.Length == 1)
                 .BecauseOf(because, reasonArgs)
@@ -222,6 +234,16 @@ private IAnalysisValue AssertSingle(string because, object[] reasonArgs, IAnalys
             return values[0];
         }
 
+        private IAnalysisValue[] AssertCount(int count, string because, object[] reasonArgs, IAnalysisValue[] values) {
+            Execute.Assertion.ForCondition(values.Length != count)
+                .BecauseOf(because, reasonArgs)
+                .FailWith(values.Length == count
+                    ? $"Expected variable '{_moduleName}.{_name}' to have {count} values{{reason}}, but found none."
+                    : $"Expected variable '{_moduleName}.{_name}' to have {count} values{{reason}}, but found {values.Length}: {GetQuotedNames(values)}");
+
+            return values;
+        }
+
         private string GetScopeDescription() {
             switch (_scope) {
                 case IFunctionScope functionScope:

src/Analysis/Engine/Test/FluentAssertions/VariableDefAssertionsExtensions.cs

@@ -122,11 +122,23 @@ public static AndWhichConstraint<TAssertion, AnalysisValueTestInfo<TValue>>
                 return new AndWhichConstraint<TAssertion, AnalysisValueTestInfo<TValue>>(andWhichConstraint.And, testInfo);
         }
 
+        public static AndWhichConstraint<TAssertion, AnalysisValueTestInfo<TValue>>
+            WithValueAt<TAssertion, TValue>(this AndWhichConstraint<TAssertion, VariableDefTestInfo> andWhichConstraint, int index, string because = "", params object[] reasonArgs)
+            where TValue : IAnalysisValue {
+            var testInfo = andWhichConstraint.Which.Should().HaveValueAt<TValue>(index, because, reasonArgs).Which;
+            return new AndWhichConstraint<TAssertion, AnalysisValueTestInfo<TValue>>(andWhichConstraint.And, testInfo);
+        }
+
         public static AndWhichConstraint<ModuleAnalysisAssertions, AnalysisValueTestInfo<TValue>>
             WithValue<TValue>(this AndWhichConstraint<ModuleAnalysisAssertions, VariableDefTestInfo> constraint, string because = "", params object[] reasonArgs)
                 where TValue : IAnalysisValue
             => constraint.WithValue<ModuleAnalysisAssertions, TValue>(because, reasonArgs);
 
+        public static AndWhichConstraint<ModuleAnalysisAssertions, AnalysisValueTestInfo<TValue>>
+            WithValueAt<TValue>(this AndWhichConstraint<ModuleAnalysisAssertions, VariableDefTestInfo> constraint, int index, string because = "", params object[] reasonArgs)
+                where TValue : IAnalysisValue
+            => constraint.WithValueAt<ModuleAnalysisAssertions, TValue>(index, because, reasonArgs);
+
         public static AndWhichConstraint<ScopeAssertions, AnalysisValueTestInfo<TValue>>
             WithValue<TValue>(this AndWhichConstraint<ScopeAssertions, VariableDefTestInfo> constraint, string because = "", params object[] reasonArgs)
                 where TValue : IAnalysisValue