docstring_tokens
list | code_tokens
list |
|---|---|
[
"try",
"to",
"sleep",
",",
"and",
"ignore",
"the",
"{",
"@",
"link",
"interrupted",
"exception",
"}"
] |
[
"private",
"void",
"try",
"2",
"sleep",
"(",
"long",
"millis",
")",
"{",
"try",
"{",
"thread",
"sleep",
"(",
"millis",
")",
";",
"}",
"catch",
"(",
"interrupted",
"exception",
"ignored",
")",
"{",
"}",
"}"
] |
[
"test",
"the",
"property",
"'",
"string",
"'"
] |
[
"public",
"void",
"string",
"test",
"(",
")",
"{",
"/",
"/",
"todo",
":",
"test",
"string",
"}"
] |
[
"test",
"overflow",
"in",
"the",
"fixed",
"share",
"calculations",
"the",
"3th",
"schedulable",
"should",
"not",
"get",
"any",
"share",
"as",
"all",
"resources",
"are",
"taken",
"by",
"the",
"handle",
"fixed",
"share",
"(",
")",
"call",
"with",
"the",
"overflow",
"it",
"looked",
"like",
"there",
"were",
"more",
"resources",
"available",
"then",
"there",
"really",
"are",
"the",
"values",
"in",
"the",
"test",
"might",
"not",
"be",
"\"",
"real",
"\"",
"but",
"they",
"show",
"the",
"overflow"
] |
[
"public",
"void",
"test",
"overflow",
"fixed",
"share",
"(",
")",
"{",
"long",
"giga",
"=",
"1000l",
"*",
"1000l",
"*",
"1000l",
";",
"long",
"min",
"value",
"=",
"long",
"max",
"value",
"-",
"1l",
";",
"scheds",
"add",
"(",
"new",
"fake",
"schedulable",
"(",
"giga",
",",
"giga",
",",
"0",
")",
")",
";",
"scheds",
"add",
"(",
"new",
"fake",
"schedulable",
"(",
"min",
"value",
",",
"long",
"max",
"value",
",",
"0",
")",
")",
";",
"scheds",
"add",
"(",
"new",
"fake",
"schedulable",
"(",
"0l",
",",
"giga",
")",
")",
";",
"compute",
"fair",
"shares",
"compute",
"shares",
"(",
"scheds",
",",
"resources",
"create",
"resource",
"(",
"1000l",
")",
",",
"resource",
"information",
"memory",
"mb",
"get",
"name",
"(",
")",
")",
";",
"verify",
"memory",
"shares",
"(",
"giga",
",",
"min",
"value",
",",
"0",
")",
";",
"}"
] |
[
"returns",
"true",
"if",
"the",
"user",
"made",
"a",
"selection",
"for",
"every",
"conflict",
"in",
"the",
"table"
] |
[
"public",
"boolean",
"all",
"choices",
"are",
"resolved",
"(",
")",
"{",
"for",
"(",
"int",
"row",
"=",
"0",
";",
"row",
"<",
"rows",
"size",
"(",
")",
";",
"row",
"+",
"+",
")",
"{",
"j",
"component",
"comp",
"=",
"get",
"component",
"(",
"row",
",",
"0",
")",
";",
"if",
"(",
"(",
"comp",
"instanceof",
"my",
"radio",
"button",
")",
"&",
"&",
"(",
"(",
"(",
"my",
"radio",
"button",
")",
"comp",
")",
"is",
"selected",
"(",
")",
")",
")",
"{",
"return",
"true",
";",
"}",
"else",
"if",
"(",
"(",
"comp",
"instanceof",
"my",
"check",
"box",
")",
"&",
"&",
"(",
"(",
"(",
"my",
"check",
"box",
")",
"comp",
")",
"is",
"selected",
"(",
")",
")",
")",
"{",
"return",
"true",
";",
"}",
"}",
"return",
"false",
";",
"}"
] |
[
"tests",
"creation",
"of",
"table",
"mapping",
"based",
"on",
"given",
"node",
"details"
] |
[
"public",
"void",
"test",
"generate",
"node",
"table",
"mapping",
"(",
")",
"throws",
"exception",
"{",
"set",
"<",
"node",
"details",
">",
"nodes",
"=",
"s",
"l",
"s",
"utils",
"generate",
"nodes",
"(",
"3",
",",
"3",
")",
";",
"file",
"temp",
"file",
"=",
"file",
"create",
"temp",
"file",
"(",
"\"",
"testslsutils",
"\"",
",",
"\"",
"tmp",
"\"",
")",
";",
"temp",
"file",
"delete",
"on",
"exit",
"(",
")",
";",
"string",
"file",
"name",
"=",
"temp",
"file",
"get",
"absolute",
"path",
"(",
")",
";",
"s",
"l",
"s",
"utils",
"generate",
"node",
"table",
"mapping",
"(",
"nodes",
",",
"file",
"name",
")",
";",
"list",
"<",
"string",
">",
"lines",
"=",
"files",
"read",
"all",
"lines",
"(",
"paths",
"get",
"(",
"file",
"name",
")",
")",
";",
"assert",
"assert",
"equals",
"(",
"3",
",",
"lines",
"size",
"(",
")",
")",
";",
"for",
"(",
"string",
"line",
":",
"lines",
")",
"{",
"assert",
"assert",
"true",
"(",
"line",
"contains",
"(",
"\"",
"node",
"\"",
")",
")",
";",
"assert",
"assert",
"true",
"(",
"line",
"contains",
"(",
"\"",
"/",
"rack",
"\"",
")",
")",
";",
"}",
"}"
] |
[
"sets",
"the",
"preferred",
"size",
"of",
"the",
"dialog",
"note",
"that",
"if",
"you",
"set",
"the",
"preferred",
"size",
",",
"the",
"dialog",
"will",
"ignore",
"any",
"natural",
"preferred",
"size",
"of",
"your",
"components"
] |
[
"public",
"void",
"set",
"preferred",
"size",
"(",
"int",
"width",
",",
"int",
"height",
")",
"{",
"this",
"default",
"size",
"=",
"new",
"dimension",
"(",
"width",
",",
"height",
")",
";",
"}"
] |
[
"the",
"number",
"of",
"records",
"with",
"an",
"invalid",
"date",
"field",
"that",
"could",
"not",
"be",
"parsed",
"or",
"converted",
"to",
"epoch",
"time"
] |
[
"public",
"long",
"get",
"invalid",
"date",
"count",
"(",
")",
"{",
"return",
"invalid",
"date",
"count",
";",
"}"
] |
[
"returns",
"the",
"selected",
"member",
"future"
] |
[
"public",
"kafka",
"future",
"<",
"void",
">",
"member",
"result",
"(",
"member",
"to",
"remove",
"member",
")",
"{",
"if",
"(",
"remove",
"all",
"(",
")",
")",
"{",
"throw",
"new",
"illegal",
"argument",
"exception",
"(",
"\"",
"the",
"method",
":",
"member",
"result",
"is",
"not",
"applicable",
"in",
"'",
"remove",
"all",
"'",
"mode",
"\"",
")",
";",
"}",
"if",
"(",
"!",
"member",
"infos",
"contains",
"(",
"member",
")",
")",
"{",
"throw",
"new",
"illegal",
"argument",
"exception",
"(",
"\"",
"member",
"\"",
"+",
"member",
"+",
"\"",
"was",
"not",
"included",
"in",
"the",
"original",
"request",
"\"",
")",
";",
"}",
"final",
"kafka",
"future",
"impl",
"<",
"void",
">",
"result",
"=",
"new",
"kafka",
"future",
"impl",
"<",
">",
"(",
")",
";",
"this",
"future",
"when",
"complete",
"(",
"(",
"member",
"errors",
",",
"throwable",
")",
"-",
">",
"{",
"if",
"(",
"throwable",
"!",
"=",
"null",
")",
"{",
"result",
"complete",
"exceptionally",
"(",
"throwable",
")",
";",
"}",
"else",
"if",
"(",
"!",
"maybe",
"complete",
"exceptionally",
"(",
"member",
"errors",
",",
"member",
"to",
"member",
"identity",
"(",
")",
",",
"result",
")",
")",
"{",
"result",
"complete",
"(",
"null",
")",
";",
"}",
"}",
")",
";",
"return",
"result",
";",
"}"
] |
[
"parses",
"a",
"retention",
"leases",
"collection",
"from",
"{",
"@",
"link",
"org",
"elasticsearch",
"common",
"xcontent",
"x",
"content",
"}",
"this",
"method",
"assumes",
"that",
"the",
"retention",
"leases",
"were",
"converted",
"to",
"{",
"@",
"link",
"org",
"elasticsearch",
"common",
"xcontent",
"x",
"content",
"}",
"via",
"{",
"@",
"link",
"#",
"to",
"x",
"content",
"(",
"x",
"content",
"builder",
",",
"params",
")",
"}"
] |
[
"public",
"static",
"retention",
"leases",
"from",
"x",
"content",
"(",
"final",
"x",
"content",
"parser",
"parser",
")",
"{",
"return",
"parser",
"apply",
"(",
"parser",
",",
"null",
")",
";",
"}"
] |
[
"called",
"by",
"log",
"4j",
"2",
"to",
"initialize",
"this",
"converter"
] |
[
"public",
"static",
"test",
"thread",
"info",
"pattern",
"converter",
"new",
"instance",
"(",
"final",
"string",
"[",
"]",
"options",
")",
"{",
"if",
"(",
"options",
"length",
">",
"0",
")",
"{",
"throw",
"new",
"illegal",
"argument",
"exception",
"(",
"\"",
"no",
"options",
"supported",
"but",
"options",
"provided",
":",
"\"",
"+",
"arrays",
"to",
"string",
"(",
"options",
")",
")",
";",
"}",
"return",
"new",
"test",
"thread",
"info",
"pattern",
"converter",
"(",
")",
";",
"}"
] |
[
"called",
"when",
"a",
"view",
"created",
"by",
"the",
"adapter",
"has",
"been",
"detached",
"from",
"its",
"window"
] |
[
"public",
"void",
"on",
"view",
"detached",
"from",
"window",
"(",
")",
"{",
"}"
] |
[
"get",
"custom",
"editor",
"for",
"the",
"given",
"type",
"if",
"no",
"direct",
"match",
"found",
",",
"try",
"custom",
"editor",
"for",
"superclass",
"(",
"which",
"will",
"in",
"any",
"case",
"be",
"able",
"to",
"render",
"a",
"value",
"as",
"string",
"via",
"{",
"@",
"code",
"get",
"as",
"text",
"}",
")"
] |
[
"private",
"property",
"editor",
"get",
"custom",
"editor",
"(",
"@",
"nullable",
"class",
"<",
"?",
">",
"required",
"type",
")",
"{",
"if",
"(",
"required",
"type",
"=",
"=",
"null",
"|",
"|",
"this",
"custom",
"editors",
"=",
"=",
"null",
")",
"{",
"return",
"null",
";",
"}",
"/",
"/",
"check",
"directly",
"registered",
"editor",
"for",
"type",
"property",
"editor",
"editor",
"=",
"this",
"custom",
"editors",
"get",
"(",
"required",
"type",
")",
";",
"if",
"(",
"editor",
"=",
"=",
"null",
")",
"{",
"/",
"/",
"check",
"cached",
"editor",
"for",
"type",
",",
"registered",
"for",
"superclass",
"or",
"interface",
"if",
"(",
"this",
"custom",
"editor",
"cache",
"!",
"=",
"null",
")",
"{",
"editor",
"=",
"this",
"custom",
"editor",
"cache",
"get",
"(",
"required",
"type",
")",
";",
"}",
"if",
"(",
"editor",
"=",
"=",
"null",
")",
"{",
"/",
"/",
"find",
"editor",
"for",
"superclass",
"or",
"interface",
"for",
"(",
"iterator",
"<",
"class",
"<",
"?",
">",
">",
"it",
"=",
"this",
"custom",
"editors",
"key",
"set",
"(",
")",
"iterator",
"(",
")",
";",
"it",
"has",
"next",
"(",
")",
"&",
"&",
"editor",
"=",
"=",
"null",
";",
")",
"{",
"class",
"<",
"?",
">",
"key",
"=",
"it",
"next",
"(",
")",
";",
"if",
"(",
"key",
"is",
"assignable",
"from",
"(",
"required",
"type",
")",
")",
"{",
"editor",
"=",
"this",
"custom",
"editors",
"get",
"(",
"key",
")",
";",
"/",
"/",
"cache",
"editor",
"for",
"search",
"type",
",",
"to",
"avoid",
"the",
"overhead",
"/",
"/",
"of",
"repeated",
"assignable",
"-",
"from",
"checks",
"if",
"(",
"this",
"custom",
"editor",
"cache",
"=",
"=",
"null",
")",
"{",
"this",
"custom",
"editor",
"cache",
"=",
"new",
"hash",
"map",
"<",
">",
"(",
")",
";",
"}",
"this",
"custom",
"editor",
"cache",
"put",
"(",
"required",
"type",
",",
"editor",
")",
";",
"}",
"}",
"}",
"}",
"return",
"editor",
";",
"}"
] |
[
"model",
"tests",
"for",
"big",
"cat",
"all",
"of"
] |
[
"public",
"void",
"test",
"big",
"cat",
"all",
"of",
"(",
")",
"{",
"/",
"/",
"todo",
":",
"test",
"big",
"cat",
"all",
"of",
"}"
] |
[
"test",
"renaming",
"a",
"file",
"and",
"then",
"delete",
"snapshots"
] |
[
"public",
"void",
"test",
"rename",
"file",
"and",
"delete",
"snapshot",
"(",
")",
"throws",
"exception",
"{",
"final",
"path",
"sdir",
"1",
"=",
"new",
"path",
"(",
"\"",
"/",
"dir",
"1",
"\"",
")",
";",
"final",
"path",
"sdir",
"2",
"=",
"new",
"path",
"(",
"\"",
"/",
"dir",
"2",
"\"",
")",
";",
"hdfs",
"mkdirs",
"(",
"sdir",
"1",
")",
";",
"hdfs",
"mkdirs",
"(",
"sdir",
"2",
")",
";",
"final",
"path",
"foo",
"=",
"new",
"path",
"(",
"sdir",
"2",
",",
"\"",
"foo",
"\"",
")",
";",
"d",
"f",
"s",
"test",
"util",
"create",
"file",
"(",
"hdfs",
",",
"foo",
",",
"blocksize",
",",
"repl",
",",
"seed",
")",
";",
"snapshot",
"test",
"helper",
"create",
"snapshot",
"(",
"hdfs",
",",
"sdir",
"1",
",",
"\"",
"s",
"1",
"\"",
")",
";",
"snapshot",
"test",
"helper",
"create",
"snapshot",
"(",
"hdfs",
",",
"sdir",
"2",
",",
"\"",
"s",
"2",
"\"",
")",
";",
"hdfs",
"create",
"snapshot",
"(",
"sdir",
"1",
",",
"\"",
"s",
"3",
"\"",
")",
";",
"final",
"path",
"newfoo",
"=",
"new",
"path",
"(",
"sdir",
"1",
",",
"\"",
"foo",
"\"",
")",
";",
"hdfs",
"rename",
"(",
"foo",
",",
"newfoo",
")",
";",
"hdfs",
"set",
"replication",
"(",
"newfoo",
",",
"repl",
"1",
")",
";",
"hdfs",
"create",
"snapshot",
"(",
"sdir",
"1",
",",
"\"",
"s",
"4",
"\"",
")",
";",
"hdfs",
"set",
"replication",
"(",
"newfoo",
",",
"repl",
"2",
")",
";",
"file",
"status",
"status",
"=",
"hdfs",
"get",
"file",
"status",
"(",
"newfoo",
")",
";",
"assert",
"equals",
"(",
"repl",
"2",
",",
"status",
"get",
"replication",
"(",
")",
")",
";",
"final",
"path",
"foo",
"s",
"4",
"=",
"snapshot",
"test",
"helper",
"get",
"snapshot",
"path",
"(",
"sdir",
"1",
",",
"\"",
"s",
"4",
"\"",
",",
"\"",
"foo",
"\"",
")",
";",
"status",
"=",
"hdfs",
"get",
"file",
"status",
"(",
"foo",
"s",
"4",
")",
";",
"assert",
"equals",
"(",
"repl",
"1",
",",
"status",
"get",
"replication",
"(",
")",
")",
";",
"hdfs",
"create",
"snapshot",
"(",
"sdir",
"1",
",",
"\"",
"s",
"5",
"\"",
")",
";",
"final",
"path",
"foo",
"s",
"5",
"=",
"snapshot",
"test",
"helper",
"get",
"snapshot",
"path",
"(",
"sdir",
"1",
",",
"\"",
"s",
"5",
"\"",
",",
"\"",
"foo",
"\"",
")",
";",
"status",
"=",
"hdfs",
"get",
"file",
"status",
"(",
"foo",
"s",
"5",
")",
";",
"assert",
"equals",
"(",
"repl",
"2",
",",
"status",
"get",
"replication",
"(",
")",
")",
";",
"/",
"/",
"delete",
"snapshot",
"s",
"5",
"hdfs",
"delete",
"snapshot",
"(",
"sdir",
"1",
",",
"\"",
"s",
"5",
"\"",
")",
";",
"restart",
"cluster",
"and",
"check",
"image",
"(",
"true",
")",
";",
"assert",
"false",
"(",
"hdfs",
"exists",
"(",
"foo",
"s",
"5",
")",
")",
";",
"status",
"=",
"hdfs",
"get",
"file",
"status",
"(",
"foo",
"s",
"4",
")",
";",
"assert",
"equals",
"(",
"repl",
"1",
",",
"status",
"get",
"replication",
"(",
")",
")",
";",
"/",
"/",
"delete",
"snapshot",
"s",
"4",
"hdfs",
"delete",
"snapshot",
"(",
"sdir",
"1",
",",
"\"",
"s",
"4",
"\"",
")",
";",
"assert",
"false",
"(",
"hdfs",
"exists",
"(",
"foo",
"s",
"4",
")",
")",
";",
"path",
"foo",
"s",
"3",
"=",
"snapshot",
"test",
"helper",
"get",
"snapshot",
"path",
"(",
"sdir",
"1",
",",
"\"",
"s",
"3",
"\"",
",",
"\"",
"foo",
"\"",
")",
";",
"assert",
"false",
"(",
"hdfs",
"exists",
"(",
"foo",
"s",
"3",
")",
")",
";",
"foo",
"s",
"3",
"=",
"snapshot",
"test",
"helper",
"get",
"snapshot",
"path",
"(",
"sdir",
"2",
",",
"\"",
"s",
"3",
"\"",
",",
"\"",
"foo",
"\"",
")",
";",
"assert",
"false",
"(",
"hdfs",
"exists",
"(",
"foo",
"s",
"3",
")",
")",
";",
"final",
"path",
"foo",
"s",
"2",
"=",
"snapshot",
"test",
"helper",
"get",
"snapshot",
"path",
"(",
"sdir",
"2",
",",
"\"",
"s",
"2",
"\"",
",",
"\"",
"foo",
"\"",
")",
";",
"assert",
"true",
"(",
"hdfs",
"exists",
"(",
"foo",
"s",
"2",
")",
")",
";",
"status",
"=",
"hdfs",
"get",
"file",
"status",
"(",
"foo",
"s",
"2",
")",
";",
"assert",
"equals",
"(",
"repl",
",",
"status",
"get",
"replication",
"(",
")",
")",
";",
"i",
"node",
"file",
"snode",
"=",
"fsdir",
"get",
"i",
"node",
"(",
"newfoo",
"to",
"string",
"(",
")",
")",
"as",
"file",
"(",
")",
";",
"assert",
"equals",
"(",
"1",
",",
"snode",
"get",
"diffs",
"(",
")",
"as",
"list",
"(",
")",
"size",
"(",
")",
")",
";",
"i",
"node",
"directory",
"sdir",
"2",
"node",
"=",
"fsdir",
"get",
"i",
"node",
"(",
"sdir",
"2",
"to",
"string",
"(",
")",
")",
"as",
"directory",
"(",
")",
";",
"snapshot",
"s",
"2",
"=",
"sdir",
"2",
"node",
"get",
"snapshot",
"(",
"d",
"f",
"s",
"util",
"string",
"2",
"bytes",
"(",
"\"",
"s",
"2",
"\"",
")",
")",
";",
"assert",
"equals",
"(",
"s",
"2",
"get",
"id",
"(",
")",
",",
"snode",
"get",
"diffs",
"(",
")",
"get",
"last",
"snapshot",
"id",
"(",
")",
")",
";",
"/",
"/",
"restart",
"cluster",
"restart",
"cluster",
"and",
"check",
"image",
"(",
"true",
")",
";",
"/",
"/",
"delete",
"snapshot",
"s",
"2",
"hdfs",
"delete",
"snapshot",
"(",
"sdir",
"2",
",",
"\"",
"s",
"2",
"\"",
")",
";",
"assert",
"false",
"(",
"hdfs",
"exists",
"(",
"foo",
"s",
"2",
")",
")",
";",
"/",
"/",
"restart",
"the",
"cluster",
"and",
"check",
"fsimage",
"restart",
"cluster",
"and",
"check",
"image",
"(",
"true",
")",
";",
"hdfs",
"delete",
"snapshot",
"(",
"sdir",
"1",
",",
"\"",
"s",
"3",
"\"",
")",
";",
"restart",
"cluster",
"and",
"check",
"image",
"(",
"true",
")",
";",
"hdfs",
"delete",
"snapshot",
"(",
"sdir",
"1",
",",
"\"",
"s",
"1",
"\"",
")",
";",
"restart",
"cluster",
"and",
"check",
"image",
"(",
"true",
")",
";",
"}"
] |
[
"get",
"a",
"single",
"expired",
"namenode",
"membership",
"record",
"from",
"the",
"store"
] |
[
"private",
"membership",
"state",
"get",
"expired",
"namenode",
"registration",
"(",
"final",
"string",
"ns",
"id",
",",
"final",
"string",
"nn",
"id",
")",
"throws",
"i",
"o",
"exception",
"{",
"membership",
"state",
"partial",
"=",
"membership",
"state",
"new",
"instance",
"(",
")",
";",
"partial",
"set",
"nameservice",
"id",
"(",
"ns",
"id",
")",
";",
"partial",
"set",
"namenode",
"id",
"(",
"nn",
"id",
")",
";",
"get",
"namenode",
"registrations",
"request",
"request",
"=",
"get",
"namenode",
"registrations",
"request",
"new",
"instance",
"(",
"partial",
")",
";",
"get",
"namenode",
"registrations",
"response",
"response",
"=",
"membership",
"store",
"get",
"expired",
"namenode",
"registrations",
"(",
"request",
")",
";",
"list",
"<",
"membership",
"state",
">",
"results",
"=",
"response",
"get",
"namenode",
"memberships",
"(",
")",
";",
"if",
"(",
"results",
"!",
"=",
"null",
"&",
"&",
"results",
"size",
"(",
")",
"=",
"=",
"1",
")",
"{",
"membership",
"state",
"record",
"=",
"results",
"get",
"(",
"0",
")",
";",
"return",
"record",
";",
"}",
"return",
"null",
";",
"}"
] |
[
"move",
"the",
"given",
"index",
"'",
"s",
"execution",
"state",
"back",
"to",
"a",
"step",
"that",
"had",
"previously",
"failed",
"if",
"this",
"is",
"an",
"automatic",
"retry",
"(",
"{",
"@",
"code",
"is",
"automatic",
"retry",
"}",
")",
",",
"the",
"retry",
"count",
"is",
"incremented"
] |
[
"static",
"cluster",
"state",
"move",
"cluster",
"state",
"to",
"previously",
"failed",
"step",
"(",
"cluster",
"state",
"current",
"state",
",",
"string",
"index",
",",
"long",
"supplier",
"now",
"supplier",
",",
"policy",
"steps",
"registry",
"step",
"registry",
",",
"boolean",
"is",
"automatic",
"retry",
")",
"{",
"cluster",
"state",
"new",
"state",
";",
"index",
"metadata",
"index",
"metadata",
"=",
"current",
"state",
"metadata",
"(",
")",
"index",
"(",
"index",
")",
";",
"if",
"(",
"index",
"metadata",
"=",
"=",
"null",
")",
"{",
"throw",
"new",
"illegal",
"argument",
"exception",
"(",
"\"",
"index",
"[",
"\"",
"+",
"index",
"+",
"\"",
"]",
"does",
"not",
"exist",
"\"",
")",
";",
"}",
"lifecycle",
"execution",
"state",
"lifecycle",
"state",
"=",
"lifecycle",
"execution",
"state",
"from",
"index",
"metadata",
"(",
"index",
"metadata",
")",
";",
"step",
"step",
"key",
"current",
"step",
"key",
"=",
"lifecycle",
"execution",
"state",
"get",
"current",
"step",
"key",
"(",
"lifecycle",
"state",
")",
";",
"string",
"failed",
"step",
"=",
"lifecycle",
"state",
"get",
"failed",
"step",
"(",
")",
";",
"if",
"(",
"current",
"step",
"key",
"!",
"=",
"null",
"&",
"&",
"error",
"step",
"name",
"equals",
"(",
"current",
"step",
"key",
"get",
"name",
"(",
")",
")",
"&",
"&",
"strings",
"is",
"null",
"or",
"empty",
"(",
"failed",
"step",
")",
"=",
"=",
"false",
")",
"{",
"step",
"step",
"key",
"next",
"step",
"key",
"=",
"new",
"step",
"step",
"key",
"(",
"current",
"step",
"key",
"get",
"phase",
"(",
")",
",",
"current",
"step",
"key",
"get",
"action",
"(",
")",
",",
"failed",
"step",
")",
";",
"index",
"lifecycle",
"transition",
"validate",
"transition",
"(",
"index",
"metadata",
",",
"current",
"step",
"key",
",",
"next",
"step",
"key",
",",
"step",
"registry",
")",
";",
"index",
"lifecycle",
"metadata",
"ilm",
"meta",
"=",
"current",
"state",
"metadata",
"(",
")",
"custom",
"(",
"index",
"lifecycle",
"metadata",
"type",
")",
";",
"lifecycle",
"policy",
"metadata",
"policy",
"metadata",
"=",
"ilm",
"meta",
"get",
"policy",
"metadatas",
"(",
")",
"get",
"(",
"lifecycle",
"settings",
"lifecycle",
"name",
"setting",
"get",
"(",
"index",
"metadata",
"get",
"settings",
"(",
")",
")",
")",
";",
"lifecycle",
"execution",
"state",
"next",
"step",
"state",
"=",
"index",
"lifecycle",
"transition",
"update",
"execution",
"state",
"to",
"step",
"(",
"policy",
"metadata",
",",
"lifecycle",
"state",
",",
"next",
"step",
"key",
",",
"now",
"supplier",
",",
"true",
")",
";",
"lifecycle",
"execution",
"state",
"builder",
"retry",
"step",
"state",
"=",
"lifecycle",
"execution",
"state",
"builder",
"(",
"next",
"step",
"state",
")",
";",
"retry",
"step",
"state",
"set",
"is",
"auto",
"retryable",
"error",
"(",
"lifecycle",
"state",
"is",
"auto",
"retryable",
"error",
"(",
")",
")",
";",
"integer",
"current",
"retry",
"count",
"=",
"lifecycle",
"state",
"get",
"failed",
"step",
"retry",
"count",
"(",
")",
";",
"if",
"(",
"is",
"automatic",
"retry",
")",
"{",
"retry",
"step",
"state",
"set",
"failed",
"step",
"retry",
"count",
"(",
"current",
"retry",
"count",
"=",
"=",
"null",
"?",
"1",
":",
"+",
"+",
"current",
"retry",
"count",
")",
";",
"}",
"else",
"{",
"/",
"/",
"manual",
"retries",
"don",
"'",
"t",
"update",
"the",
"retry",
"count",
"retry",
"step",
"state",
"set",
"failed",
"step",
"retry",
"count",
"(",
"lifecycle",
"state",
"get",
"failed",
"step",
"retry",
"count",
"(",
")",
")",
";",
"}",
"new",
"state",
"=",
"index",
"lifecycle",
"transition",
"new",
"cluster",
"state",
"with",
"lifecycle",
"state",
"(",
"index",
"metadata",
"get",
"index",
"(",
")",
",",
"current",
"state",
",",
"retry",
"step",
"state",
"build",
"(",
")",
")",
"build",
"(",
")",
";",
"}",
"else",
"{",
"throw",
"new",
"illegal",
"argument",
"exception",
"(",
"\"",
"cannot",
"retry",
"an",
"action",
"for",
"an",
"index",
"[",
"\"",
"+",
"index",
"+",
"\"",
"]",
"that",
"has",
"not",
"encountered",
"an",
"error",
"when",
"running",
"a",
"lifecycle",
"policy",
"\"",
")",
";",
"}",
"return",
"new",
"state",
";",
"}"
] |
[
"returns",
"the",
"names",
"of",
"the",
"symlinks",
"in",
"the",
"runfiles",
"symlink",
"farm",
"as",
"a",
"set",
"of",
"path",
"fragments",
"this",
"method",
"is",
"slow"
] |
[
"public",
"set",
"<",
"path",
"fragment",
">",
"get",
"runfiles",
"symlink",
"names",
"(",
")",
"{",
"return",
"get",
"runfiles",
"symlinks",
"(",
")",
"key",
"set",
"(",
")",
";",
"}"
] |
[
"how",
"many",
"version",
"mismatches",
"have",
"occurred"
] |
[
"long",
"get",
"version",
"mismatches",
"(",
")",
";"
] |
[
"register",
"a",
"listener",
"that",
"will",
"be",
"called",
"when",
"this",
"model",
"is",
"unbound",
"from",
"a",
"view",
"the",
"listener",
"will",
"contribute",
"to",
"this",
"model",
"'",
"s",
"hash",
"code",
"state",
"per",
"the",
"{",
"@",
"link",
"com",
"airbnb",
"epoxy",
"epoxy",
"attribute",
"option",
"#",
"do",
"not",
"hash",
"}",
"rules",
"you",
"may",
"clear",
"the",
"listener",
"by",
"setting",
"a",
"null",
"value",
",",
"or",
"by",
"calling",
"{",
"@",
"link",
"#",
"reset",
"(",
")",
"}"
] |
[
"public",
"on",
"visibility",
"state",
"changed",
"view",
"model",
"on",
"unbind",
"(",
"on",
"model",
"unbound",
"listener",
"<",
"on",
"visibility",
"state",
"changed",
"view",
"model",
",",
"on",
"visibility",
"state",
"changed",
"view",
">",
"listener",
")",
"{",
"on",
"mutation",
"(",
")",
";",
"this",
"on",
"model",
"unbound",
"listener",
"epoxy",
"generated",
"model",
"=",
"listener",
";",
"return",
"this",
";",
"}"
] |
[
"tests",
"that",
"topics",
"are",
"added",
"to",
"the",
"metadata",
"list",
"when",
"messages",
"are",
"available",
"to",
"send",
"and",
"expired",
"if",
"not",
"used",
"during",
"a",
"metadata",
"refresh",
"interval"
] |
[
"public",
"void",
"test",
"metadata",
"topic",
"expiry",
"(",
")",
"throws",
"exception",
"{",
"long",
"offset",
"=",
"0",
";",
"client",
"update",
"metadata",
"(",
"request",
"test",
"utils",
"metadata",
"update",
"with",
"(",
"1",
",",
"collections",
"singleton",
"map",
"(",
"\"",
"test",
"\"",
",",
"2",
")",
")",
")",
";",
"future",
"<",
"record",
"metadata",
">",
"future",
"=",
"append",
"to",
"accumulator",
"(",
"tp",
"0",
")",
";",
"sender",
"run",
"once",
"(",
")",
";",
"assert",
"true",
"(",
"metadata",
"contains",
"topic",
"(",
"tp",
"0",
"topic",
"(",
")",
")",
",",
"\"",
"topic",
"not",
"added",
"to",
"metadata",
"\"",
")",
";",
"client",
"update",
"metadata",
"(",
"request",
"test",
"utils",
"metadata",
"update",
"with",
"(",
"1",
",",
"collections",
"singleton",
"map",
"(",
"\"",
"test",
"\"",
",",
"2",
")",
")",
")",
";",
"sender",
"run",
"once",
"(",
")",
";",
"/",
"/",
"send",
"produce",
"request",
"client",
"respond",
"(",
"produce",
"response",
"(",
"tp",
"0",
",",
"offset",
",",
"errors",
"none",
",",
"0",
")",
")",
";",
"sender",
"run",
"once",
"(",
")",
";",
"assert",
"equals",
"(",
"0",
",",
"client",
"in",
"flight",
"request",
"count",
"(",
")",
",",
"\"",
"request",
"completed",
"\"",
")",
";",
"assert",
"false",
"(",
"client",
"has",
"in",
"flight",
"requests",
"(",
")",
")",
";",
"assert",
"equals",
"(",
"0",
",",
"sender",
"in",
"flight",
"batches",
"(",
"tp",
"0",
")",
"size",
"(",
")",
")",
";",
"sender",
"run",
"once",
"(",
")",
";",
"assert",
"true",
"(",
"future",
"is",
"done",
"(",
")",
",",
"\"",
"request",
"should",
"be",
"completed",
"\"",
")",
";",
"assert",
"true",
"(",
"metadata",
"contains",
"topic",
"(",
"tp",
"0",
"topic",
"(",
")",
")",
",",
"\"",
"topic",
"not",
"retained",
"in",
"metadata",
"list",
"\"",
")",
";",
"time",
"sleep",
"(",
"topic",
"idle",
"ms",
")",
";",
"client",
"update",
"metadata",
"(",
"request",
"test",
"utils",
"metadata",
"update",
"with",
"(",
"1",
",",
"collections",
"singleton",
"map",
"(",
"\"",
"test",
"\"",
",",
"2",
")",
")",
")",
";",
"assert",
"false",
"(",
"metadata",
"contains",
"topic",
"(",
"tp",
"0",
"topic",
"(",
")",
")",
",",
"\"",
"unused",
"topic",
"has",
"not",
"been",
"expired",
"\"",
")",
";",
"future",
"=",
"append",
"to",
"accumulator",
"(",
"tp",
"0",
")",
";",
"sender",
"run",
"once",
"(",
")",
";",
"assert",
"true",
"(",
"metadata",
"contains",
"topic",
"(",
"tp",
"0",
"topic",
"(",
")",
")",
",",
"\"",
"topic",
"not",
"added",
"to",
"metadata",
"\"",
")",
";",
"client",
"update",
"metadata",
"(",
"request",
"test",
"utils",
"metadata",
"update",
"with",
"(",
"1",
",",
"collections",
"singleton",
"map",
"(",
"\"",
"test",
"\"",
",",
"2",
")",
")",
")",
";",
"sender",
"run",
"once",
"(",
")",
";",
"/",
"/",
"send",
"produce",
"request",
"client",
"respond",
"(",
"produce",
"response",
"(",
"tp",
"0",
",",
"offset",
"+",
"1",
",",
"errors",
"none",
",",
"0",
")",
")",
";",
"sender",
"run",
"once",
"(",
")",
";",
"assert",
"equals",
"(",
"0",
",",
"client",
"in",
"flight",
"request",
"count",
"(",
")",
",",
"\"",
"request",
"completed",
"\"",
")",
";",
"assert",
"false",
"(",
"client",
"has",
"in",
"flight",
"requests",
"(",
")",
")",
";",
"assert",
"equals",
"(",
"0",
",",
"sender",
"in",
"flight",
"batches",
"(",
"tp",
"0",
")",
"size",
"(",
")",
")",
";",
"sender",
"run",
"once",
"(",
")",
";",
"assert",
"true",
"(",
"future",
"is",
"done",
"(",
")",
",",
"\"",
"request",
"should",
"be",
"completed",
"\"",
")",
";",
"}"
] |
[
"simulate",
"a",
"secondary",
"node",
"failure",
"to",
"transfer",
"image",
"uses",
"an",
"unchecked",
"error",
"and",
"fail",
"transfer",
"before",
"even",
"setting",
"the",
"length",
"header",
"this",
"used",
"to",
"cause",
"image",
"truncation",
"regression",
"test",
"for",
"hdfs",
"-",
"3330"
] |
[
"public",
"void",
"test",
"secondary",
"fails",
"with",
"error",
"before",
"setting",
"headers",
"(",
")",
"throws",
"i",
"o",
"exception",
"{",
"mockito",
"do",
"throw",
"(",
"new",
"error",
"(",
"\"",
"if",
"this",
"exception",
"is",
"not",
"caught",
"by",
"the",
"\"",
"+",
"\"",
"name",
"-",
"node",
",",
"fs",
"image",
"will",
"be",
"truncated",
"\"",
")",
")",
"when",
"(",
"fault",
"injector",
")",
"before",
"get",
"image",
"sets",
"headers",
"(",
")",
";",
"do",
"secondary",
"fails",
"to",
"return",
"image",
"(",
")",
";",
"}"
] |
[
"returns",
"a",
"random",
"field",
"name",
"can",
"be",
"a",
"leaf",
"field",
"name",
"or",
"the",
"path",
"to",
"refer",
"to",
"a",
"field",
"name",
"using",
"the",
"dot",
"notation"
] |
[
"public",
"static",
"string",
"random",
"field",
"name",
"(",
"random",
"random",
")",
"{",
"int",
"num",
"levels",
"=",
"random",
"numbers",
"random",
"int",
"between",
"(",
"random",
",",
"1",
",",
"5",
")",
";",
"string",
"builder",
"field",
"name",
"=",
"new",
"string",
"builder",
"(",
")",
";",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"num",
"levels",
"-",
"1",
";",
"i",
"+",
"+",
")",
"{",
"if",
"(",
"i",
">",
"0",
")",
"{",
"field",
"name",
"append",
"(",
"'",
"'",
")",
";",
"}",
"field",
"name",
"append",
"(",
"random",
"string",
"(",
"random",
")",
")",
";",
"}",
"if",
"(",
"num",
"levels",
">",
"1",
")",
"{",
"field",
"name",
"append",
"(",
"'",
"'",
")",
";",
"}",
"field",
"name",
"append",
"(",
"random",
"leaf",
"field",
"name",
"(",
"random",
")",
")",
";",
"return",
"field",
"name",
"to",
"string",
"(",
")",
";",
"}"
] |
[
"returns",
"the",
"command",
"environment",
"you",
"must",
"call",
"{",
"@",
"link",
"#",
"new",
"command",
"(",
")",
"}",
"before",
"calling",
"this",
"method"
] |
[
"public",
"command",
"environment",
"get",
"command",
"environment",
"(",
")",
"{",
"return",
"env",
";",
"}"
] |
[
"wait",
"until",
"the",
"application",
"has",
"finished",
"and",
"is",
"ready",
"for",
"cleanup"
] |
[
"private",
"void",
"wait",
"for",
"completion",
"(",
")",
"throws",
"interrupted",
"exception",
"{",
"synchronized",
"(",
"completion",
"lock",
")",
"{",
"while",
"(",
"!",
"completed",
")",
"{",
"completion",
"lock",
"wait",
"(",
")",
";",
"}",
"}",
"}"
] |
[
"matches",
"the",
"entire",
"region",
"for",
"the",
"string"
] |
[
"public",
"static",
"boolean",
"matches",
"(",
"final",
"pattern",
"pattern",
",",
"final",
"string",
"string",
")",
"{",
"return",
"pattern",
"matcher",
"(",
"string",
")",
"matches",
"(",
")",
";",
"}"
] |
[
"get",
"the",
"value",
"of",
"a",
"register",
"as",
"a",
"varnode",
"(",
"value",
",",
"space",
",",
"size",
")"
] |
[
"public",
"varnode",
"get",
"register",
"varnode",
"value",
"(",
"register",
"reg",
",",
"address",
"from",
"addr",
",",
"address",
"to",
"addr",
",",
"boolean",
"signed",
")",
"{",
"varnode",
"rvnode",
"=",
"null",
";",
"if",
"(",
"reg",
"=",
"=",
"null",
")",
"{",
"return",
"null",
";",
"}",
"big",
"integer",
"big",
"val",
"=",
"offset",
"context",
"get",
"value",
"(",
"reg",
",",
"from",
"addr",
",",
"to",
"addr",
",",
"signed",
")",
";",
"if",
"(",
"big",
"val",
"=",
"=",
"null",
")",
"{",
"return",
"null",
";",
"}",
"big",
"integer",
"space",
"val",
"=",
"get",
"translated",
"space",
"value",
"(",
"reg",
",",
"from",
"addr",
",",
"to",
"addr",
")",
";",
"rvnode",
"=",
"create",
"varnode",
"(",
"big",
"val",
",",
"space",
"val",
",",
"reg",
"get",
"minimum",
"byte",
"size",
"(",
")",
")",
";",
"if",
"(",
"rvnode",
"=",
"=",
"null",
")",
"{",
"return",
"null",
";",
"}",
"if",
"(",
"!",
"rvnode",
"get",
"address",
"(",
")",
"equals",
"(",
"bad",
"address",
")",
")",
"{",
"if",
"(",
"debug",
")",
"{",
"msg",
"info",
"(",
"this",
",",
"\"",
"\"",
"+",
"reg",
"get",
"name",
"(",
")",
"+",
"\"",
"=",
"\"",
"+",
"print",
"(",
"rvnode",
")",
")",
";",
"}",
"return",
"rvnode",
";",
"}",
"return",
"null",
";",
"}"
] |
[
"returns",
"the",
"version",
"of",
"elasticsearch",
"that",
"the",
"snapshot",
"was",
"created",
"with",
"will",
"only",
"return",
"{",
"@",
"code",
"null",
"}",
"if",
"{",
"@",
"link",
"#",
"state",
"(",
")",
"}",
"returns",
"{",
"@",
"code",
"null",
"}",
"or",
"{",
"@",
"link",
"snapshot",
"state",
"#",
"incompatible",
"}"
] |
[
"public",
"version",
"version",
"(",
")",
"{",
"return",
"version",
";",
"}"
] |
[
"returns",
"the",
"value",
"to",
"use",
"when",
"none",
"of",
"the",
"attribute",
"'",
"s",
"selection",
"keys",
"match"
] |
[
"public",
"t",
"get",
"default",
"(",
")",
"{",
"return",
"map",
"get",
"(",
"default",
"condition",
"label",
")",
";",
"}"
] |
[
"no",
"op",
"runnable"
] |
[
"public",
"static",
"runnable",
"no",
"op",
"(",
")",
"{",
"return",
"(",
")",
"-",
">",
"{",
"}",
";",
"}",
"@",
"scheduled",
"(",
"initial",
"delay",
"string",
"=",
"\"",
"$",
"{",
"cas",
"service",
"-",
"registry",
"schedule",
"start",
"-",
"delay",
":",
"20000",
"}",
"\"",
",",
"fixed",
"delay",
"string",
"=",
"\"",
"$",
"{",
"cas",
"service",
"-",
"registry",
"schedule",
"repeat",
"-",
"interval",
":",
"60000",
"}"
] |
[
"has",
"request",
"surrogate",
"authentication",
"request"
] |
[
"public",
"static",
"void",
"remove",
"request",
"surrogate",
"authentication",
"request",
"(",
"final",
"request",
"context",
"request",
"context",
")",
"{",
"request",
"context",
"get",
"flow",
"scope",
"(",
")",
"remove",
"(",
"\"",
"request",
"surrogate",
"account",
"\"",
")",
";",
"}"
] |
[
"adds",
"the",
"extent",
"of",
"two",
"points",
"representing",
"a",
"bounding",
"box",
"'",
"s",
"bottom",
"-",
"left",
"and",
"top",
"-",
"right",
"points",
"the",
"bounding",
"box",
"must",
"not",
"cross",
"the",
"dateline"
] |
[
"public",
"void",
"add",
"rectangle",
"(",
"int",
"bottom",
"left",
"x",
",",
"int",
"bottom",
"left",
"y",
",",
"int",
"top",
"right",
"x",
",",
"int",
"top",
"right",
"y",
")",
"{",
"assert",
"bottom",
"left",
"x",
"<",
"=",
"top",
"right",
"x",
";",
"assert",
"bottom",
"left",
"y",
"<",
"=",
"top",
"right",
"y",
";",
"this",
"bottom",
"=",
"math",
"min",
"(",
"this",
"bottom",
",",
"bottom",
"left",
"y",
")",
";",
"this",
"top",
"=",
"math",
"max",
"(",
"this",
"top",
",",
"top",
"right",
"y",
")",
";",
"if",
"(",
"bottom",
"left",
"x",
"<",
"0",
"&",
"&",
"top",
"right",
"x",
"<",
"0",
")",
"{",
"this",
"neg",
"left",
"=",
"math",
"min",
"(",
"this",
"neg",
"left",
",",
"bottom",
"left",
"x",
")",
";",
"this",
"neg",
"right",
"=",
"math",
"max",
"(",
"this",
"neg",
"right",
",",
"top",
"right",
"x",
")",
";",
"}",
"else",
"if",
"(",
"bottom",
"left",
"x",
"<",
"0",
")",
"{",
"this",
"neg",
"left",
"=",
"math",
"min",
"(",
"this",
"neg",
"left",
",",
"bottom",
"left",
"x",
")",
";",
"this",
"pos",
"right",
"=",
"math",
"max",
"(",
"this",
"pos",
"right",
",",
"top",
"right",
"x",
")",
";",
"/",
"/",
"this",
"signal",
"the",
"extent",
"cannot",
"be",
"wrapped",
"around",
"the",
"dateline",
"this",
"neg",
"right",
"=",
"0",
";",
"this",
"pos",
"left",
"=",
"0",
";",
"}",
"else",
"{",
"this",
"pos",
"left",
"=",
"math",
"min",
"(",
"this",
"pos",
"left",
",",
"bottom",
"left",
"x",
")",
";",
"this",
"pos",
"right",
"=",
"math",
"max",
"(",
"this",
"pos",
"right",
",",
"top",
"right",
"x",
")",
";",
"}",
"}"
] |
[
"gets",
"the",
"unique",
"branch",
"target",
"of",
"this",
"instruction"
] |
[
"public",
"code",
"address",
"get",
"target",
"(",
")",
"{",
"return",
"target",
";",
"}"
] |
[
"counters",
"to",
"measure",
"the",
"usage",
"of",
"the",
"different",
"file",
"systems",
"always",
"return",
"the",
"string",
"array",
"with",
"two",
"elements",
"first",
"one",
"is",
"the",
"name",
"of",
"bytes",
"read",
"counter",
"and",
"second",
"one",
"is",
"of",
"the",
"bytes",
"written",
"counter"
] |
[
"protected",
"static",
"string",
"[",
"]",
"get",
"file",
"system",
"counter",
"names",
"(",
"string",
"uri",
"scheme",
")",
"{",
"string",
"scheme",
"=",
"string",
"utils",
"to",
"upper",
"case",
"(",
"uri",
"scheme",
")",
";",
"return",
"new",
"string",
"[",
"]",
"{",
"scheme",
"+",
"\"",
"bytes",
"read",
"\"",
",",
"scheme",
"+",
"\"",
"bytes",
"written",
"\"",
"}",
";",
"}"
] |
[
"writes",
"the",
"instruction",
"at",
"the",
"given",
"offset",
"in",
"the",
"given",
"code",
"array"
] |
[
"public",
"void",
"write",
"(",
"byte",
"[",
"]",
"code",
",",
"int",
"offset",
")",
"{",
"/",
"/",
"write",
"the",
"wide",
"opcode",
",",
"if",
"necessary",
"if",
"(",
"is",
"wide",
"(",
")",
")",
"{",
"code",
"[",
"offset",
"+",
"+",
"]",
"=",
"instruction",
"constants",
"op",
"wide",
";",
"}",
"/",
"/",
"write",
"the",
"opcode",
"code",
"[",
"offset",
"+",
"+",
"]",
"=",
"opcode",
";",
"/",
"/",
"write",
"any",
"additional",
"arguments",
"write",
"info",
"(",
"code",
",",
"offset",
")",
";",
"}"
] |
[
"tests",
"that",
"an",
"existing",
"path",
"throws",
"an",
"exception"
] |
[
"public",
"void",
"test",
"add",
"already",
"existing",
"path",
"(",
")",
"throws",
"exception",
"{",
"final",
"testing",
"long",
"state",
"handle",
"helper",
"state",
"handle",
"provider",
"=",
"new",
"testing",
"long",
"state",
"handle",
"helper",
"(",
")",
";",
"zoo",
"keeper",
"state",
"handle",
"store",
"<",
"long",
">",
"store",
"=",
"new",
"zoo",
"keeper",
"state",
"handle",
"store",
"<",
">",
"(",
"zookeeper",
"get",
"client",
"(",
")",
",",
"state",
"handle",
"provider",
")",
";",
"zookeeper",
"get",
"client",
"(",
")",
"create",
"(",
")",
"for",
"path",
"(",
"\"",
"/",
"test",
"add",
"already",
"existing",
"path",
"\"",
")",
";",
"store",
"add",
"and",
"lock",
"(",
"\"",
"/",
"test",
"add",
"already",
"existing",
"path",
"\"",
",",
"1l",
")",
";",
"/",
"/",
"writing",
"to",
"the",
"state",
"storage",
"should",
"have",
"succeeded",
"assert",
"equals",
"(",
"1",
",",
"state",
"handle",
"provider",
"get",
"state",
"handles",
"(",
")",
")",
";",
"/",
"/",
"the",
"created",
"state",
"handle",
"should",
"have",
"been",
"cleaned",
"up",
"if",
"the",
"add",
"operation",
"failed",
"assert",
"equals",
"(",
"1",
",",
"state",
"handle",
"provider",
"get",
"state",
"handles",
"(",
")",
"get",
"(",
"0",
")",
"get",
"number",
"of",
"discard",
"calls",
"(",
")",
")",
";",
"}"
] |
[
"produce",
"a",
"j",
"s",
"o",
"n",
"array",
"of",
"j",
"s",
"o",
"n",
"objects",
"from",
"a",
"comma",
"delimited",
"text",
"string",
"using",
"a",
"supplied",
"j",
"s",
"o",
"n",
"array",
"as",
"the",
"source",
"of",
"element",
"names"
] |
[
"public",
"static",
"j",
"s",
"o",
"n",
"array",
"to",
"j",
"s",
"o",
"n",
"array",
"(",
"j",
"s",
"o",
"n",
"array",
"names",
",",
"string",
"string",
")",
"throws",
"j",
"s",
"o",
"n",
"exception",
"{",
"return",
"to",
"j",
"s",
"o",
"n",
"array",
"(",
"names",
",",
"new",
"j",
"s",
"o",
"n",
"tokener",
"(",
"string",
")",
")",
";",
"}"
] |
[
"get",
"name",
"boolean"
] |
[
"public",
"boolean",
"get",
"name",
"boolean",
"(",
")",
"{",
"return",
"name",
"boolean",
";",
"}"
] |
[
"branch",
"the",
"current",
"state",
"the",
"current",
"state",
"should",
"be",
"associated",
"with",
"branch",
"target",
",",
"the",
"returned",
"state",
"should",
"be",
"used",
"for",
"the",
"fall",
"-",
"through",
"flow"
] |
[
"public",
"context",
"state",
"branch",
"state",
"(",
"sequence",
"number",
"pcode",
"entry",
")",
"{",
"context",
"state",
"new",
"state",
"=",
"new",
"context",
"state",
"(",
"pcode",
"entry",
",",
"this",
")",
";",
"new",
"state",
"unique",
"map",
"=",
"unique",
"map",
";",
"if",
"(",
"unique",
"map",
"!",
"=",
"null",
")",
"{",
"unique",
"map",
"clear",
"(",
")",
";",
"}",
"return",
"new",
"state",
";",
"}"
] |
[
"identifier",
"used",
"to",
"encode",
"this",
"strategy",
",",
"when",
"marshalled",
"as",
"part",
"of",
"a",
"bloom",
"filter",
"only",
"values",
"in",
"the",
"[",
"-",
"128",
",",
"127",
"]",
"range",
"are",
"valid",
"for",
"the",
"compact",
"serial",
"form",
"non",
"-",
"negative",
"values",
"are",
"reserved",
"for",
"enums",
"defined",
"in",
"bloom",
"filter",
"strategies",
";",
"negative",
"values",
"are",
"reserved",
"for",
"any",
"custom",
",",
"stateful",
"strategy",
"we",
"may",
"define",
"(",
"e",
"g",
"any",
"kind",
"of",
"strategy",
"that",
"would",
"depend",
"on",
"user",
"input",
")"
] |
[
"int",
"ordinal",
"(",
")",
";"
] |
[
"sets",
"the",
"default",
"header",
"checking",
"mode"
] |
[
"public",
"builder",
"set",
"default",
"hdrs",
"check",
"(",
"string",
"hdrs",
"check",
")",
"{",
"/",
"/",
"note",
"that",
"this",
"setting",
"is",
"propagated",
"directly",
"to",
"the",
"package",
"because",
"/",
"/",
"other",
"code",
"needs",
"the",
"ability",
"to",
"read",
"this",
"info",
"directly",
"from",
"the",
"/",
"/",
"under",
"-",
"construction",
"package",
"see",
"{",
"@",
"link",
"package",
"#",
"set",
"default",
"hdrs",
"check",
"}",
"pkg",
"set",
"default",
"hdrs",
"check",
"(",
"hdrs",
"check",
")",
";",
"return",
"this",
";",
"}"
] |
[
"returns",
"the",
"malloc",
"implementation",
"for",
"the",
"given",
"target"
] |
[
"public",
"static",
"transitive",
"info",
"collection",
"malloc",
"for",
"target",
"(",
"rule",
"context",
"rule",
"context",
",",
"string",
"malloc",
"attr",
"name",
")",
"{",
"if",
"(",
"rule",
"context",
"get",
"fragment",
"(",
"cpp",
"configuration",
"class",
")",
"custom",
"malloc",
"(",
")",
"!",
"=",
"null",
")",
"{",
"return",
"rule",
"context",
"get",
"prerequisite",
"(",
"\"",
":",
"default",
"malloc",
"\"",
")",
";",
"}",
"else",
"{",
"return",
"rule",
"context",
"get",
"prerequisite",
"(",
"malloc",
"attr",
"name",
")",
";",
"}",
"}"
] |
[
"returns",
"a",
"matcher",
"which",
"matches",
"classes",
"in",
"the",
"given",
"package",
"packages",
"are",
"specific",
"to",
"their",
"classloader",
",",
"so",
"classes",
"with",
"the",
"same",
"package",
"name",
"may",
"not",
"have",
"the",
"same",
"package",
"at",
"runtime"
] |
[
"public",
"static",
"matcher",
"<",
"class",
">",
"in",
"package",
"(",
"final",
"package",
"target",
"package",
")",
"{",
"return",
"new",
"in",
"package",
"(",
"target",
"package",
")",
";",
"}"
] |
[
"ensures",
"the",
"given",
"array",
"has",
"a",
"given",
"size"
] |
[
"public",
"static",
"object",
"[",
"]",
"ensure",
"array",
"size",
"(",
"object",
"[",
"]",
"array",
",",
"int",
"size",
",",
"object",
"initial",
"value",
")",
"{",
"/",
"/",
"is",
"the",
"existing",
"array",
"large",
"enough",
"?",
"if",
"(",
"array",
"length",
">",
"=",
"size",
")",
"{",
"/",
"/",
"reinitialize",
"the",
"existing",
"array",
"arrays",
"fill",
"(",
"array",
",",
"0",
",",
"size",
",",
"initial",
"value",
")",
";",
"}",
"else",
"{",
"/",
"/",
"otherwise",
"create",
"and",
"initialize",
"a",
"new",
"array",
"array",
"=",
"(",
"object",
"[",
"]",
")",
"array",
"new",
"instance",
"(",
"array",
"get",
"class",
"(",
")",
"get",
"component",
"type",
"(",
")",
",",
"size",
")",
";",
"if",
"(",
"initial",
"value",
"!",
"=",
"null",
")",
"{",
"arrays",
"fill",
"(",
"array",
",",
"0",
",",
"size",
",",
"initial",
"value",
")",
";",
"}",
"}",
"return",
"array",
";",
"}"
] |
[
"test",
"checks",
"that",
"we",
"throw",
"an",
"{",
"@",
"link",
"unsupported",
"operation",
"exception",
"}",
"if",
"the",
"query",
"wrapped",
"by",
"{",
"@",
"link",
"span",
"multi",
"term",
"query",
"builder",
"}",
"does",
"not",
"generate",
"a",
"lucene",
"{",
"@",
"link",
"multi",
"term",
"query",
"}",
"this",
"is",
"currently",
"the",
"case",
"for",
"{",
"@",
"link",
"range",
"query",
"builder",
"}",
"when",
"the",
"target",
"field",
"is",
"mapped",
"to",
"a",
"date"
] |
[
"public",
"void",
"test",
"unsupported",
"inner",
"query",
"type",
"(",
")",
"throws",
"i",
"o",
"exception",
"{",
"multi",
"term",
"query",
"builder",
"query",
"=",
"new",
"term",
"multi",
"term",
"query",
"builder",
"(",
")",
";",
"span",
"multi",
"term",
"query",
"builder",
"span",
"multi",
"term",
"query",
"=",
"new",
"span",
"multi",
"term",
"query",
"builder",
"(",
"query",
")",
";",
"unsupported",
"operation",
"exception",
"e",
"=",
"expect",
"throws",
"(",
"unsupported",
"operation",
"exception",
"class",
",",
"(",
")",
"-",
">",
"span",
"multi",
"term",
"query",
"to",
"query",
"(",
"create",
"shard",
"context",
"(",
")",
")",
")",
";",
"assert",
"that",
"(",
"e",
"get",
"message",
"(",
")",
",",
"starts",
"with",
"(",
"\"",
"unsupported",
"inner",
"query",
"\"",
")",
")",
";",
"}"
] |
[
"always",
"throws",
"{",
"@",
"link",
"unsupported",
"operation",
"exception",
"}",
"changing",
"{",
"@",
"link",
"surface",
"texture",
"}",
"is",
"not",
"supported"
] |
[
"public",
"void",
"set",
"surface",
"texture",
"(",
"surface",
"texture",
"surface",
"texture",
")",
"{",
"throw",
"new",
"unsupported",
"operation",
"exception",
"(",
"\"",
"changing",
"surface",
"texture",
"is",
"not",
"supported",
"\"",
")",
";",
"}"
] |
[
"sets",
"the",
"default",
"{",
"@",
"link",
"request",
"options",
"}",
"to",
"use",
"for",
"all",
"loads",
"across",
"the",
"app",
"applying",
"additional",
"options",
"with",
"{",
"@",
"link",
"request",
"builder",
"#",
"apply",
"(",
"base",
"request",
"options",
")",
"}",
"will",
"override",
"defaults",
"set",
"here"
] |
[
"public",
"glide",
"builder",
"set",
"default",
"request",
"options",
"(",
"@",
"nullable",
"final",
"request",
"options",
"request",
"options",
")",
"{",
"return",
"set",
"default",
"request",
"options",
"(",
"new",
"request",
"options",
"factory",
"(",
")",
"{",
"@",
"non",
"null",
"@",
"override",
"public",
"request",
"options",
"build",
"(",
")",
"{",
"return",
"request",
"options",
"!",
"=",
"null",
"?",
"request",
"options",
":",
"new",
"request",
"options",
"(",
")",
";",
"}",
"}",
")",
";",
"}"
] |
[
"signals",
"all",
"threads",
"waiting",
"on",
"guards"
] |
[
"private",
"void",
"signal",
"all",
"waiters",
"(",
")",
"{",
"for",
"(",
"guard",
"guard",
"=",
"active",
"guards",
";",
"guard",
"!",
"=",
"null",
";",
"guard",
"=",
"guard",
"next",
")",
"{",
"guard",
"condition",
"signal",
"all",
"(",
")",
";",
"}",
"}"
] |
[
"test",
"the",
"property",
"'",
"complete",
"'"
] |
[
"public",
"void",
"complete",
"test",
"(",
")",
"{",
"/",
"/",
"todo",
":",
"test",
"complete",
"}"
] |
[
"returns",
"a",
"basic",
"formatter",
"for",
"a",
"two",
"digit",
"hour",
"of",
"day",
",",
"two",
"digit",
"minute",
"of",
"hour",
",",
"two",
"digit",
"second",
"of",
"minute",
",",
"and",
"time",
"zone",
"offset",
"prefixed",
"by",
"'",
"t",
"'",
"(",
"'",
"t",
"'",
"h",
"hmmss",
"z",
")",
"the",
"time",
"zone",
"offset",
"is",
"'",
"z",
"'",
"for",
"zero",
",",
"and",
"of",
"the",
"form",
"'",
"±",
"h",
"hmm",
"'",
"for",
"non",
"-",
"zero",
"the",
"parser",
"is",
"strict",
"by",
"default",
",",
"thus",
"time",
"string",
"{",
"@",
"code",
"24",
":",
"00",
"}",
"cannot",
"be",
"parsed",
"the",
"returned",
"formatter",
"prints",
"and",
"parses",
"only",
"this",
"format",
",",
"which",
"excludes",
"milliseconds"
] |
[
"public",
"static",
"date",
"time",
"formatter",
"basic",
"t",
"time",
"no",
"millis",
"(",
")",
"{",
"return",
"constants",
"bttx",
";",
"}"
] |
[
"{",
"@",
"inherit",
"doc",
"}"
] |
[
"public",
"string",
"to",
"string",
"(",
")",
"{",
"final",
"long",
"now",
"=",
"current",
"time",
"(",
")",
";",
"return",
"connection",
"+",
"\"",
",",
"accessed",
"\"",
"+",
"elapsed",
"display",
"string",
"(",
"last",
"accessed",
",",
"now",
")",
"+",
"\"",
"ago",
",",
"\"",
"+",
"state",
"to",
"string",
"(",
")",
";",
"}",
"/",
"/",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"/",
"/",
"i",
"concurrent",
"bag",
"entry",
"methods",
"/",
"/",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*",
"*"
] |
[
"set",
"the",
"start",
"time",
"of",
"this",
"{",
"@",
"link",
"find",
"}",
"command"
] |
[
"public",
"void",
"set",
"start",
"time",
"(",
"long",
"time",
")",
"{",
"this",
"start",
"time",
"=",
"time",
";",
"}"
] |
[
"returns",
"the",
"unique",
"instance",
"corresponding",
"to",
"the",
"type",
"with",
"the",
"given",
"descriptor",
",",
"allowing",
"{",
"@",
"code",
"\"",
"v",
"\"",
"}",
"to",
"return",
"the",
"type",
"for",
"{",
"@",
"code",
"void",
"}",
"other",
"than",
"that",
"one",
"caveat",
",",
"this",
"method",
"is",
"identical",
"to",
"{",
"@",
"link",
"#",
"intern",
"}"
] |
[
"public",
"static",
"type",
"intern",
"return",
"type",
"(",
"string",
"descriptor",
")",
"{",
"try",
"{",
"if",
"(",
"descriptor",
"equals",
"(",
"\"",
"v",
"\"",
")",
")",
"{",
"/",
"/",
"this",
"is",
"the",
"one",
"special",
"case",
"where",
"void",
"may",
"be",
"returned",
"return",
"void",
";",
"}",
"}",
"catch",
"(",
"null",
"pointer",
"exception",
"ex",
")",
"{",
"/",
"/",
"elucidate",
"the",
"exception",
"throw",
"new",
"null",
"pointer",
"exception",
"(",
"\"",
"descriptor",
"=",
"=",
"null",
"\"",
")",
";",
"}",
"return",
"intern",
"(",
"descriptor",
")",
";",
"}"
] |
[
"extract",
"a",
"key",
"from",
"the",
"request",
"to",
"use",
"to",
"look",
"up",
"media",
"types"
] |
[
"protected",
"abstract",
"string",
"get",
"media",
"type",
"key",
"(",
"native",
"web",
"request",
"request",
")",
";"
] |
[
"find",
"the",
"meta",
"annotations",
"from",
"the",
"the",
"{",
"@",
"link",
"annotation",
"annotation",
"}",
"type",
"by",
"meta",
"annotation",
"type"
] |
[
"static",
"<",
"a",
"extends",
"annotation",
">",
"list",
"<",
"a",
">",
"find",
"meta",
"annotations",
"(",
"class",
"<",
"?",
"extends",
"annotation",
">",
"annotation",
"type",
",",
"class",
"<",
"a",
">",
"meta",
"annotation",
"type",
")",
"{",
"return",
"(",
"list",
"<",
"a",
">",
")",
"get",
"all",
"meta",
"annotations",
"(",
"annotation",
"type",
",",
"a",
"-",
">",
"is",
"same",
"type",
"(",
"a",
",",
"meta",
"annotation",
"type",
")",
")",
";",
"}"
] |
[
"finds",
"the",
"word",
"at",
"the",
"given",
"index",
"in",
"the",
"given",
"string",
";",
"if",
"the",
"word",
"contains",
"the",
"given",
"char",
"to",
"allow",
",",
"then",
"allow",
"it",
"in",
"the",
"string",
"for",
"example",
",",
"the",
"string",
"\"",
"the",
"tree",
"is",
"green",
"\"",
"and",
"the",
"index",
"of",
"5",
",",
"char",
"to",
"allow",
"is",
"'",
"'",
",",
"then",
"the",
"result",
"would",
"be",
"\"",
"tree",
"\"",
"if",
"the",
"search",
"yields",
"only",
"whitespace",
",",
"then",
"the",
"empty",
"string",
"will",
"be",
"returned"
] |
[
"public",
"static",
"string",
"find",
"word",
"(",
"string",
"s",
",",
"int",
"index",
",",
"char",
"[",
"]",
"chars",
"to",
"allow",
")",
"{",
"word",
"location",
"location",
"=",
"find",
"word",
"location",
"(",
"s",
",",
"index",
",",
"chars",
"to",
"allow",
")",
";",
"return",
"location",
"get",
"word",
"(",
")",
";",
"}"
] |
[
"post",
"fake",
":",
"fake",
"endpoint",
"for",
"testing",
"various",
"parameters",
"가짜",
"엔드",
"포인트",
"fake",
"endpoint",
"for",
"testing",
"various",
"parameters",
"가짜",
"엔드",
"포인트"
] |
[
"default",
"response",
"entity",
"<",
"void",
">",
"test",
"endpoint",
"parameters",
"(",
"@",
"api",
"param",
"(",
"value",
"=",
"\"",
"none",
"\"",
",",
"required",
"=",
"true",
")",
"@",
"valid",
"@",
"request",
"part",
"(",
"value",
"=",
"\"",
"number",
"\"",
",",
"required",
"=",
"true",
")",
"big",
"decimal",
"number",
",",
"@",
"api",
"param",
"(",
"value",
"=",
"\"",
"none",
"\"",
",",
"required",
"=",
"true",
")",
"@",
"valid",
"@",
"request",
"part",
"(",
"value",
"=",
"\"",
"double",
"\"",
",",
"required",
"=",
"true",
")",
"double",
"double",
",",
"@",
"api",
"param",
"(",
"value",
"=",
"\"",
"none",
"\"",
",",
"required",
"=",
"true",
")",
"@",
"valid",
"@",
"request",
"part",
"(",
"value",
"=",
"\"",
"pattern",
"without",
"delimiter",
"\"",
",",
"required",
"=",
"true",
")",
"string",
"pattern",
"without",
"delimiter",
",",
"@",
"api",
"param",
"(",
"value",
"=",
"\"",
"none",
"\"",
",",
"required",
"=",
"true",
")",
"@",
"valid",
"@",
"request",
"part",
"(",
"value",
"=",
"\"",
"byte",
"\"",
",",
"required",
"=",
"true",
")",
"byte",
"[",
"]",
"byte",
",",
"@",
"api",
"param",
"(",
"value",
"=",
"\"",
"none",
"\"",
")",
"@",
"valid",
"@",
"request",
"part",
"(",
"value",
"=",
"\"",
"integer",
"\"",
",",
"required",
"=",
"false",
")",
"integer",
"integer",
",",
"@",
"api",
"param",
"(",
"value",
"=",
"\"",
"none",
"\"",
")",
"@",
"valid",
"@",
"request",
"part",
"(",
"value",
"=",
"\"",
"int",
"3",
"2",
"\"",
",",
"required",
"=",
"false",
")",
"integer",
"int",
"3",
"2",
",",
"@",
"api",
"param",
"(",
"value",
"=",
"\"",
"none",
"\"",
")",
"@",
"valid",
"@",
"request",
"part",
"(",
"value",
"=",
"\"",
"int",
"6",
"4",
"\"",
",",
"required",
"=",
"false",
")",
"long",
"int",
"6",
"4",
",",
"@",
"api",
"param",
"(",
"value",
"=",
"\"",
"none",
"\"",
")",
"@",
"valid",
"@",
"request",
"part",
"(",
"value",
"=",
"\"",
"float",
"\"",
",",
"required",
"=",
"false",
")",
"float",
"float",
",",
"@",
"api",
"param",
"(",
"value",
"=",
"\"",
"none",
"\"",
")",
"@",
"valid",
"@",
"request",
"part",
"(",
"value",
"=",
"\"",
"string",
"\"",
",",
"required",
"=",
"false",
")",
"string",
"string",
",",
"@",
"api",
"param",
"(",
"value",
"=",
"\"",
"none",
"\"",
")",
"@",
"valid",
"@",
"request",
"part",
"(",
"value",
"=",
"\"",
"binary",
"\"",
",",
"required",
"=",
"false",
")",
"multipart",
"file",
"binary",
",",
"@",
"api",
"param",
"(",
"value",
"=",
"\"",
"none",
"\"",
")",
"@",
"valid",
"@",
"request",
"part",
"(",
"value",
"=",
"\"",
"date",
"\"",
",",
"required",
"=",
"false",
")",
"local",
"date",
"date",
",",
"@",
"api",
"param",
"(",
"value",
"=",
"\"",
"none",
"\"",
")",
"@",
"valid",
"@",
"request",
"part",
"(",
"value",
"=",
"\"",
"date",
"time",
"\"",
",",
"required",
"=",
"false",
")",
"local",
"date",
"time",
"date",
"time",
",",
"@",
"api",
"param",
"(",
"value",
"=",
"\"",
"none",
"\"",
")",
"@",
"valid",
"@",
"request",
"part",
"(",
"value",
"=",
"\"",
"password",
"\"",
",",
"required",
"=",
"false",
")",
"string",
"password",
",",
"@",
"api",
"param",
"(",
"value",
"=",
"\"",
"none",
"\"",
")",
"@",
"valid",
"@",
"request",
"part",
"(",
"value",
"=",
"\"",
"callback",
"\"",
",",
"required",
"=",
"false",
")",
"string",
"param",
"callback",
")",
"{",
"return",
"new",
"response",
"entity",
"<",
">",
"(",
"http",
"status",
"not",
"implemented",
")",
";",
"}"
] |
[
"returns",
"a",
"new",
"http",
"jersey",
"{",
"@",
"link",
"client",
"}",
"for",
"performing",
"http",
"requests",
"against",
"the",
"tested",
"dropwizard",
"server",
"the",
"client",
"can",
"be",
"reused",
"across",
"different",
"tests",
"and",
"automatically",
"closed",
"along",
"with",
"the",
"server",
"the",
"client",
"can",
"be",
"augmented",
"by",
"overriding",
"the",
"{",
"@",
"link",
"#",
"client",
"builder",
"(",
")",
"}",
"method"
] |
[
"public",
"client",
"client",
"(",
")",
"{",
"synchronized",
"(",
"this",
")",
"{",
"if",
"(",
"client",
"=",
"=",
"null",
")",
"{",
"client",
"=",
"client",
"builder",
"(",
")",
"build",
"(",
")",
";",
"}",
"return",
"client",
";",
"}",
"}"
] |
[
"releases",
"all",
"domain",
"files",
"for",
"the",
"specified",
"consumer"
] |
[
"public",
"void",
"release",
"domain",
"files",
"(",
"object",
"consumer",
")",
"{",
"for",
"(",
"domain",
"object",
"adapter",
"domain",
"obj",
":",
"open",
"domain",
"objects",
"values",
"(",
")",
")",
"{",
"try",
"{",
"if",
"(",
"domain",
"obj",
"get",
"consumer",
"list",
"(",
")",
"contains",
"(",
"consumer",
")",
")",
"{",
"domain",
"obj",
"release",
"(",
"consumer",
")",
";",
"}",
"}",
"catch",
"(",
"illegal",
"argument",
"exception",
"e",
")",
"{",
"/",
"/",
"ignore",
"}",
"}",
"}"
] |
[
"test",
"recovery",
"on",
"restart",
"oob",
"message",
"it",
"also",
"tests",
"the",
"delivery",
"of",
"oob",
"ack",
"originating",
"from",
"the",
"primary",
"datanode",
"since",
"there",
"is",
"only",
"one",
"node",
"in",
"the",
"cluster",
",",
"failure",
"of",
"restart",
"-",
"recovery",
"will",
"fail",
"the",
"test"
] |
[
"public",
"void",
"test",
"pipeline",
"recovery",
"on",
"o",
"o",
"b",
"(",
")",
"throws",
"exception",
"{",
"configuration",
"conf",
"=",
"new",
"hdfs",
"configuration",
"(",
")",
";",
"conf",
"set",
"(",
"hdfs",
"client",
"config",
"keys",
"dfs",
"client",
"datanode",
"restart",
"timeout",
"key",
",",
"\"",
"15",
"\"",
")",
";",
"mini",
"d",
"f",
"s",
"cluster",
"cluster",
"=",
"null",
";",
"try",
"{",
"int",
"num",
"data",
"nodes",
"=",
"1",
";",
"cluster",
"=",
"new",
"mini",
"d",
"f",
"s",
"cluster",
"builder",
"(",
"conf",
")",
"num",
"data",
"nodes",
"(",
"num",
"data",
"nodes",
")",
"build",
"(",
")",
";",
"cluster",
"wait",
"active",
"(",
")",
";",
"file",
"system",
"file",
"sys",
"=",
"cluster",
"get",
"file",
"system",
"(",
")",
";",
"path",
"file",
"=",
"new",
"path",
"(",
"\"",
"dataprotocol",
"2",
"dat",
"\"",
")",
";",
"d",
"f",
"s",
"test",
"util",
"create",
"file",
"(",
"file",
"sys",
",",
"file",
",",
"10240l",
",",
"(",
"short",
")",
"1",
",",
"0l",
")",
";",
"d",
"f",
"s",
"output",
"stream",
"out",
"=",
"(",
"d",
"f",
"s",
"output",
"stream",
")",
"(",
"file",
"sys",
"append",
"(",
"file",
")",
"get",
"wrapped",
"stream",
"(",
")",
")",
";",
"out",
"write",
"(",
"1",
")",
";",
"out",
"hflush",
"(",
")",
";",
"d",
"f",
"s",
"admin",
"dfsadmin",
"=",
"new",
"d",
"f",
"s",
"admin",
"(",
"conf",
")",
";",
"data",
"node",
"dn",
"=",
"cluster",
"get",
"data",
"nodes",
"(",
")",
"get",
"(",
"0",
")",
";",
"final",
"string",
"dn",
"addr",
"=",
"dn",
"get",
"datanode",
"id",
"(",
")",
"get",
"ipc",
"addr",
"(",
"false",
")",
";",
"/",
"/",
"issue",
"shutdown",
"to",
"the",
"datanode",
"final",
"string",
"[",
"]",
"args",
"1",
"=",
"{",
"\"",
"-",
"shutdown",
"datanode",
"\"",
",",
"dn",
"addr",
",",
"\"",
"upgrade",
"\"",
"}",
";",
"assert",
"assert",
"equals",
"(",
"0",
",",
"dfsadmin",
"run",
"(",
"args",
"1",
")",
")",
";",
"/",
"/",
"wait",
"long",
"enough",
"to",
"receive",
"an",
"oob",
"ack",
"before",
"closing",
"the",
"file",
"generic",
"test",
"utils",
"wait",
"for",
"thread",
"termination",
"(",
"\"",
"async",
"datanode",
"shutdown",
"thread",
"\"",
",",
"100",
",",
"10000",
")",
";",
"/",
"/",
"retart",
"the",
"datanode",
"cluster",
"restart",
"data",
"node",
"(",
"0",
",",
"true",
")",
";",
"/",
"/",
"the",
"following",
"forces",
"a",
"data",
"packet",
"and",
"end",
"of",
"block",
"packets",
"to",
"be",
"sent",
"out",
"close",
"(",
")",
";",
"}",
"finally",
"{",
"if",
"(",
"cluster",
"!",
"=",
"null",
")",
"{",
"cluster",
"shutdown",
"(",
")",
";",
"}",
"}",
"}"
] |
[
"sets",
"whether",
"the",
"specified",
"variable",
"is",
"alive",
"before",
"the",
"instruction",
"at",
"the",
"given",
"offset"
] |
[
"public",
"void",
"set",
"alive",
"before",
"(",
"int",
"instruction",
"offset",
",",
"int",
"variable",
"index",
",",
"boolean",
"alive",
")",
"{",
"if",
"(",
"variable",
"index",
"<",
"max",
"variables",
"size",
")",
"{",
"if",
"(",
"alive",
")",
"{",
"is",
"alive",
"before",
"[",
"instruction",
"offset",
"]",
"|",
"=",
"1l",
"<",
"<",
"variable",
"index",
";",
"}",
"else",
"{",
"is",
"alive",
"before",
"[",
"instruction",
"offset",
"]",
"&",
"=",
"~",
"(",
"1l",
"<",
"<",
"variable",
"index",
")",
";",
"}",
"}",
"}"
] |
[
"tests",
"that",
"plugins",
"can",
"register",
"pre",
"-",
"configured",
"char",
"filters",
"that",
"vary",
"in",
"behavior",
"based",
"on",
"elasticsearch",
"version",
",",
"lucene",
"version",
",",
"and",
"that",
"do",
"not",
"vary",
"based",
"on",
"version",
"at",
"all"
] |
[
"public",
"void",
"test",
"plugin",
"pre",
"configured",
"char",
"filters",
"(",
")",
"throws",
"i",
"o",
"exception",
"{",
"boolean",
"no",
"version",
"supports",
"multi",
"term",
"=",
"random",
"boolean",
"(",
")",
";",
"boolean",
"lucene",
"version",
"supports",
"multi",
"term",
"=",
"random",
"boolean",
"(",
")",
";",
"boolean",
"elasticsearch",
"version",
"supports",
"multi",
"term",
"=",
"random",
"boolean",
"(",
")",
";",
"analysis",
"registry",
"registry",
"=",
"new",
"analysis",
"module",
"(",
"test",
"environment",
"new",
"environment",
"(",
"empty",
"node",
"settings",
")",
",",
"singleton",
"list",
"(",
"new",
"analysis",
"plugin",
"(",
")",
"{",
"@",
"override",
"public",
"list",
"<",
"pre",
"configured",
"char",
"filter",
">",
"get",
"pre",
"configured",
"char",
"filters",
"(",
")",
"{",
"return",
"arrays",
"as",
"list",
"(",
"pre",
"configured",
"char",
"filter",
"singleton",
"(",
"\"",
"no",
"version",
"\"",
",",
"no",
"version",
"supports",
"multi",
"term",
",",
"token",
"stream",
"-",
">",
"new",
"append",
"char",
"filter",
"(",
"token",
"stream",
",",
"\"",
"no",
"version",
"\"",
")",
")",
",",
"pre",
"configured",
"char",
"filter",
"lucene",
"version",
"(",
"\"",
"lucene",
"version",
"\"",
",",
"lucene",
"version",
"supports",
"multi",
"term",
",",
"(",
"token",
"stream",
",",
"lucene",
"version",
")",
"-",
">",
"new",
"append",
"char",
"filter",
"(",
"token",
"stream",
",",
"lucene",
"version",
"to",
"string",
"(",
")",
")",
")",
",",
"pre",
"configured",
"char",
"filter",
"elasticsearch",
"version",
"(",
"\"",
"elasticsearch",
"version",
"\"",
",",
"elasticsearch",
"version",
"supports",
"multi",
"term",
",",
"(",
"token",
"stream",
",",
"es",
"version",
")",
"-",
">",
"new",
"append",
"char",
"filter",
"(",
"token",
"stream",
",",
"es",
"version",
"to",
"string",
"(",
")",
")",
")",
")",
";",
"}",
"@",
"override",
"public",
"map",
"<",
"string",
",",
"analysis",
"provider",
"<",
"tokenizer",
"factory",
">",
">",
"get",
"tokenizers",
"(",
")",
"{",
"/",
"/",
"need",
"mock",
"keyword",
"tokenizer",
"here",
",",
"because",
"alpha",
"/",
"beta",
"versions",
"are",
"broken",
"up",
"by",
"the",
"dash",
"return",
"singleton",
"map",
"(",
"\"",
"keyword",
"\"",
",",
"(",
"index",
"settings",
",",
"environment",
",",
"name",
",",
"settings",
")",
"-",
">",
"tokenizer",
"factory",
"new",
"factory",
"(",
"name",
",",
"(",
")",
"-",
">",
"new",
"mock",
"tokenizer",
"(",
"mock",
"tokenizer",
"keyword",
",",
"false",
")",
")",
")",
";",
"}",
"}",
")",
")",
"get",
"analysis",
"registry",
"(",
")",
";",
"version",
"version",
"=",
"version",
"utils",
"random",
"version",
"(",
"random",
"(",
")",
")",
";",
"index",
"analyzers",
"analyzers",
"=",
"get",
"index",
"analyzers",
"(",
"registry",
",",
"settings",
"builder",
"(",
")",
"put",
"(",
"\"",
"index",
"analysis",
"analyzer",
"no",
"version",
"tokenizer",
"\"",
",",
"\"",
"keyword",
"\"",
")",
"put",
"(",
"\"",
"index",
"analysis",
"analyzer",
"no",
"version",
"char",
"filter",
"\"",
",",
"\"",
"no",
"version",
"\"",
")",
"put",
"(",
"\"",
"index",
"analysis",
"analyzer",
"lucene",
"version",
"tokenizer",
"\"",
",",
"\"",
"keyword",
"\"",
")",
"put",
"(",
"\"",
"index",
"analysis",
"analyzer",
"lucene",
"version",
"char",
"filter",
"\"",
",",
"\"",
"lucene",
"version",
"\"",
")",
"put",
"(",
"\"",
"index",
"analysis",
"analyzer",
"elasticsearch",
"version",
"tokenizer",
"\"",
",",
"\"",
"keyword",
"\"",
")",
"put",
"(",
"\"",
"index",
"analysis",
"analyzer",
"elasticsearch",
"version",
"char",
"filter",
"\"",
",",
"\"",
"elasticsearch",
"version",
"\"",
")",
"put",
"(",
"index",
"metadata",
"setting",
"version",
"created",
",",
"version",
")",
"build",
"(",
")",
")",
";",
"assert",
"token",
"stream",
"contents",
"(",
"analyzers",
"get",
"(",
"\"",
"no",
"version",
"\"",
")",
"token",
"stream",
"(",
"\"",
"\"",
",",
"\"",
"test",
"\"",
")",
",",
"new",
"string",
"[",
"]",
"{",
"\"",
"testno",
"version",
"\"",
"}",
")",
";",
"assert",
"token",
"stream",
"contents",
"(",
"analyzers",
"get",
"(",
"\"",
"lucene",
"version",
"\"",
")",
"token",
"stream",
"(",
"\"",
"\"",
",",
"\"",
"test",
"\"",
")",
",",
"new",
"string",
"[",
"]",
"{",
"\"",
"test",
"\"",
"+",
"version",
"lucene",
"version",
"}",
")",
";",
"assert",
"token",
"stream",
"contents",
"(",
"analyzers",
"get",
"(",
"\"",
"elasticsearch",
"version",
"\"",
")",
"token",
"stream",
"(",
"\"",
"\"",
",",
"\"",
"test",
"\"",
")",
",",
"new",
"string",
"[",
"]",
"{",
"\"",
"test",
"\"",
"+",
"version",
"}",
")",
";",
"assert",
"equals",
"(",
"\"",
"test",
"\"",
"+",
"(",
"no",
"version",
"supports",
"multi",
"term",
"?",
"\"",
"no",
"version",
"\"",
":",
"\"",
"\"",
")",
",",
"analyzers",
"get",
"(",
"\"",
"no",
"version",
"\"",
")",
"normalize",
"(",
"\"",
"\"",
",",
"\"",
"test",
"\"",
")",
"utf",
"8",
"to",
"string",
"(",
")",
")",
";",
"assert",
"equals",
"(",
"\"",
"test",
"\"",
"+",
"(",
"lucene",
"version",
"supports",
"multi",
"term",
"?",
"version",
"lucene",
"version",
"to",
"string",
"(",
")",
":",
"\"",
"\"",
")",
",",
"analyzers",
"get",
"(",
"\"",
"lucene",
"version",
"\"",
")",
"normalize",
"(",
"\"",
"\"",
",",
"\"",
"test",
"\"",
")",
"utf",
"8",
"to",
"string",
"(",
")",
")",
";",
"assert",
"equals",
"(",
"\"",
"test",
"\"",
"+",
"(",
"elasticsearch",
"version",
"supports",
"multi",
"term",
"?",
"version",
"to",
"string",
"(",
")",
":",
"\"",
"\"",
")",
",",
"analyzers",
"get",
"(",
"\"",
"elasticsearch",
"version",
"\"",
")",
"normalize",
"(",
"\"",
"\"",
",",
"\"",
"test",
"\"",
")",
"utf",
"8",
"to",
"string",
"(",
")",
")",
";",
"}"
] |
[
"returns",
"a",
"view",
"of",
"the",
"given",
"character",
"sequence",
"as",
"a",
"{",
"@",
"link",
"char",
"source",
"}",
"the",
"behavior",
"of",
"the",
"returned",
"{",
"@",
"code",
"char",
"source",
"}",
"and",
"any",
"{",
"@",
"code",
"reader",
"}",
"instances",
"created",
"by",
"it",
"is",
"unspecified",
"if",
"the",
"{",
"@",
"code",
"char",
"sequence",
"}",
"is",
"mutated",
"while",
"it",
"is",
"being",
"read",
",",
"so",
"don",
"'",
"t",
"do",
"that"
] |
[
"public",
"static",
"char",
"source",
"wrap",
"(",
"char",
"sequence",
"char",
"sequence",
")",
"{",
"return",
"char",
"sequence",
"instanceof",
"string",
"?",
"new",
"string",
"char",
"source",
"(",
"(",
"string",
")",
"char",
"sequence",
")",
":",
"new",
"char",
"sequence",
"char",
"source",
"(",
"char",
"sequence",
")",
";",
"}"
] |
[
"get",
"my",
"string"
] |
[
"public",
"string",
"get",
"my",
"string",
"(",
")",
"{",
"return",
"my",
"string",
";",
"}"
] |
[
"check",
"that",
"the",
"docker",
"image",
"has",
"the",
"expected",
"\"",
"label",
"schema",
"\"",
"labels"
] |
[
"public",
"void",
"test",
"1",
"1",
"0",
"org",
"label",
"schema",
"labels",
"(",
")",
"throws",
"exception",
"{",
"final",
"map",
"<",
"string",
",",
"string",
">",
"labels",
"=",
"get",
"image",
"labels",
"(",
"distribution",
")",
";",
"final",
"map",
"<",
"string",
",",
"string",
">",
"static",
"labels",
"=",
"new",
"hash",
"map",
"<",
">",
"(",
")",
";",
"static",
"labels",
"put",
"(",
"\"",
"name",
"\"",
",",
"\"",
"elasticsearch",
"\"",
")",
";",
"static",
"labels",
"put",
"(",
"\"",
"schema",
"-",
"version",
"\"",
",",
"\"",
"1",
"0",
"\"",
")",
";",
"static",
"labels",
"put",
"(",
"\"",
"url",
"\"",
",",
"\"",
"https",
":",
"/",
"/",
"www",
"elastic",
"co",
"/",
"products",
"/",
"elasticsearch",
"\"",
")",
";",
"static",
"labels",
"put",
"(",
"\"",
"usage",
"\"",
",",
"\"",
"https",
":",
"/",
"/",
"www",
"elastic",
"co",
"/",
"guide",
"/",
"en",
"/",
"elasticsearch",
"/",
"reference",
"/",
"index",
"html",
"\"",
")",
";",
"static",
"labels",
"put",
"(",
"\"",
"vcs",
"-",
"url",
"\"",
",",
"\"",
"https",
":",
"/",
"/",
"github",
"com",
"/",
"elastic",
"/",
"elasticsearch",
"\"",
")",
";",
"static",
"labels",
"put",
"(",
"\"",
"vendor",
"\"",
",",
"\"",
"elastic",
"\"",
")",
";",
"if",
"(",
"distribution",
"is",
"o",
"s",
"s",
"(",
")",
")",
"{",
"static",
"labels",
"put",
"(",
"\"",
"license",
"\"",
",",
"\"",
"apache",
"-",
"2",
"0",
"\"",
")",
";",
"}",
"else",
"{",
"static",
"labels",
"put",
"(",
"\"",
"license",
"\"",
",",
"\"",
"elastic",
"-",
"license",
"\"",
")",
";",
"}",
"/",
"/",
"todo",
":",
"we",
"should",
"check",
"the",
"actual",
"version",
"value",
"final",
"set",
"<",
"string",
">",
"dynamic",
"labels",
"=",
"set",
"of",
"(",
"\"",
"build",
"-",
"date",
"\"",
",",
"\"",
"vcs",
"-",
"ref",
"\"",
",",
"\"",
"version",
"\"",
")",
";",
"final",
"string",
"prefix",
"=",
"\"",
"org",
"label",
"-",
"schema",
"\"",
";",
"static",
"labels",
"for",
"each",
"(",
"(",
"suffix",
",",
"value",
")",
"-",
">",
"{",
"string",
"key",
"=",
"prefix",
"+",
"\"",
"\"",
"+",
"suffix",
";",
"assert",
"that",
"(",
"labels",
",",
"has",
"key",
"(",
"key",
")",
")",
";",
"assert",
"that",
"(",
"labels",
"get",
"(",
"key",
")",
",",
"equal",
"to",
"(",
"value",
")",
")",
";",
"}",
")",
";",
"dynamic",
"labels",
"for",
"each",
"(",
"label",
"-",
">",
"{",
"string",
"key",
"=",
"prefix",
"+",
"\"",
"\"",
"+",
"label",
";",
"assert",
"that",
"(",
"labels",
",",
"has",
"key",
"(",
"key",
")",
")",
";",
"}",
")",
";",
"}"
] |
[
"this",
"method",
"uses",
"reflection",
"to",
"determine",
"if",
"the",
"two",
"<",
"code",
">",
"object",
"<",
"code",
">",
"s",
"are",
"equal",
"it",
"uses",
"<",
"code",
">",
"accessible",
"object",
"set",
"accessible",
"<",
"code",
">",
"to",
"gain",
"access",
"to",
"private",
"fields",
"this",
"means",
"that",
"it",
"will",
"throw",
"a",
"security",
"exception",
"if",
"run",
"under",
"a",
"security",
"manager",
",",
"if",
"the",
"permissions",
"are",
"not",
"set",
"up",
"correctly",
"it",
"is",
"also",
"not",
"as",
"efficient",
"as",
"testing",
"explicitly",
"transient",
"members",
"will",
"be",
"not",
"be",
"tested",
",",
"as",
"they",
"are",
"likely",
"derived",
"fields",
",",
"and",
"not",
"part",
"of",
"the",
"value",
"of",
"the",
"object",
"static",
"fields",
"will",
"not",
"be",
"tested",
"superclass",
"fields",
"will",
"be",
"included"
] |
[
"public",
"static",
"boolean",
"reflection",
"equals",
"(",
"object",
"lhs",
",",
"object",
"rhs",
",",
"string",
"[",
"]",
"exclude",
"fields",
")",
"{",
"return",
"reflection",
"equals",
"(",
"lhs",
",",
"rhs",
",",
"false",
",",
"null",
",",
"exclude",
"fields",
")",
";",
"}"
] |
[
"renew",
"an",
"existing",
"delegation",
"{",
"@",
"link",
"token",
"}"
] |
[
"public",
"renew",
"delegation",
"token",
"response",
"renew",
"delegation",
"token",
"(",
"renew",
"delegation",
"token",
"request",
"request",
")",
"throws",
"yarn",
"exception",
",",
"i",
"o",
"exception",
";"
] |
[
"only",
"return",
"traces",
"whose",
"{",
"@",
"link",
"span",
"#",
"duration",
"(",
")",
"}",
"is",
"greater",
"than",
"or",
"equal",
"to",
"min",
"duration",
"microseconds"
] |
[
"@",
"nullable",
"public",
"long",
"min",
"duration",
"(",
")",
"{",
"return",
"min",
"duration",
";",
"}"
] |
[
"getter",
"for",
"use",
"native",
"code",
"option"
] |
[
"public",
"static",
"boolean",
"get",
"use",
"native",
"code",
"(",
")",
"{",
"return",
"s",
"use",
"native",
"code",
";",
"}"
] |
[
"append",
"additional",
"metadata",
"entries",
"through",
"a",
"{",
"@",
"code",
"consumer",
"}",
"this",
"enables",
"libraries",
"such",
"as",
"spring",
"security",
"to",
"provide",
"shortcuts",
"for",
"applying",
"a",
"set",
"of",
"customizations"
] |
[
"request",
"spec",
"metadata",
"(",
"consumer",
"<",
"metadata",
"spec",
"<",
"?",
">",
">",
"configurer",
")",
";"
] |
[
"get",
"the",
"current",
"cursor",
"value"
] |
[
"long",
"get",
"cursor",
"(",
")",
";"
] |
[
"if",
"true",
",",
"then",
"memory",
"blocks",
"should",
"be",
"readwritten"
] |
[
"public",
"boolean",
"is",
"memory",
"blocks",
"(",
")",
"{",
"return",
"memory",
"blocks",
";",
"}"
] |
[
"add",
"element",
",",
"and",
"propagate",
"it",
"to",
"any",
"(",
"transitive",
")",
"dependers",
"on",
"this",
"objc",
"provider"
] |
[
"public",
"<",
"e",
">",
"builder",
"add",
"(",
"key",
"<",
"e",
">",
"key",
",",
"e",
"to",
"add",
")",
"{",
"unchecked",
"add",
"all",
"(",
"key",
",",
"immutable",
"list",
"of",
"(",
"to",
"add",
")",
")",
";",
"return",
"this",
";",
"}"
] |
[
"this",
"is",
"called",
"when",
"recoverable",
"exceptions",
"happen",
"at",
"runtime",
"they",
"can",
"be",
"ignored",
"and",
"epoxy",
"will",
"recover",
",",
"but",
"you",
"can",
"override",
"this",
"to",
"be",
"aware",
"of",
"when",
"they",
"happen"
] |
[
"protected",
"void",
"on",
"exception",
"swallowed",
"(",
"runtime",
"exception",
"exception",
")",
"{",
"}"
] |
[
"returns",
"true",
"if",
"this",
"version",
"file",
"will",
"accept",
"old",
"buffer",
"data",
"for",
"the",
"specified",
"buffer",
"index"
] |
[
"public",
"boolean",
"is",
"put",
"o",
"k",
"(",
"int",
"index",
")",
"{",
"return",
"(",
"index",
">",
"=",
"0",
"&",
"&",
"index",
"<",
"original",
"buf",
"count",
"&",
"&",
"!",
"buffer",
"index",
"map",
"contains",
"(",
"index",
")",
"&",
"&",
"!",
"is",
"free",
"index",
"(",
"index",
")",
")",
";",
"}"
] |
[
"return",
"the",
"strategy",
"to",
"use",
"for",
"resolving",
"errors",
"into",
"message",
"codes"
] |
[
"public",
"message",
"codes",
"resolver",
"get",
"message",
"codes",
"resolver",
"(",
")",
"{",
"return",
"this",
"message",
"codes",
"resolver",
";",
"}"
] |
[
"convert",
"the",
"given",
"object",
"to",
"string",
"with",
"each",
"line",
"indented",
"by",
"4",
"spaces",
"(",
"except",
"the",
"first",
"line",
")"
] |
[
"private",
"string",
"to",
"indented",
"string",
"(",
"object",
"o",
")",
"{",
"if",
"(",
"o",
"=",
"=",
"null",
")",
"{",
"return",
"\"",
"null",
"\"",
";",
"}",
"return",
"o",
"to",
"string",
"(",
")",
"replace",
"(",
"\"",
"\\",
"n",
"\"",
",",
"\"",
"\\",
"n",
"\"",
")",
";",
"}"
] |
[
"build",
"a",
"ellipse"
] |
[
"public",
"static",
"void",
"build",
"(",
"mesh",
"part",
"builder",
"builder",
",",
"float",
"width",
",",
"float",
"height",
",",
"int",
"divisions",
",",
"float",
"center",
"x",
",",
"float",
"center",
"y",
",",
"float",
"center",
"z",
",",
"float",
"normal",
"x",
",",
"float",
"normal",
"y",
",",
"float",
"normal",
"z",
",",
"float",
"angle",
"from",
",",
"float",
"angle",
"to",
")",
"{",
"build",
"(",
"builder",
",",
"width",
",",
"height",
",",
"0f",
",",
"0f",
",",
"divisions",
",",
"center",
"x",
",",
"center",
"y",
",",
"center",
"z",
",",
"normal",
"x",
",",
"normal",
"y",
",",
"normal",
"z",
",",
"angle",
"from",
",",
"angle",
"to",
")",
";",
"}"
] |
[
"builds",
"a",
"gl",
"shader",
"program",
"from",
"vertex",
"and",
"fragment",
"shader",
"code"
] |
[
"public",
"static",
"int",
"compile",
"program",
"(",
"string",
"vertex",
"code",
",",
"string",
"fragment",
"code",
")",
"{",
"int",
"program",
"=",
"gles20",
"gl",
"create",
"program",
"(",
")",
";",
"check",
"gl",
"error",
"(",
")",
";",
"/",
"/",
"add",
"the",
"vertex",
"and",
"fragment",
"shaders",
"add",
"shader",
"(",
"gles20",
"gl",
"vertex",
"shader",
",",
"vertex",
"code",
",",
"program",
")",
";",
"add",
"shader",
"(",
"gles20",
"gl",
"fragment",
"shader",
",",
"fragment",
"code",
",",
"program",
")",
";",
"/",
"/",
"link",
"and",
"check",
"for",
"errors",
"gles20",
"gl",
"link",
"program",
"(",
"program",
")",
";",
"int",
"[",
"]",
"link",
"status",
"=",
"new",
"int",
"[",
"]",
"{",
"gles20",
"gl",
"false",
"}",
";",
"gles20",
"gl",
"get",
"programiv",
"(",
"program",
",",
"gles20",
"gl",
"link",
"status",
",",
"link",
"status",
",",
"0",
")",
";",
"if",
"(",
"link",
"status",
"[",
"0",
"]",
"!",
"=",
"gles20",
"gl",
"true",
")",
"{",
"throw",
"gl",
"error",
"(",
"\"",
"unable",
"to",
"link",
"shader",
"program",
":",
"\\",
"n",
"\"",
"+",
"gles20",
"gl",
"get",
"program",
"info",
"log",
"(",
"program",
")",
")",
";",
"}",
"check",
"gl",
"error",
"(",
")",
";",
"return",
"program",
";",
"}"
] |
[
"verifies",
"that",
"the",
"input",
"entered",
"by",
"the",
"user",
"is",
"valid",
"meaning",
":",
"the",
"string",
"represents",
"a",
"hex",
"or",
"binary",
"number",
"the",
"string",
"contains",
"only",
"full",
"bytes"
] |
[
"public",
"boolean",
"validate",
"input",
"(",
")",
"{",
"return",
"validate",
"input",
"(",
"input",
"bytes",
"t",
"a",
"get",
"text",
"(",
")",
")",
";",
"}"
] |
[
"propagates",
"{",
"@",
"code",
"throwable",
"}",
"exactly",
"as",
"-",
"is",
",",
"if",
"and",
"only",
"if",
"it",
"is",
"an",
"instance",
"of",
"{",
"@",
"link",
"runtime",
"exception",
"}",
"or",
"{",
"@",
"link",
"error",
"}",
"example",
"usage",
":",
"try",
"{",
"some",
"method",
"that",
"could",
"throw",
"anything",
"(",
")",
";",
"}",
"catch",
"(",
"i",
"know",
"what",
"to",
"do",
"with",
"this",
"exception",
"e",
")",
"{",
"handle",
"(",
"e",
")",
";",
"}",
"catch",
"(",
"throwable",
"t",
")",
"{",
"throwables",
"propagate",
"if",
"possible",
"(",
"t",
")",
";",
"throw",
"new",
"runtime",
"exception",
"(",
"\"",
"unexpected",
"\"",
",",
"t",
")",
";",
"}"
] |
[
"public",
"static",
"void",
"propagate",
"if",
"possible",
"(",
"@",
"nullable",
"throwable",
"throwable",
")",
"{",
"if",
"(",
"throwable",
"!",
"=",
"null",
")",
"{",
"throw",
"if",
"unchecked",
"(",
"throwable",
")",
";",
"}",
"}"
] |
[
"creates",
"a",
"zip",
"archive",
"from",
"all",
"found",
"r",
"java",
"files"
] |
[
"public",
"static",
"void",
"create",
"src",
"jar",
"(",
"path",
"generated",
"sources",
"root",
",",
"path",
"src",
"jar",
",",
"boolean",
"static",
"ids",
")",
"{",
"try",
"{",
"files",
"create",
"directories",
"(",
"src",
"jar",
"get",
"parent",
"(",
")",
")",
";",
"try",
"(",
"final",
"zip",
"builder",
"zip",
"=",
"zip",
"builder",
"create",
"for",
"(",
"src",
"jar",
")",
")",
"{",
"symbol",
"file",
"src",
"jar",
"building",
"visitor",
"visitor",
"=",
"new",
"symbol",
"file",
"src",
"jar",
"building",
"visitor",
"(",
"zip",
",",
"generated",
"sources",
"root",
",",
"static",
"ids",
")",
";",
"files",
"walk",
"file",
"tree",
"(",
"generated",
"sources",
"root",
",",
"visitor",
")",
";",
"visitor",
"write",
"entries",
"(",
")",
";",
"}",
"}",
"catch",
"(",
"i",
"o",
"exception",
"e",
")",
"{",
"throw",
"new",
"runtime",
"exception",
"(",
"e",
")",
";",
"}",
"}"
] |
[
"test",
"the",
"property",
"'",
"enum",
"number",
"'"
] |
[
"public",
"void",
"enum",
"number",
"test",
"(",
")",
"{",
"/",
"/",
"todo",
":",
"test",
"enum",
"number",
"}"
] |
[
"get",
"the",
"adjusted",
"symbol",
"value",
"based",
"upon",
"its",
"placement",
"within",
"the",
"program",
"this",
"value",
"may",
"differ",
"from",
"symbol",
"get",
"value",
"(",
")",
"and",
"will",
"reflect",
"the",
"addressable",
"unitword",
"offset",
"of",
"it",
"program",
"address"
] |
[
"public",
"long",
"get",
"symbol",
"value",
"(",
"elf",
"symbol",
"symbol",
")",
"{",
"address",
"sym",
"addr",
"=",
"symbol",
"map",
"get",
"(",
"symbol",
")",
";",
"return",
"sym",
"addr",
"!",
"=",
"null",
"?",
"sym",
"addr",
"get",
"addressable",
"word",
"offset",
"(",
")",
":",
"0",
";",
"}"
] |
[
"case",
"-",
"insensitive",
"from",
"string",
"method",
"works",
"with",
"either",
"all",
",",
"all",
",",
"etc"
] |
[
"public",
"static",
"exclude",
"frequent",
"for",
"string",
"(",
"string",
"value",
")",
"{",
"return",
"value",
"of",
"(",
"value",
"to",
"upper",
"case",
"(",
"locale",
"root",
")",
")",
";",
"}"
] |
[
"number",
"of",
"slots",
"at",
"<",
"code",
">",
"level",
"<",
"code",
">"
] |
[
"private",
"static",
"int",
"num",
"slots",
"(",
"int",
"level",
")",
"{",
"return",
"1",
"<",
"<",
"level",
";",
"}"
] |
[
"closes",
"the",
"underlying",
"stream",
",",
"following",
"writes",
"will",
"fail"
] |
[
"void",
"close",
"(",
")",
"throws",
"i",
"o",
"exception",
";"
] |
[
"called",
"when",
"an",
"initializing",
"replica",
"is",
"reinitialized",
"this",
"happens",
"when",
"a",
"primary",
"relocation",
"completes",
",",
"which",
"reinitializes",
"all",
"currently",
"initializing",
"replicas",
"as",
"their",
"recovery",
"source",
"node",
"changes"
] |
[
"void",
"initialized",
"replica",
"reinitialized",
"(",
"shard",
"routing",
"old",
"replica",
",",
"shard",
"routing",
"reinitialized",
"replica",
")",
";"
] |
[
"resets",
"a",
"to",
"-",
"many",
"relationship",
",",
"making",
"the",
"next",
"get",
"call",
"to",
"query",
"for",
"a",
"fresh",
"result"
] |
[
"public",
"synchronized",
"void",
"reset",
"to",
"many",
"join",
"two",
"(",
")",
"{",
"to",
"many",
"join",
"two",
"=",
"null",
";",
"}"
] |
[
"test",
"the",
"property",
"'",
"id",
"'"
] |
[
"public",
"void",
"id",
"test",
"(",
")",
"{",
"/",
"/",
"todo",
":",
"test",
"id",
"}"
] |
[
"report",
"the",
"class",
"not",
"found",
"if",
"this",
"exception",
"or",
"any",
"of",
"its",
"causes",
"or",
"suppressed",
"exceptions",
"is",
"related",
"to",
"missed",
"classes"
] |
[
"public",
"static",
"void",
"report",
"exception",
"inside",
"(",
"@",
"non",
"null",
"throwable",
"e",
")",
"{",
"if",
"(",
"enabled",
"(",
")",
")",
"{",
"/",
"/",
"use",
"a",
"set",
"with",
"equity",
"based",
"on",
"=",
"=",
"instead",
"of",
"equal",
"to",
"find",
"cycles",
"set",
"<",
"throwable",
">",
"exceptions",
"reviewed",
"=",
"collections",
"new",
"set",
"from",
"map",
"(",
"new",
"identity",
"hash",
"map",
"<",
">",
"(",
")",
")",
";",
"report",
"exception",
"inside",
"(",
"e",
",",
"exceptions",
"reviewed",
")",
";",
"}",
"}"
] |
[
"transfers",
"this",
"buffer",
"'",
"s",
"data",
"to",
"a",
"newly",
"created",
"buffer",
"starting",
"at",
"the",
"current",
"{",
"@",
"code",
"reader",
"index",
"}",
"and",
"increases",
"the",
"{",
"@",
"code",
"reader",
"index",
"}",
"by",
"the",
"number",
"of",
"the",
"transferred",
"bytes",
"(",
"=",
"{",
"@",
"code",
"length",
"}",
")",
"the",
"returned",
"buffer",
"'",
"s",
"{",
"@",
"code",
"reader",
"index",
"}",
"and",
"{",
"@",
"code",
"writer",
"index",
"}",
"are",
"{",
"@",
"code",
"0",
"}",
"and",
"{",
"@",
"code",
"length",
"}",
"respectively"
] |
[
"public",
"abstract",
"byte",
"buf",
"read",
"bytes",
"(",
"int",
"length",
")",
";"
] |
[
"fix",
"for",
"flink",
"-",
"2019"
] |
[
"public",
"void",
"test",
"jodatime",
"date",
"time",
"with",
"kryo",
"(",
")",
"throws",
"exception",
"{",
"final",
"execution",
"environment",
"env",
"=",
"execution",
"environment",
"get",
"execution",
"environment",
"(",
")",
";",
"data",
"set",
"<",
"tuple",
"2",
"<",
"integer",
",",
"date",
"time",
">",
">",
"ds",
"=",
"env",
"from",
"elements",
"(",
"new",
"tuple",
"2",
"<",
">",
"(",
"1",
",",
"date",
"time",
"now",
"(",
")",
")",
")",
";",
"data",
"set",
"<",
"tuple",
"2",
"<",
"integer",
",",
"date",
"time",
">",
">",
"reduce",
"ds",
"=",
"ds",
"group",
"by",
"(",
"\"",
"f",
"1",
"\"",
")",
"sum",
"(",
"0",
")",
"project",
"(",
"0",
")",
";",
"list",
"<",
"tuple",
"2",
"<",
"integer",
",",
"date",
"time",
">",
">",
"result",
"=",
"reduce",
"ds",
"collect",
"(",
")",
";",
"string",
"expected",
"=",
"\"",
"1",
"\\",
"n",
"\"",
";",
"compare",
"result",
"as",
"tuples",
"(",
"result",
",",
"expected",
")",
";",
"}"
] |
[
"is",
"timeout",
"boolean"
] |
[
"public",
"boolean",
"is",
"timeout",
"(",
")",
"{",
"return",
"system",
"current",
"time",
"millis",
"(",
")",
"-",
"start",
">",
"timeout",
";",
"}"
] |
[
"like",
"gallop",
"left",
",",
"except",
"that",
"if",
"the",
"range",
"contains",
"an",
"element",
"equal",
"to",
"key",
",",
"gallop",
"right",
"returns",
"the",
"index",
"after",
"the",
"rightmost",
"equal",
"element"
] |
[
"private",
"static",
"int",
"gallop",
"right",
"(",
"comparable",
"<",
"object",
">",
"key",
",",
"object",
"[",
"]",
"a",
",",
"int",
"base",
",",
"int",
"len",
",",
"int",
"hint",
")",
"{",
"if",
"(",
"debug",
")",
"assert",
"len",
">",
"0",
"&",
"&",
"hint",
">",
"=",
"0",
"&",
"&",
"hint",
"<",
"len",
";",
"int",
"ofs",
"=",
"1",
";",
"int",
"last",
"ofs",
"=",
"0",
";",
"if",
"(",
"key",
"compare",
"to",
"(",
"a",
"[",
"base",
"+",
"hint",
"]",
")",
"<",
"0",
")",
"{",
"/",
"/",
"gallop",
"left",
"until",
"a",
"[",
"b",
"+",
"hint",
"-",
"ofs",
"]",
"<",
"=",
"key",
"<",
"a",
"[",
"b",
"+",
"hint",
"-",
"last",
"ofs",
"]",
"int",
"max",
"ofs",
"=",
"hint",
"+",
"1",
";",
"while",
"(",
"ofs",
"<",
"max",
"ofs",
"&",
"&",
"key",
"compare",
"to",
"(",
"a",
"[",
"base",
"+",
"hint",
"-",
"ofs",
"]",
")",
"<",
"0",
")",
"{",
"last",
"ofs",
"=",
"ofs",
";",
"ofs",
"=",
"(",
"ofs",
"<",
"<",
"1",
")",
"+",
"1",
";",
"if",
"(",
"ofs",
"<",
"=",
"0",
")",
"/",
"/",
"int",
"overflow",
"ofs",
"=",
"max",
"ofs",
";",
"}",
"if",
"(",
"ofs",
">",
"max",
"ofs",
")",
"ofs",
"=",
"max",
"ofs",
";",
"/",
"/",
"make",
"offsets",
"relative",
"to",
"b",
"int",
"tmp",
"=",
"last",
"ofs",
";",
"last",
"ofs",
"=",
"hint",
"-",
"ofs",
";",
"ofs",
"=",
"hint",
"-",
"tmp",
";",
"}",
"else",
"{",
"/",
"/",
"a",
"[",
"b",
"+",
"hint",
"]",
"<",
"=",
"key",
"/",
"/",
"gallop",
"right",
"until",
"a",
"[",
"b",
"+",
"hint",
"+",
"last",
"ofs",
"]",
"<",
"=",
"key",
"<",
"a",
"[",
"b",
"+",
"hint",
"+",
"ofs",
"]",
"int",
"max",
"ofs",
"=",
"len",
"-",
"hint",
";",
"while",
"(",
"ofs",
"<",
"max",
"ofs",
"&",
"&",
"key",
"compare",
"to",
"(",
"a",
"[",
"base",
"+",
"hint",
"+",
"ofs",
"]",
")",
">",
"=",
"0",
")",
"{",
"last",
"ofs",
"=",
"ofs",
";",
"ofs",
"=",
"(",
"ofs",
"<",
"<",
"1",
")",
"+",
"1",
";",
"if",
"(",
"ofs",
"<",
"=",
"0",
")",
"/",
"/",
"int",
"overflow",
"ofs",
"=",
"max",
"ofs",
";",
"}",
"if",
"(",
"ofs",
">",
"max",
"ofs",
")",
"ofs",
"=",
"max",
"ofs",
";",
"/",
"/",
"make",
"offsets",
"relative",
"to",
"b",
"last",
"ofs",
"+",
"=",
"hint",
";",
"ofs",
"+",
"=",
"hint",
";",
"}",
"if",
"(",
"debug",
")",
"assert",
"-",
"1",
"<",
"=",
"last",
"ofs",
"&",
"&",
"last",
"ofs",
"<",
"ofs",
"&",
"&",
"ofs",
"<",
"=",
"len",
";",
"/",
"*",
"*",
"now",
"a",
"[",
"b",
"+",
"last",
"ofs",
"]",
"<",
"=",
"key",
"<",
"a",
"[",
"b",
"+",
"ofs",
"]",
",",
"so",
"key",
"belongs",
"somewhere",
"to",
"the",
"right",
"of",
"last",
"ofs",
"but",
"no",
"farther",
"right",
"than",
"ofs",
"*",
"do",
"a",
"binary",
"search",
",",
"with",
"invariant",
"a",
"[",
"b",
"+",
"last",
"ofs",
"-",
"1",
"]",
"<",
"=",
"key",
"<",
"a",
"[",
"b",
"+",
"ofs",
"]",
"*",
"/",
"last",
"ofs",
"+",
"+",
";",
"while",
"(",
"last",
"ofs",
"<",
"ofs",
")",
"{",
"int",
"m",
"=",
"last",
"ofs",
"+",
"(",
"(",
"ofs",
"-",
"last",
"ofs",
")",
">",
">",
">",
"1",
")",
";",
"if",
"(",
"key",
"compare",
"to",
"(",
"a",
"[",
"base",
"+",
"m",
"]",
")",
"<",
"0",
")",
"ofs",
"=",
"m",
";",
"/",
"/",
"key",
"<",
"a",
"[",
"b",
"+",
"m",
"]",
"else",
"last",
"ofs",
"=",
"m",
"+",
"1",
";",
"/",
"/",
"a",
"[",
"b",
"+",
"m",
"]",
"<",
"=",
"key",
"}",
"if",
"(",
"debug",
")",
"assert",
"last",
"ofs",
"=",
"=",
"ofs",
";",
"/",
"/",
"so",
"a",
"[",
"b",
"+",
"ofs",
"-",
"1",
"]",
"<",
"=",
"key",
"<",
"a",
"[",
"b",
"+",
"ofs",
"]",
"return",
"ofs",
";",
"}"
] |
[
"delete",
"storeorder",
"{",
"order",
"id",
"}",
":",
"delete",
"purchase",
"order",
"by",
"id",
"for",
"valid",
"response",
"try",
"integer",
"i",
"ds",
"with",
"value",
"&",
"lt",
";",
"1000",
"anything",
"above",
"1000",
"or",
"nonintegers",
"will",
"generate",
"api",
"errors"
] |
[
"default",
"mono",
"<",
"response",
"entity",
"<",
"void",
">",
">",
"delete",
"order",
"(",
"@",
"api",
"param",
"(",
"value",
"=",
"\"",
"id",
"of",
"the",
"order",
"that",
"needs",
"to",
"be",
"deleted",
"\"",
",",
"required",
"=",
"true",
")",
"@",
"path",
"variable",
"(",
"\"",
"order",
"id",
"\"",
")",
"string",
"order",
"id",
",",
"@",
"api",
"ignore",
"final",
"server",
"web",
"exchange",
"exchange",
")",
"{",
"return",
"get",
"delegate",
"(",
")",
"delete",
"order",
"(",
"order",
"id",
",",
"exchange",
")",
";",
"}"
] |
[
"get",
"address",
"list",
"of",
"members"
] |
[
"public",
"static",
"list",
"<",
"string",
">",
"simple",
"members",
"(",
"collection",
"<",
"member",
">",
"members",
")",
"{",
"return",
"members",
"stream",
"(",
")",
"map",
"(",
"member",
":",
":",
"get",
"address",
")",
"sorted",
"(",
")",
"collect",
"(",
"array",
"list",
":",
":",
"new",
",",
"array",
"list",
":",
":",
"add",
",",
"array",
"list",
":",
":",
"add",
"all",
")",
";",
"}"
] |
[
"implementation",
"note",
":",
"we",
"currently",
"chose",
"the",
"same",
"format",
"between",
"{",
"@",
"link",
"nested",
"maps",
"state",
"table",
"}",
"and",
"{",
"@",
"link",
"copy",
"on",
"write",
"state",
"table",
"}",
"{",
"@",
"link",
"nested",
"maps",
"state",
"table",
"}",
"could",
"naturally",
"support",
"a",
"kind",
"of",
"prefix",
"-",
"compressed",
"format",
"(",
"grouping",
"by",
"namespace",
",",
"writing",
"the",
"namespace",
"only",
"once",
"per",
"group",
"instead",
"for",
"each",
"mapping",
")",
"we",
"might",
"implement",
"support",
"for",
"different",
"formats",
"later",
"(",
"tailored",
"towards",
"different",
"state",
"table",
"implementations",
")"
] |
[
"public",
"void",
"write",
"state",
"in",
"key",
"group",
"(",
"@",
"nonnull",
"data",
"output",
"view",
"dov",
",",
"int",
"key",
"group",
"id",
")",
"throws",
"i",
"o",
"exception",
"{",
"state",
"map",
"snapshot",
"<",
"k",
",",
"n",
",",
"s",
",",
"?",
"extends",
"state",
"map",
"<",
"k",
",",
"n",
",",
"s",
">",
">",
"state",
"map",
"snapshot",
"=",
"get",
"state",
"map",
"snapshot",
"for",
"key",
"group",
"(",
"key",
"group",
"id",
")",
";",
"state",
"map",
"snapshot",
"write",
"state",
"(",
"local",
"key",
"serializer",
",",
"local",
"namespace",
"serializer",
",",
"local",
"state",
"serializer",
",",
"dov",
",",
"state",
"snapshot",
"transformer",
")",
";",
"state",
"map",
"snapshot",
"release",
"(",
")",
";",
"}"
] |
[
"executes",
"a",
"{",
"@",
"link",
"file",
"system",
"access",
"file",
"system",
"executor",
"}",
"using",
"a",
"filesystem",
"for",
"the",
"effective",
"user"
] |
[
"private",
"<",
"t",
">",
"t",
"fs",
"execute",
"(",
"user",
"group",
"information",
"ugi",
",",
"file",
"system",
"access",
"file",
"system",
"executor",
"<",
"t",
">",
"executor",
")",
"throws",
"i",
"o",
"exception",
",",
"file",
"system",
"access",
"exception",
"{",
"file",
"system",
"access",
"fs",
"access",
"=",
"http",
"f",
"s",
"server",
"web",
"app",
"get",
"(",
")",
"get",
"(",
"file",
"system",
"access",
"class",
")",
";",
"configuration",
"conf",
"=",
"http",
"f",
"s",
"server",
"web",
"app",
"get",
"(",
")",
"get",
"(",
"file",
"system",
"access",
"class",
")",
"get",
"file",
"system",
"configuration",
"(",
")",
";",
"return",
"fs",
"access",
"execute",
"(",
"ugi",
"get",
"short",
"user",
"name",
"(",
")",
",",
"conf",
",",
"executor",
")",
";",
"}"
] |
[
"the",
"value",
"assigned",
"to",
"this",
"plural",
"<",
"code",
">",
"optional",
"aapt",
"pb",
"item",
"item",
"=",
"4",
";",
"<",
"code",
">"
] |
[
"public",
"builder",
"set",
"item",
"(",
"com",
"android",
"aapt",
"resources",
"item",
"builder",
"builder",
"for",
"value",
")",
"{",
"copy",
"on",
"write",
"(",
")",
";",
"instance",
"set",
"item",
"(",
"builder",
"for",
"value",
")",
";",
"return",
"this",
";",
"}"
] |
[
"returns",
"true",
"if",
"{",
"@",
"code",
"file",
"name",
"}",
"names",
"a",
"zip",
",",
"jar",
",",
"or",
"apk"
] |
[
"public",
"static",
"boolean",
"has",
"archive",
"suffix",
"(",
"string",
"file",
"name",
")",
"{",
"return",
"file",
"name",
"ends",
"with",
"(",
"\"",
"zip",
"\"",
")",
"|",
"|",
"file",
"name",
"ends",
"with",
"(",
"\"",
"jar",
"\"",
")",
"|",
"|",
"file",
"name",
"ends",
"with",
"(",
"\"",
"apk",
"\"",
")",
";",
"}"
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.