[DO NOT MERGE] Document failing test cases

Author: aldexis

baseline-error-prone/src/test/java/com/palantir/baseline/errorprone/IllegalSafeLoggingLambdaTest.java

@@ -395,6 +395,102 @@ void fun(@Safe Object ob) {}
                 .doTest();
     }
 
+    @Test
+    public void testUnsafeLambdaSwitchStatement() {
+        helper().addSourceLines(
+                        "Test.java",
+                        // language=Java
+                        """
+                        import com.palantir.logsafe.*;
+                        import java.util.function.*;
+
+                        enum MyEnum {
+                          ONE,
+                          TWO
+                        }
+
+                        class Test {
+                          void f(MyEnum myEnum, @Unsafe Object unsafeValue) {
+                            @Safe
+                            Object result =
+                                switch (myEnum) {
+                                    // BUG: Diagnostic contains: Dangerous
+                                  case ONE -> unsafeValue;
+                                  case TWO -> "safe";
+                                };
+                          }
+                        }
+                        """)
+                .doTest();
+    }
+
+    @Test
+    void testOverrideArgumentSafety() {
+        helper().addSourceLines(
+                        "Test.java",
+                        // language=Java
+                        """
+                        import com.palantir.logsafe.*;
+                        import java.util.function.*;
+
+                        interface MyInterface {
+                          @Safe
+                          String safeMethod(@Unsafe String safeArg);
+                        }
+
+                        class MyClass implements MyInterface {
+                          @Override
+                          @Safe
+                          // BUG: Diagnostic contains: Dangerous
+                          public String safeMethod(@Safe String safeArg) {
+                            return "unsafe";
+                          }
+                        }
+                        """)
+                .doTest();
+    }
+
+    @Test
+    void testLambdaConsumesSafetyAnnotatedType_reference() {
+        helper().addSourceLines(
+                        "Test.java",
+                        // language=Java
+                        """
+                        import com.palantir.logsafe.*;
+                        import java.util.function.*;
+
+                        class Test {
+                          // BUG: Diagnostic contains: Dangerous
+                          Consumer<@Unsafe String> func = this::fun;
+
+                          void fun(@Safe Object ob) {}
+                        }
+                        """)
+                .doTest();
+    }
+
+    @Test
+    void testLambdaProducesSafetyAnnotatedType_reference() {
+        helper().addSourceLines(
+                        "Test.java",
+                        // language=Java
+                        """
+                        import com.palantir.logsafe.*;
+                        import java.util.function.*;
+
+                        class Test {
+                          // BUG: Diagnostic contains: Dangerous
+                          Supplier<@Safe String> func = this::fun;
+
+                          @Unsafe
+                          String fun() {
+                            return "unsafe";
+                          }
+                        }
+                        """)
+                .doTest();
+    }
+
     private CompilationTestHelper helper() {
         return CompilationTestHelper.newInstance(IllegalSafeLoggingArgument.class, getClass());
     }