} else {
                slf4jLogger.warn(
                        "Expected LoggerFactory to be of type '{}', but found '{}' instead. "
                                + "The --fail-on-severity flag will not take effect.",
                        LogLevelRecorder.class.getName(),
                        slf4jLoggerFactory.getClass().getName());
            }
        }

pkg encoding/json, method (Delim) String() string
pkg encoding/json, type Delim int32
pkg encoding/json, type Token interface {}
pkg encoding/json, type UnmarshalTypeError struct, Offset int64
pkg flag, func UnquoteUsage(*Flag) (string, string)
pkg go/ast, type EmptyStmt struct, Implicit bool
pkg go/build, type Package struct, PkgTargetRoot string
pkg go/constant, const Bool = 1
pkg go/constant, const Bool Kind

      </description>
      <fields>
        <field>
          <name>activeByDefault</name>
          <version>1.0.0+</version>
          <type>boolean</type>
          <description>
            Flag specifying whether this profile is active as a default.
          </description>
        </field>
        <field>
          <name>jdk</name>
          <version>1.0.0+</version>
          <type>String</type>

    val ping = peer.takeFrame()
    assertThat(ping.type).isEqualTo(Http2.TYPE_PING)
  }

  @Test fun serverWritesTrailersWithData() {
    // We buffer some outbound data and headers and confirm that the END_STREAM flag comes with the
    // headers (and not with the data).

    // Write the mocking script. for the client
    peer.setClient(true)

    // Write the mocking script.
    peer.sendFrame().settings(Settings())

	type QueryResetItem struct {
		ID   string `gorm:"type:varchar(5)"`
		Name string
	}

	type QueryResetNullValue struct {
		ID      int
		Name    string     `gorm:"default:NULL"`
		Flag    bool       `gorm:"default:NULL"`
		Number1 int64      `gorm:"default:NULL"`
		Number2 uint64     `gorm:"default:NULL"`
		Number3 float64    `gorm:"default:NULL"`
		Now     *time.Time `gorm:"default:NULL"`

*   CPU
    *   Fix an issue w/ dynamic weights and `Conv2D` on x86.
    *   Add a runtime Android flag for enabling `XNNPACK` for optimized CPU
        performance.
    *   Add a runtime iOS flag for enabling `XNNPACK` for optimized CPU
        performance.
    *   Add a compiler flag to enable building a TFLite library that applies
        `XNNPACK` delegate automatically when the model has a `fp32` operation.

                        + "', but found '"
                        + context.loggerFactory.getClass().getName() + "' instead. "
                        + "The --fail-on-severity flag will not take effect.");
            }
        }

        // at this point logging is set up, reply so far accumulated logs, if any and swap logger with real one
        Logger logger =

func (tr *Reader) readOldGNUSparseMap(hdr *Header, blk *block) (sparseDatas, error) {
	// Make sure that the input format is GNU.
	// Unfortunately, the STAR format also has a sparse header format that uses
	// the same type flag but has a completely different layout.
	if blk.getFormat() != FormatGNU {
		return nil, ErrHeader
	}
	hdr.Format.mayOnlyBe(FormatGNU)

	var p parser
	hdr.Size = p.parseNumeric(blk.toGNU().realSize())

	"github.com/minio/minio/internal/logger"
	"github.com/minio/pkg/v3/certs"
	"github.com/minio/pkg/v3/env"
	"gopkg.in/yaml.v2"
)

// ServerFlags - server command specific flags
var ServerFlags = []cli.Flag{
	cli.StringFlag{
		Name:   "config",
		Usage:  "specify server configuration via YAML configuration",
		EnvVar: "MINIO_CONFIG",
	},
	cli.StringFlag{
		Name:   "address",
		Value:  ":" + GlobalMinioDefaultPort,

	if errors.Is(err, errFileCorrupt) && opts.ScanMode != madmin.HealDeepScan {
		// Instead of returning an error when a bitrot error is detected
		// during a normal heal scan, heal again with bitrot flag enabled.
		opts.ScanMode = madmin.HealDeepScan
		hr, err = er.healObject(healCtx, bucket, object, versionID, opts)
	}
	return hr, toObjectErr(err, bucket, object, versionID)
}