Move Checks with Tests

test/GqlPlus.Verifier.ClassTests/Ast/Schema/AstAliasedTests.cs

@@ -58,3 +58,67 @@ private static string Aliases(params string[] aliases)
 
   internal abstract IAstAliasedChecks<I> AliasedChecks { get; }
 }
+
+internal sealed class AstAliasedChecks<TAliased>
+  : AstAliasedChecks<string, TAliased>, IAstAliasedChecks
+  where TAliased : AstAliased
+{
+  public AstAliasedChecks(CreateBy<string> create)
+    : base(create) { }
+}
+
+internal class AstAliasedChecks<TInput, TAliased>
+  : AstAbbreviatedChecks<TInput, TAliased>, IAstAliasedChecks<TInput>
+  where TAliased : AstAliased
+{
+  public AstAliasedChecks(CreateBy<TInput> create)
+    : base(create) { }
+
+  public void HashCode(TInput input, params string[] aliases)
+    => HashCode(
+      () => CreateAliases(input, aliases),
+      _createExpression);
+
+  public void Equality(TInput input, params string[] aliases)
+    => Equality(
+      () => CreateAliases(input, aliases),
+      _createExpression);
+
+  public void Inequality_WithAliases(TInput input, params string[] aliases)
+    => Inequality(
+      () => CreateAliases(input, aliases),
+      () => CreateInput(input),
+      factoryExpression: _createExpression);
+
+  public void Inequality_ByAliased(TInput input, string aliased1, string aliased2)
+    => InequalityBetween(aliased1, aliased2,
+      aliased => CreateAliases(input, aliased),
+      aliased1 == aliased2, _createExpression);
+
+  public void Inequality_ByInputs(TInput input1, TInput input2, string aliased)
+    => InequalityBetween(input1, input2,
+      input => CreateAliases(input, aliased),
+      input1!.Equals(input2), _createExpression);
+
+  public void String(TInput input, string expected, params string[] aliases)
+    => String(
+      () => CreateAliases(input, aliases), expected,
+      factoryExpression: _createExpression);
+
+  private TAliased CreateAliases(TInput input, params string[] aliases)
+    => CreateInput(input) with { Aliases = aliases };
+}
+
+internal interface IAstAliasedChecks
+  : IAstAliasedChecks<string>, IAstBaseChecks
+{ }
+
+internal interface IAstAliasedChecks<TInput> : IAstAbbreviatedChecks<TInput>
+{
+  void HashCode(TInput input, params string[] aliases);
+  void String(TInput input, string expected, params string[] aliases);
+  void Equality(TInput input, params string[] aliases);
+  void Inequality_WithAliases(TInput input, params string[] aliases);
+  void Inequality_ByInputs(TInput input1, TInput input2, string aliased);
+  void Inequality_ByAliased(TInput input, string aliased1, string aliased2);
+}

test/GqlPlus.Verifier.ClassTests/Ast/Schema/AstFieldTests.cs

@@ -36,3 +36,83 @@ public void ModifiedType_WithModifiersAndArguments(FieldInput input, string argu
 
   internal abstract IAstFieldChecks<TField, TReference> FieldChecks { get; }
 }
+
+internal sealed class AstFieldChecks<TField, TReference>
+  : AstAliasedChecks<FieldInput, TField>, IAstFieldChecks<TField, TReference>
+  where TField : AstField<TReference> where TReference : AstReference<TReference>
+{
+  private readonly FieldBy _createField;
+  private readonly ReferenceBy _createReference;
+  private readonly ArgumentsBy _createArguments;
+
+  internal delegate TReference ReferenceBy(FieldInput input);
+  internal delegate TField FieldBy(FieldInput input, TReference reference);
+  internal delegate TReference[] ArgumentsBy(string argument);
+
+  public AstFieldChecks(FieldBy createField, ReferenceBy createReference, AstFieldChecks<TField, TReference>.ArgumentsBy createArguments)
+    : base(input => createField(input, createReference(input)))
+  {
+    _createField = createField;
+    _createReference = createReference;
+    _createArguments = createArguments;
+  }
+
+  public void HashCode_WithModifiers(FieldInput input)
+      => HashCode(() => CreateModifiers(input));
+
+  public void String_WithModifiers(FieldInput input)
+    => String(
+      () => CreateModifiers(input),
+      $"( !{Abbr} {input.Name} : {input.Type} [] ? )");
+
+  public void Equality_WithModifiers(FieldInput input)
+    => Equality(() => CreateModifiers(input));
+
+  public void Inequality_WithModifiers(FieldInput input)
+    => InequalityWith(input, () => CreateModifiers(input));
+
+  public void ModifiedType_WithArguments(FieldInput input, string argument)
+  {
+    var field = _createField(input, _createReference(input) with { Arguments = _createArguments(argument) });
+    var expected = $"{input.Type} < {argument} >";
+
+    field.ModifiedType.Should().Be(expected);
+  }
+
+  public void ModifiedType_WithModifiers(FieldInput input)
+  {
+    var field = CreateModifiers(input);
+    var expected = $"{input.Type} [] ?";
+
+    field.ModifiedType.Should().Be(expected);
+  }
+
+  public void ModifiedType_WithModifiersAndArguments(FieldInput input, string argument)
+  {
+    var field = _createField(
+        input,
+        _createReference(input) with { Arguments = _createArguments(argument) }
+      ) with { Modifiers = TestMods() };
+    var expected = $"{input.Type} < {argument} > [] ?";
+
+    field.ModifiedType.Should().Be(expected);
+  }
+
+  private TField CreateModifiers(FieldInput input)
+    => CreateInput(input) with { Modifiers = TestMods() };
+}
+
+public record struct FieldInput(string Name, string Type);
+
+internal interface IAstFieldChecks<TField, TReference>
+  : IAstAliasedChecks<FieldInput>
+  where TField : AstField<TReference> where TReference : AstReference<TReference>
+{
+  void HashCode_WithModifiers(FieldInput input);
+  void String_WithModifiers(FieldInput input);
+  void Equality_WithModifiers(FieldInput input);
+  void Inequality_WithModifiers(FieldInput input);
+  void ModifiedType_WithArguments(FieldInput input, string argument);
+  void ModifiedType_WithModifiers(FieldInput input);
+  void ModifiedType_WithModifiersAndArguments(FieldInput input, string argument);
+}