assertEquals(0, initialThroughput);

        // Add some data transfer
        channelInfo.addBytesSent(1000);
        channelInfo.addBytesReceived(2000);

        // Wait a bit to ensure time passes
        try {
            Thread.sleep(10);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }

        long throughput = channelInfo.getThroughput();

        exclude_defaults: bool = False,
        exclude_none: bool = False,
    ) -> bytes:
        # What calls this code passes a value that already called
        # self._type_adapter.validate_python(value)
        # This uses Pydantic's dump_json() which serializes directly to JSON
        # bytes in one pass (via Rust), avoiding the intermediate Python dict
        # step of dump_python(mode="json") + json.dumps().

            }
        } catch (IOException e) {
            assertEquals("Resource not found: non/existent/resource.json", e.getMessage());
            // Test passes - exception was thrown as expected
        }
    }

    /**
     * Test that resource content is properly read using readAllBytes.
     * Verifies that the new implementation correctly reads entire resource content.

import java.util.SortedMap;
import java.util.TreeMap;
import org.jspecify.annotations.Nullable;

/**
 * A wrapper around {@code TreeMap} that aggressively checks to see if keys are mutually comparable.
 * This implementation passes the navigable map test suites.
 *
 * @author Louis Wasserman
 */
@GwtIncompatible
public final class SafeTreeMap<K, V> implements Serializable, NavigableMap<K, V> {
  @SuppressWarnings("unchecked")

    @Test
    public void test_initializeProbes() {
        // Test that initializeProbes doesn't throw exception
        try {
            ThumbnailGenerator.initializeProbes();
            // If no exception thrown, test passes
            assertTrue(true);
        } catch (Exception e) {
            fail("initializeProbes should not throw exception: " + e.getMessage());
        }
    }

    @Test
    public void test_main_withHelp() {

          // For convenience, testing only with big endianness, to match DataOutputStream.
          // I regard highly unlikely that both the little endianness tests above and this one
          // passes, and there is still a little endianness bug lurking around.
        }
      }

      Control control = new Control();
      Hasher controlSink = control.newHasher(1024);

        violations = validator.validate(bean);
        assertEquals(1, violations.size()); // Only CronExpression violation

        bean.setRequiredCron(""); // Empty string passes NotNull but should pass CronExpression too
        violations = validator.validate(bean);
        assertTrue(violations.isEmpty());
    }

    // Test annotation composition
    @Test

import java.util.SortedMap;
import java.util.TreeMap;
import org.jspecify.annotations.Nullable;

/**
 * A wrapper around {@code TreeMap} that aggressively checks to see if keys are mutually comparable.
 * This implementation passes the navigable map test suites.
 *
 * @author Louis Wasserman
 */
@GwtIncompatible
public final class SafeTreeMap<K, V> implements Serializable, NavigableMap<K, V> {
  @SuppressWarnings("unchecked")

        assertEquals(value1, value2);
    }

    // Test property that should be consistent
    @Test
    public void test_get_propertyFilter() {
        // Test a regular property that passes through
        String value = fessConfig.get("domain.title");
        assertEquals("Test Fess", value);
    }

    // Test null property handling
    @Test
    public void test_get_nullProperty() {

        leftoverFiles.forEach {
            assertTrue(projectDir.resolve(it).walk().filter { it.isFile }.toList().isEmpty())
        }
    }

    @Test
    fun `fail build if leftover file found and test passes`() {
        val result = run(":successful-test-with-leftover:test").buildAndFail()
        assertEquals(TaskOutcome.SUCCESS, result.task(":successful-test-with-leftover:test")!!.outcome)