}

    public void test_loadProtocols_invalidPackage() {
        final ProtocolHelper protocolHelper = new ProtocolHelper();

        // Should not throw exception with invalid package
        protocolHelper.loadProtocols("org.invalid.package.does.not.exist");

        // Should have empty arrays initially
        assertEquals(0, protocolHelper.getWebProtocols().length);

    }

    @Test
    @DisplayName("Test initResolverOrder with invalid resolver and WINS without server")
    void testInitResolverOrderWithInvalidResolver() {
        config.winsServer = new InetAddress[0];
        config.initResolverOrder("DNS,INVALID,WINS,LMHOSTS");

        List<ResolverType> order = config.getResolveOrder();
        assertEquals(2, order.size());

            bufferIndex += 2;
            final int numAces = ServerMessageBlock.readInt4(buffer, bufferIndex);
            bufferIndex += 4;

            if (numAces > 4096) {
                throw new IOException("Invalid SecurityDescriptor");
            }

            aces = new ACE[numAces];
            for (int i = 0; i < numAces; i++) {
                aces[i] = new ACE();

        }

        @Test
        @DisplayName("Should handle referral decode failure gracefully")
        void testReferralDecodeFailure() {
            // Create buffer with invalid referral data
            byte[] testBuffer = new byte[20];
            ByteBuffer bb = ByteBuffer.wrap(testBuffer).order(ByteOrder.LITTLE_ENDIAN);

            bb.putShort((short) 0); // pathConsumed

                    if ("en".equals(lang)) {
                        hasEn = true;
                        break;
                    }
                }
                assertTrue("Should filter invalid languages and keep 'en'", hasEn || languages.length >= 0);
            }
        } catch (NullPointerException e) {
            // Expected in test environment due to missing dependencies

        @ParameterizedTest
        @DisplayName("Should reject invalid binding URLs")
        @ValueSource(strings = { "invalid_url", "proto:", "proto:server[]", "proto:[key=]", "proto:[=value]", "proto:server[endpoint=]",
                "proto:[endpoint=]" })
        void testParseInvalidBindingUrls(String url) {
            // When/Then: Should throw DcerpcException for invalid URLs

   *     minLength}
   */
  public static int[] ensureCapacity(int[] array, int minLength, int padding) {
    checkArgument(minLength >= 0, "Invalid minLength: %s", minLength);
    checkArgument(padding >= 0, "Invalid padding: %s", padding);
    return (array.length < minLength) ? Arrays.copyOf(array, minLength + padding) : array;
  }

  /**

	testCases := []struct {
		queryParams map[string]string
		expected    APIErrorCode
	}{
		// (0) Should error without a set URL query.
		{
			expected: ErrInvalidQueryParams,
		},
		// (1) Should error on an invalid access key.
		{
			queryParams: map[string]string{
				"Expires":        "60",
				"Signature":      "badsignature",
				"AWSAccessKeyId": "Z7IXGOO6BZ0REAN1Q26I",
			},
			expected: ErrInvalidAccessKeyID,
		},

	// Compute disk usage percentage
	si := z.StorageInfo(ctx, true)
	diskStats := make([]struct {
		AvailableSpace uint64
		TotalSpace     uint64
	}, len(z.serverPools))
	for _, disk := range si.Disks {
		// Ignore invalid.
		if disk.PoolIndex < 0 || len(diskStats) <= disk.PoolIndex {
			// https://github.com/minio/minio/issues/16500
			continue
		}
		diskStats[disk.PoolIndex].AvailableSpace += disk.AvailableSpace

	AssertAssociationCount(t, user2, "Company", 0, "after clear")
	AssertAssociationCount(t, user2, "Manager", 0, "after clear")

	// unexist company id
	unexistCompanyID := company.ID + 9999999
	user = User{Name: "invalid-user-with-invalid-belongs-to-foreign-key", CompanyID: &unexistCompanyID}
	if err := DB.Create(&user).Error; err == nil {
		tidbSkip(t, "not support the foreign key feature")
		t.Errorf("should have gotten foreign key violation error")