class CoreUtils {

    public static <T> T cast(Class<T> clazz, Object o, String name) {
        if (!clazz.isInstance(o)) {
            if (o == null) {
                throw new IllegalArgumentException(name + " is null");
            }
            throw new IllegalArgumentException(name + " is not an instance of " + clazz.getName());
        }
        return clazz.cast(o);
    }

    for item in items:
        if isinstance(item, str):
            resolve_file(item=item, files=files, config=config)
        elif isinstance(item, dict):
            assert len(item) == 1
            values = list(item.values())
            if not values:
                continue
            if isinstance(values[0], str):
                resolve_file(item=values[0], files=files, config=config)

        File tempFile = createTempFile("pomTest");
        FileModelSource instance = new FileModelSource(tempFile);

        assertFalse(instance.equals(null), "Expected " + instance + " to not equal " + null);
        assertFalse(instance.equals(new Object()));
        assertTrue(instance.equals(instance), "Expected " + instance + " to equal " + instance);
        assertTrue(instance.equals(new FileModelSource(tempFile)));
    }

    @Test

        dt_field: safe_datetime

    instance = MyDict(dt_field=safe_datetime.now())

    encoded_instance = jsonable_encoder(
        instance, custom_encoder={safe_datetime: lambda o: o.strftime("%H:%M:%S")}
    )
    assert encoded_instance["dt_field"] == instance["dt_field"].strftime("%H:%M:%S")

    encoded_instance = jsonable_encoder(
        instance, custom_encoder={datetime: lambda o: o.strftime("%H:%M:%S")}

But we want to be able to parameterize that fixed content.

## A "callable" instance { #a-callable-instance }

In Python there's a way to make an instance of a class a "callable".

Not the class itself (which is already a callable), but an instance of that class.

To do that, we declare a method `__call__`:

{* ../../docs_src/dependencies/tutorial011_an_py39.py hl[12] *}

    instance := grid.NewStream[*Payload, *Req, *Resp](h, newPayload, newReq, newResp)

    // Tweakable options
    instance.WithPayload = true // default true when newPayload != nil
    instance.OutCapacity = 1    // default
    instance.InCapacity = 1     // default true when newReq != nil

    // Register the handler on the manager
    instance.Register(manager, handler, "asubroute")

                afterExecutionFailure.incrementAndGet();
            }
        };
        assertSame(instance, scope.scope(Key.get(Object.class), () -> instance).get());
        assertSame(
                instance,
                scope.scope(Key.get(WeakMojoExecutionListener.class), () -> instance)
                        .get());

        final MojoExecutionEvent event = new MojoExecutionEvent(null, null, null, null);

    field = v2.ModelField(name="items", field_info=field_info)
    result = v2.serialize_sequence_value(field=field, value=["a", "b", "c"])
    assert result == ["a", "b", "c"]
    assert isinstance(result, list)


@needs_py310
def test_serialize_sequence_value_with_optional_list_pipe_union():
    """Test that serialize_sequence_value handles optional lists correctly (with new syntax)."""

  <version>0.0.0.0</version>
</parent>
    ]]></configuration>
    <description> This is the MavenProject instance for the parent of the current POM.
    </description>
  </expression>
  <expression>
    <syntax>project.file</syntax>
    <description> This is the File instance that refers to the location of the current POM on
      disk.
    </description>
  </expression>
  <expression>

class MonotonicClockTest {

    @Test
    @DisplayName("MonotonicClock singleton instance should always return the same instance")
    void testSingletonInstance() {
        MonotonicClock clock1 = MonotonicClock.get();
        MonotonicClock clock2 = MonotonicClock.get();

        assertSame(clock1, clock2, "Multiple calls to get() should return the same instance");
    }

    @Test