// no-op for test
            }
        }
        assertThrows(ClassCastException.class, () -> transport.unwrap(OtherTransport.class));
    }

    @Test
    @DisplayName("getSmbSession creates and then reuses matching session")
    void getSmbSession_createAndReuse() {
        // Arrange: minimal credentials chain so SmbSessionImpl constructor succeeds
        CredentialsInternal creds = mock(CredentialsInternal.class);

    /**
     * Returns an {@link Iterable} of {@link FieldDesc}.
     *
     * @return An {@link Iterable} of {@link FieldDesc}
     */
    Iterable<FieldDesc> getFieldDescs();

    /**
     * Creates a new instance.
     *
     * @param <T>
     *            The type of the Bean class
     * @param args
     *            The arguments to pass to the constructor
     * @return A new instance
     */

        crawlingInfoHelper.putToInfoMap("url_count", "100");
        crawlingInfoHelper.putToInfoMap("error_count", "5");

        // Store with create=true
        crawlingInfoHelper.store(sessionId, true);

        // Verify infoMap is cleared
        assertNull(crawlingInfoHelper.infoMap);
    }

    public void test_store_existing() {
        final String sessionId = "existing-session";

### Create the Tables { #create-the-tables }

We then add a function that uses `SQLModel.metadata.create_all(engine)` to **create the tables** for all the *table models*.

{* ../../docs_src/sql_databases/tutorial001_an_py310.py ln[21:22] hl[21:22] *}

### Create a Session Dependency { #create-a-session-dependency }

	if err := DB.Omit("Languages.*").Create(&user).Error; err == nil {
		t.Fatalf("should raise error when create users without languages reference")
	}

	if err := DB.Create(&user.Languages).Error; err != nil {
		t.Fatalf("no error should happen when create languages, but got %v", err)
	}

	if err := DB.Omit("Languages.*").Create(&user).Error; err != nil {

	}

	t.Run("Polymorphic", func(t *testing.T) {
		pet := Pet{Name: "create"}

		if err := DB.Create(&pet).Error; err != nil {
			t.Fatalf("errors happened when create: %v", err)
		}

		pet.Toy = Toy{Name: "Update-HasOneAssociation-Polymorphic"}

		if err := DB.Save(&pet).Error; err != nil {
			t.Fatalf("errors happened when create: %v", err)
		}

		var pet2 Pet
		DB.Preload("Toy").Find(&pet2, "id = ?", pet.ID)

  public static class ImmutableListOfGenerator extends TestStringListGenerator {
    @Override
    protected List<String> create(String[] elements) {
      return ImmutableList.copyOf(elements);
    }
  }

  public static class BuilderAddListGenerator extends TestStringListGenerator {
    @Override
    protected List<String> create(String[] elements) {
      ImmutableList.Builder<String> builder = ImmutableList.<String>builder();

    /**
     * Map of pending requests to their corresponding responses.
     */
    protected HashMap response_map = new HashMap(4);

    /**
     * Creates a key for the specified request for response matching.
     *
     * @param request the request to create a key for
     * @throws IOException if an I/O error occurs
     */
    protected abstract void makeKey(Request request) throws IOException;

    /**

/**
 * Test cases for AuthenticationRateLimiter
 */
public class AuthenticationRateLimiterTest {

    private AuthenticationRateLimiter rateLimiter;

    @BeforeEach
    public void setUp() {
        // Create rate limiter with test-friendly settings
        rateLimiter = new AuthenticationRateLimiter(3, // max attempts per account
                5, // max attempts per IP
                20, // max global attempts per minute

			// multiple / elements
			return true
		case path[r] == '.' && (r+1 == n || path[r+1] == '/'):
			// . element - assume it has to be cleaned.
			return true
		case path[r] == '.' && path[r+1] == '.' && (r+2 == n || path[r+2] == '/'):
			// .. element: remove to last / - assume it has to be cleaned.
			return true
		default:
			// real path element.
			// add slash if needed
			if rooted && w != 1 || !rooted && w != 0 {