if err := json.Unmarshal(data, &info); err != nil {
		return err
	}
	sum, err := hex.DecodeString(info.Hash)
	if err != nil {
		return err
	}
	c.Algorithm = BitrotAlgorithmFromString(info.Algorithm)
	c.Hash = sum
	if _, err = fmt.Sscanf(info.Name, "part.%d", &c.PartNumber); err != nil {
		return err
	}

	if !c.Algorithm.Available() {
		internalLogIf(GlobalContext, errBitrotHashAlgoInvalid)

	"gorm.io/gorm/schema"
	"gorm.io/gorm/utils"
)

func Query(db *gorm.DB) {
	if db.Error == nil {
		BuildQuerySQL(db)

		if !db.DryRun && db.Error == nil {
			rows, err := db.Statement.ConnPool.QueryContext(db.Statement.Context, db.Statement.SQL.String(), db.Statement.Vars...)
			if err != nil {
				db.AddError(err)
				return
			}
			defer func() {
				db.AddError(rows.Close())
			}()

		writeErrorResponse(ctx, w, errorCodes.ToAPIErr(ErrBadRequest), r.URL)
		return
	}

	opts, err := getOpts(ctx, r, bucket, object)
	if err != nil {
		writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL)
		return
	}

	// Check for auth type to return S3 compatible error.
	// type to return the correct error (NoSuchKey vs AccessDenied)

			if !hasMore {
				auditOptions := AuditLogOptions{Event: "callhome:diagnostics"}
				// Received all data. Send to SUBNET and return
				err := sendHealthInfo(ctx, healthInfo)
				if err != nil {
					internalLogIf(ctx, fmt.Errorf("Unable to perform callhome: %w", err))
					auditOptions.Error = err.Error()
				}
				auditLogInternal(ctx, auditOptions)
				return
			}
			healthInfo = hi
		case <-healthCtx.Done():
			return

	if err != nil {
		t.Fatal(err)
	}
	_, err = writer.Write([]byte("aaaaa"))
	if err != nil {
		t.Fatal(err)
	}
	if bw, ok := writer.(io.Closer); ok {
		bw.Close()
	}

	reader := newBitrotReader(disk, nil, volume, filePath, 35, bitrotAlgo, bitrotWriterSum(writer), 10)
	b := make([]byte, 10)
	if _, err = reader.ReadAt(b, 0); err != nil {
		t.Fatal(err)
	}
	if _, err = reader.ReadAt(b, 10); err != nil {
		t.Fatal(err)
	}

 * {@link SmbException#getMessageByCode(int)} and
 * {@link SmbException#getStatusByCode(int)}.
 */
@DisplayName("SmbAuthException Tests")
class SmbAuthExceptionTest {

    /**
     * Provides a set of error codes covering normal, edge and unknown cases.
     */
    static Stream<Arguments> errorCodes() {
        return Stream.of(
                // Known NT status code - NT_STATUS_UNSUCCESSFUL

                if (FessAdminAction.class.isAssignableFrom(runtime.getActionType())) {
                    return "/admin/error/error.jsp";
                }
                return "/error/system.jsp";
            }
        });
    }

    protected Consumer<List<String>> createMessageNameList() {
        return nameList -> nameList.add("fess_message");
    }

				},
			}

			var err error
			globalLambdaTargetList, err = lambda.FetchEnabledTargets(context.Background(), cfg, http.DefaultTransport.(*http.Transport))
			if err != nil {
				t.Fatalf("failed to load lambda targets: %v", err)
			}

			getLambdaEventData = func(_, _ string, _ auth.Credentials, _ *http.Request) (levent.Event, error) {
				return levent.Event{

     * @param cause the cause of the exception
     */
    public GsaConfigException(final String message, final Throwable cause) {
        super(message, cause);
    }

    /**
     * Constructs a new GSA configuration exception with the specified detail message.
     *
     * @param message the detail message describing the configuration error
     */

        assertNull(e.getCause());
    }

    /**
     * Test the constructor with a message.
     */
    @Test
    void testMessageConstructor() {
        String errorMessage = "This is a test error message.";
        PACDecodingException e = new PACDecodingException(errorMessage);
        // Expect the message to be set correctly and cause to be null
        assertEquals(errorMessage, e.getMessage());