// Simulate error status
        when(mockResponse.isError()).thenReturn(true);
        assertTrue(mockResponse.isError());

        // Verify the method was called
        verify(mockResponse, times(2)).isError();
    }

    @Test
    void testError() {
        // Call the method
        mockResponse.error();

        // Verify that the method was called

    message = "moved to val",
    replaceWith = ReplaceWith(expression = "type"),
    level = DeprecationLevel.ERROR,
  )
  fun type(): String = type

  @JvmName("-deprecated_subtype")
  @Deprecated(
    message = "moved to val",
    replaceWith = ReplaceWith(expression = "subtype"),
    level = DeprecationLevel.ERROR,
  )
  fun subtype(): String = subtype

  /**

func loadDataUsageFromBackend(ctx context.Context, objAPI ObjectLayer) (DataUsageInfo, error) {
	buf, err := readConfig(ctx, objAPI, dataUsageObjNamePath)
	if err != nil {
		buf, err = readConfig(ctx, objAPI, dataUsageObjNamePath+".bkp")
		if err != nil {
			if errors.Is(err, errConfigNotFound) {
				return DataUsageInfo{}, nil
			}
			return DataUsageInfo{}, toObjectErr(err, minioMetaBucket, dataUsageObjNamePath)
		}
	}

		t.Run("", func(t *testing.T) {
			_, err := ParseObjectLockConfig(strings.NewReader(tt.value))
			//nolint:gocritic
			if tt.expectedErr == nil {
				if err != nil {
					t.Fatalf("error: expected = <nil>, got = %v", err)
				}
			} else if err == nil {
				t.Fatalf("error: expected = %v, got = <nil>", tt.expectedErr)
			} else if tt.expectedErr.Error() != err.Error() {
				t.Fatalf("error: expected = %v, got = %v", tt.expectedErr, err)

     * @throws IOException if an I/O error occurs
     */
    public PacDataInputStream(final InputStream in) throws IOException {
        this.dis = new DataInputStream(in);
        this.size = in.available();
    }

    /**
     * Aligns the stream position to the specified boundary.
     * @param mask the alignment mask (typically 2, 4, or 8)
     * @throws IOException if an I/O error occurs
     */

		host, port, err := net.SplitHostPort(addr)
		if err != nil {
			return nil, err
		}

		if net.ParseIP(host) != nil {
			// For IP only setups there is no need for DNS lookups.
			return baseDialCtx(ctx, "tcp", addr)
		}

		ips, err := lookupHost(ctx, host)
		if err != nil {
			return nil, err
		}

		for _, ip := range ips {

                                    },
                                },
                            },
                            "description": "Validation Error",
                        },
                    },
                    "summary": "Read Root",
                },
            },
        },
        "components": {
            "schemas": {

            rpc.retval = errorCode; // Simulate RPC error
            return null;
        }).when(mockDcerpcHandle).sendrecv(any(MsrpcLsarOpenPolicy2.class));

        // Act & Assert
        SmbException thrown = assertThrows(SmbException.class, () -> {
            new LsaPolicyHandle(mockDcerpcHandle, server, access);
        });

			Op:   "open",
			Path: path,
			Err:  syscall.EINVAL,
		}
	}

	f, err := os.OpenFile(path, flag|syscall.O_SYNC, perm)
	if err != nil {
		return nil, err
	}

	if err = syscall.Flock(int(f.Fd()), lockType); err != nil {
		f.Close()
		if err == syscall.EWOULDBLOCK {
			err = ErrAlreadyLocked
		}
		return nil, err
	}

	st, err := os.Stat(path)
	if err != nil {
		f.Close()
		return nil, err
	}

     * @param resp The response.
     * @param challenge The domain controller challenge.
     * @throws IOException If an IO error occurs.
     * @return the authenticated NtlmPasswordAuthentication object
     * @throws IOException If an IO error occurs.
     * @throws ServletException If an error occurs.
     */
    public static NtlmPasswordAuthentication authenticate(final HttpServletRequest req, final HttpServletResponse resp,