@@ -224,6 +224,31 @@ public class Shapes {
         Assert.Contains("static Shapes()", parsed);
     }
 
+    /// <summary>
+    /// Asserts on the converted form of every method reference kind in the integration resource.
+    /// That resource is conversion-only, since java.util.function has no BCL delegate mapping and
+    /// so its output cannot be compiled and run by the integration harness.
+    /// </summary>
+    [Fact]
+    public void Method_Reference_Resource_Converts_Every_Reference_Kind()
+    {
+        var parsed = Convert(File.ReadAllText("Resources/Java8MethodReferences.java"));
+
+        // Instance method of a type, and of a particular object.
+        Assert.Contains("return string.Length;", parsed);
+        Assert.Contains("return this.Upper;", parsed);
+
+        // Static method.
+        Assert.Contains("return Java8MethodReferences.Add;", parsed);
+
+        // Constructor reference, keeping the generic argument.
+        Assert.Contains("() => new List<string>()", parsed);
+
+        // No method reference may become an invocation.
+        Assert.DoesNotContain("string.Length()", parsed);
+        Assert.DoesNotContain("Java8MethodReferences.Add()", parsed);
+    }
+
     private static string Convert(string javaCode, bool allowWarnings = false)
     {
         var options = new JavaConversionOptions { IncludeComments = false };
 
@@ -22,10 +22,8 @@ public class IntegrationTests(ITestOutputHelper testOutputHelper)
     [InlineData("Resources/Java11LambdaInference.java")]
     [InlineData("Resources/MultidimensionalArrays.java", true)]
     [InlineData("Resources/Java17SealedClasses.java", true)]
-    [InlineData("Resources/Java16LocalRecords.java")]
+    // Conversion-only: java.util.function has no BCL delegate mapping, so the output cannot be run.
     [InlineData("Resources/Java8MethodReferences.java")]
-    [InlineData("Resources/InstanceInitializers.java")]
-    [InlineData("Resources/StaticImports.java")]
     public void GeneralSuccessfulConversionTest(string filePath, bool allowWarnings = false)
     {
         var options = new JavaConversionOptions
@@ -86,6 +84,9 @@ public void GeneralUnsuccessfulConversionTest(string filePath)
     [InlineData("Resources/BooleanArrays.java")]
     [InlineData("Resources/BinaryLiterals.java")]
     [InlineData("Resources/NestedEnumStaticUsing.java")]
+    [InlineData("Resources/Java16LocalRecords.java")]
+    [InlineData("Resources/InstanceInitializers.java")]
+    [InlineData("Resources/StaticImports.java")]
     public void FullIntegrationTests(string filePath, bool allowWarnings = false)
     {
         var options = new JavaConversionOptions
 
@@ -1,35 +1,75 @@
-package com.example;
-
-import java.util.ArrayList;
-import java.util.List;
-
-/**
- * Instance initializer blocks, which Java runs at the start of every constructor that does not
- * chain to another constructor of the same class.
- */
-public class InstanceInitializers {
-    private final List<String> names;
-    private int count;
-
-    {
-        names = new ArrayList<String>();
-        count = 1;
+/// Expect:
+/// - output: "a: count=1 tag=init\nb: count=2 tag=x\nc: count=2 tag=x-y\nd: count=1 tag=init\nstatic=7\n"
+package example;
+
+// Instance initializer blocks run at the start of every constructor that does not chain to another
+// constructor of the same class. A constructor that chains via this(...) must not re-run them.
+public class Program {
+    static int staticValue;
+
+    static {
+        staticValue = 7;
     }
 
-    public InstanceInitializers() {
+    public static class Counter {
+        public String tag;
+        public int count;
+
+        // Two separate initializer blocks, to verify both run and in declaration order.
+        {
+            tag = "init";
+        }
+
+        {
+            count = 1;
+        }
+
+        public Counter() {
+        }
+
+        public Counter(String first) {
+            tag = first;
+            count = 2;
+        }
+
+        // Chains to Counter(String), so the initializers already ran there and must not run again.
+        public Counter(String first, String second) {
+            this(first);
+            tag = tag + "-" + second;
+        }
     }
 
-    public InstanceInitializers(String first) {
-        names.add(first);
-        count = 2;
+    // A class with an initializer but no declared constructor needs one synthesized, or the
+    // initializer would be dropped entirely.
+    public static class Implicit {
+        public String tag;
+        public int count;
+
+        {
+            tag = "init";
+            count = 1;
+        }
     }
 
-    public InstanceInitializers(String first, String second) {
-        this(first);
-        names.add(second);
+    public static void describe(String label, int count, String tag) {
+        System.out.println(label + ": count=" + count + " tag=" + tag);
     }
 
-    public int getCount() {
-        return count;
+    public static void main(String[] args) {
+        Counter a = new Counter();
+        describe("a", a.count, a.tag);
+
+        Counter b = new Counter("x");
+        describe("b", b.count, b.tag);
+
+        // count stays 2 rather than resetting to 1, because the chained constructor did not re-run
+        // the initializer.
+        Counter c = new Counter("x", "y");
+        describe("c", c.count, c.tag);
+
+        Implicit d = new Implicit();
+        describe("d", d.count, d.tag);
+
+        System.out.println("static=" + staticValue);
     }
 }
@@ -1,37 +1,36 @@
-package com.example;
-
-import java.util.ArrayList;
-import java.util.List;
-
-/**
- * Java 16 local record declarations (JEP 395), which may be declared in a method body.
- */
-public class Java16LocalRecords {
-    public int sumAreas(List<int[]> pairs) {
-        record Rect(int width, int height) {
-        }
-
-        List<Rect> rects = new ArrayList<Rect>();
-
-        for (int[] pair : pairs) {
-            rects.add(new Rect(pair[0], pair[1]));
+/// Expect:
+/// - output: "area=6\npair=1,2\nsame=True\nnested=9\n"
+package example;
+
+// Java 16 local records (JEP 395) may be declared in a method body. C# has no local record
+// declaration, so they are hoisted to the enclosing type.
+public class Program {
+    public static int scale(int value) {
+        // A local record in a second method, to verify each is hoisted independently.
+        record Factor(int amount) {
         }
 
-        int total = 0;
+        Factor f = new Factor(3);
+        return value * f.amount;
+    }
 
-        for (Rect rect : rects) {
-            total += rect.width * rect.height;
+    public static void main(String[] args) {
+        record Rect(int width, int height) {
         }
 
-        return total;
-    }
+        Rect r = new Rect(2, 3);
+        System.out.println("area=" + (r.width * r.height));
 
-    public String describe(int a, int b) {
+        // A second local record in the same method, to verify both are hoisted.
         record Pair(int left, int right) {
         }
 
-        Pair pair = new Pair(a, b);
+        Pair p = new Pair(1, 2);
+        System.out.println("pair=" + p.left + "," + p.right);
+
+        // Records have value equality in both languages.
+        System.out.println("same=" + p.equals(new Pair(1, 2)));
 
-        return pair.left + "," + pair.right;
+        System.out.println("nested=" + scale(3));
     }
 }
@@ -1,27 +1,51 @@
-package com.example;
+package example;
 
 import java.util.ArrayList;
 import java.util.List;
+import java.util.function.BiFunction;
 import java.util.function.Function;
 import java.util.function.Supplier;
 
 /**
- * Java 8 method references (JEP 126), which map to C# method groups rather than invocations.
+ * Java 8 method references (JEP 126).
+ *
+ * <p>These convert to C# method groups rather than invocations. This file is a conversion-only
+ * test: java.util.function has no mapping to BCL delegate types, so the generated C# cannot be
+ * compiled and run by the integration harness. See ConvertJava21GapTests for the assertions on
+ * the generated syntax.
  */
 public class Java8MethodReferences {
-    public void printAll(List<String> items) {
-        items.forEach(System.out::println);
+    public static int add(int a, int b) {
+        return a + b;
+    }
+
+    public String value;
+
+    public String upper() {
+        return value.toUpperCase();
     }
 
+    // Reference to an instance method of a type, applied to a supplied receiver.
     public Function<String, Integer> lengthOf() {
         return String::length;
     }
 
+    // Constructor reference, which has no C# equivalent and becomes a lambda.
     public Supplier<ArrayList<String>> newList() {
         return ArrayList<String>::new;
     }
 
-    public int count(List<String> items) {
-        return items.size();
+    // Reference to a static method.
+    public BiFunction<Integer, Integer, Integer> adder() {
+        return Java8MethodReferences::add;
+    }
+
+    // Reference to an instance method of a particular object.
+    public Supplier<String> upperOf() {
+        return this::upper;
+    }
+
+    public void printAll(List<String> items) {
+        items.forEach(System.out::println);
     }
 }
@@ -1,20 +1,47 @@
-package com.example;
+/// Expect:
+/// - output: "clamped=5\nmax=9\ndoubled=8\nsingle=3\n"
+package example;
 
-import static java.lang.Math.max;
-import static java.lang.Math.min;
-import static java.util.Arrays.asList;
+import static example.MathHelpers.doubled;
+import static example.MathHelpers.max;
+import static example.MathHelpers.min;
+import static example.Constants.*;
 
-import java.util.List;
+// A static import names the declaring type, so it must become `using static`. Treating it as a
+// namespace import stripped the type off and left the imported members unresolvable.
+//
+// java.lang.Math is deliberately not used here: it maps to Java.Lang.Math, which does not exist in
+// the BCL, so the generated code could not be compiled and run by this harness.
+class MathHelpers {
+    public static int max(int a, int b) {
+        return a > b ? a : b;
+    }
+
+    public static int min(int a, int b) {
+        return a < b ? a : b;
+    }
 
-/**
- * Static imports, which map to C# <c>using static</c> directives rather than namespace usings.
- */
-public class StaticImports {
-    public int clamp(int value, int low, int high) {
+    public static int doubled(int a) {
+        return a * 2;
+    }
+}
+
+class Constants {
+    public static final int SINGLE = 3;
+}
+
+public class Program {
+    public static int clamp(int value, int low, int high) {
         return min(max(value, low), high);
     }
 
-    public List<String> pair(String a, String b) {
-        return asList(a, b);
+    public static void main(String[] args) {
+        System.out.println("clamped=" + clamp(12, 1, 5));
+        System.out.println("max=" + max(9, 3));
+        System.out.println("doubled=" + doubled(4));
+
+        // An on-demand static import (`import static example.Constants.*`) already names the type,
+        // so nothing is stripped from it.
+        System.out.println("single=" + SINGLE);
     }
 }