final Iterator<ListFrobber> remainingActions = actionsToPerformConcurrently.iterator();

          final Set<List<Integer>> allStates = new HashSet<>();

          @Override
          public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            return method.equals(getAllStatesMethod)
                ? getAllStates()
                : invokeListMethod(method, args);
          }

                }
            }
            var m = cls.getDeclaredMethod(name, paramTypes);
            m.setAccessible(true);
            return (int) m.invoke(target, params);
        } catch (Exception e) {
            fail("invoke " + name, e);
            return -1;
        }
    }

* Elle s’exécute sans aucune authentification, il n’y a pas à envoyer d’informations d’authentification.
* Le navigateur pense qu’il n’envoie pas de JSON (faute d’en-tête `Content-Type`).

Le site malveillant pourrait alors amener l’agent IA local à envoyer des messages en colère à l’ancien patron de l’utilisateur ... ou pire. 😅

## Internet ouvert { #open-internet }

        String result1 = (String) method.invoke(crawler, dataMap, "key1", "default");
        assertEquals("value1", result1);

        // Test with empty value
        String result2 = (String) method.invoke(crawler, dataMap, "key2", "default");
        assertEquals("default", result2);

        // Test with null value
        String result3 = (String) method.invoke(crawler, dataMap, "key3", "default");

            assertNull(getIdMethod.invoke(crawlingConfigHelper, (String) null));
            assertNull(getIdMethod.invoke(crawlingConfigHelper, ""));
            assertNull(getIdMethod.invoke(crawlingConfigHelper, "W"));
            assertEquals("123", getIdMethod.invoke(crawlingConfigHelper, "W123"));
            assertEquals("abc", getIdMethod.invoke(crawlingConfigHelper, "Fabc"));

        }
    }

    // Helper method to invoke protected method using reflection
    private ClassificationMeta invokeMethod(Object obj, String methodName, String param) {
        try {
            java.lang.reflect.Method method = obj.getClass().getDeclaredMethod(methodName, String.class);
            method.setAccessible(true);
            return (ClassificationMeta) method.invoke(obj, param);
        } catch (Exception e) {

 *
 * <p><b>{@code default} method warning:</b> This class does <i>not</i> forward calls to {@code
 * default} methods. Instead, it inherits their default implementations. When those implementations
 * invoke methods, they invoke methods on the {@code ForwardingBlockingDeque}.
 *
 * <p>The {@code standard} methods are not guaranteed to be thread-safe, even when all of the
 * methods that they depend on are thread-safe.
 *

            // Then
            assertTrue(Modifier.isProtected(method.getModifiers()));
            method.setAccessible(true); // Required to invoke protected method
            assertEquals(443, method.invoke(testHandler));
        }

        @Test
        @DisplayName("Should maintain inheritance hierarchy")
        void testInheritanceHierarchy() {
            // When

                method.setAccessible(true);
                byte[] targetInfo = (byte[]) method.invoke(null, mockContext, null);

                assertNotNull(targetInfo);
                assertEquals(4, targetInfo.length); // Only the 4-byte terminator
            } catch (Exception e) {
                fail("Failed to invoke makeTargetInfo via reflection: " + e.getMessage());
            }
        }
    }

 *
 * <p><b>{@code default} method warning:</b> This class does <i>not</i> forward calls to {@code
 * default} methods. Instead, it inherits their default implementations. When those implementations
 * invoke methods, they invoke methods on the {@code ForwardingSortedSet}.
 *
 * <p>Each of the {@code standard} methods, where appropriate, uses the set's comparator (or the