}
			}
		} else if db.Statement.Schema != nil && db.Statement.ReflectValue.IsValid() {
			queryFields := db.QueryFields
			if !queryFields {
				switch db.Statement.ReflectValue.Kind() {
				case reflect.Struct:
					queryFields = db.Statement.ReflectValue.Type() != db.Statement.Schema.ModelType
				case reflect.Slice:

                }
                if (i < len && data[i] == '.') {
                    dots++;
                    i++;
                }
            }
        } else {
            switch (this.hostName.hexCode) {
            case 0x1B:
            case 0x1C:
            case 0x1D:
                this.calledName = SMBSERVER_NAME;
            }
        }

        return this.calledName;

        this.targetName = targetName;
    }

    @Override
    public byte[] initSecContext(final byte[] token, final int offset, final int len) throws SmbException {
        return switch (this.state) {
        case 1 -> makeNegotiate(token);
        case 2 -> makeAuthenticate(token);
        default -> throw new SmbException("Invalid state");
        };
    }

    /**

 * functions without a clear receiver
 */

// CmpInt compares x and y. The result is
//
//	-1 if x <  y
//	 0 if x == y
//	+1 if x >  y
func CmpInt(x, y *Int) int {
	x.doinit()
	y.doinit()
	switch cmp := C.mpz_cmp(&x.i[0], &y.i[0]); {
	case cmp < 0:
		return -1
	case cmp == 0:
		return 0
	}
	return +1
}

// DivModInt sets q = x / y and r = x % y.
func DivModInt(q, r, x, y *Int) {

	}
	// Since `apiRouter` satisfies `http.Handler` it has a ServeHTTP to execute the logic of the handler.
	// Call the ServeHTTP to execute the handler.
	apiRouter.ServeHTTP(rec, req)
	switch rec.Code {
	case http.StatusOK, http.StatusCreated, http.StatusAccepted, http.StatusNoContent:
		t.Fatalf("Test %v: expected failure, but succeeded with %v", instanceType, rec.Code)
	}

    //                                                                        ============

    private static OptionalEntity<RelatedContent> getEntity(final CreateForm form, final String username, final long currentTime) {
        switch (form.crudMode) {
        case CrudMode.CREATE:
            return OptionalEntity.of(new RelatedContent()).map(entity -> {
                entity.setCreatedBy(username);
                entity.setCreatedTime(currentTime);

    }
    if (MICROSECONDS.convert(nanos, NANOSECONDS) > 0) {
      return MICROSECONDS;
    }
    return NANOSECONDS;
  }

  private static String abbreviate(TimeUnit unit) {
    switch (unit) {
      case NANOSECONDS:
        return "ns";
      case MICROSECONDS:
        return "\u03bcs"; // μs
      case MILLISECONDS:
        return "ms";
      case SECONDS:
        return "s";

        this.digest = Crypto.getMD5();
        try {
            final byte[] serverEncryptionKey = transport.getServerEncryptionKey();
            switch (transport.getContext().getConfig().getLanManCompatibility()) {
            case 0:
            case 1:
            case 2:
                this.macSigningKey = new byte[40];

				return false
			}
			versioned := vc != nil && vc.Versioned(object)
			objInfo := fi.ToObjectInfo(bucket, object, versioned)

			evt := evalActionFromLifecycle(ctx, *lc, lr, rcfg, objInfo)
			switch {
			case evt.Action.DeleteRestored(): // if restored copy has expired,delete it synchronously
				applyExpiryOnTransitionedObject(ctx, newObjectLayerFn(), objInfo, evt, lcEventSrc_Heal)
				return false

    //                                                                        ============
    private static OptionalEntity<PathMapping> getEntity(final CreateForm form, final String username, final long currentTime) {
        switch (form.crudMode) {
        case CrudMode.CREATE:
            return OptionalEntity.of(new PathMapping()).map(entity -> {
                entity.setCreatedBy(username);
                entity.setCreatedTime(currentTime);