var out bytes.Buffer
	rootCmd := GetRootCmd([]string{"options"})
	rootCmd.SetOut(&out)
	rootCmd.SetErr(&out)

	fErr := rootCmd.Execute()
	if fErr != nil {
		t.Fatalf("options failed with %v and %q\n", fErr, out.String())
	}
	if !regexp.MustCompile(expectedOutput).Match(out.Bytes()) {
		t.Fatalf("'istioctl options' expected output\n%s\n  got\n%s",
			expectedOutput, out.String())
	}

                            "items": {
                                "anyOf": [{"type": "string"}, {"type": "integer"}]
                            },
                        },
                        "msg": {"title": "Message", "type": "string"},
                        "type": {"title": "Error Type", "type": "string"},
                    },
                },
            }
        },

                            "items": {
                                "anyOf": [{"type": "string"}, {"type": "integer"}]
                            },
                        },
                        "msg": {"title": "Message", "type": "string"},
                        "type": {"title": "Error Type", "type": "string"},
                    },
                },
            }
        },

                                "anyOf": [{"type": "string"}, {"type": "integer"}]
                            },
                            "type": "array",
                            "title": "Location",
                        },
                        "msg": {"type": "string", "title": "Message"},
                        "type": {"type": "string", "title": "Error Type"},
                    },

      }
    }
    return max;
  }

  /**
   * Returns a string containing the supplied {@code byte} values separated by {@code separator}.
   * For example, {@code join(":", 0x01, 0x02, -0x01)} returns the string {@code "1:2:-1"}.
   *
   * @param separator the text that should appear between consecutive values in the resulting string
   *     (but not at the start or end)

     *            クラス名。{@literal null}や空文字列であってはいけません
     * @return パッケージ名とFQCNからパッケージ名を除いた名前
     */
    public static String[] splitPackageAndShortClassName(final String className) {
        assertArgumentNotEmpty("className", className);

        final String[] ret = new String[2];
        final int i = className.lastIndexOf('.');
        if (i > 0) {
            ret[0] = className.substring(0, i);

            default:
                throw new IllegalArgumentException(new String(arr, offset, length));
            }
            count++;
        }

        return value;
    }

    static final char[] HEXCHARS = {
        '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'
    };


    private static String bin_to_hex ( int value, int length ) {
        char[] arr = new char[length];

	"gorm.io/gorm"
	. "gorm.io/gorm/utils/tests"
)

func NameIn1And2(d *gorm.DB) *gorm.DB {
	return d.Where("name in (?)", []string{"ScopeUser1", "ScopeUser2"})
}

func NameIn2And3(d *gorm.DB) *gorm.DB {
	return d.Where("name in (?)", []string{"ScopeUser2", "ScopeUser3"})
}

func NameIn(names []string) func(d *gorm.DB) *gorm.DB {
	return func(d *gorm.DB) *gorm.DB {
		return d.Where("name in (?)", names)
	}
}

	}
	if input[0] == '[' {
		return json.Unmarshal(input, i)
	}
	m := make(map[string]T)
	if err := json.Unmarshal(input, &m); err != nil {
		return err
	}
	*i = maps.Values(m)
	return nil
}

// PrintBootstrapDump prints just the bootstrap config dump to the ConfigWriter stdout
func (c *ConfigWriter) PrintBootstrapDump(outputFormat string) error {
	// TODO
	return nil
}

  // as if the messageExpression field were unset. If messageExpression evaluates to an empty string, a string with only spaces, or a string
  // that contains line breaks, then the validation failure message will also be produced as if the messageExpression field were unset, and
  // the fact that messageExpression produced an empty string/string with only spaces/string with line breaks will be logged.